#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winver.h"
#include "dbghelp.h"
#include "objbase.h"
#include "oaidl.h"
#include "winnls.h"
#include "wine/list.h"
#include "wine/rbtree.h"
#include "cvconst.h"

Include dependency graph for dbghelp_private.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	pool

class	vector< _Tp, >

struct	sparse_array

struct	hash_table_elt

struct	hash_table_bucket

struct	hash_table

struct	hash_table_iter

struct	location

struct	symt

struct	symt_ht

struct	symt_block

struct	symt_compiland

struct	symt_data

struct	symt_function

struct	symt_hierarchy_point

struct	symt_public

struct	symt_thunk

struct	symt_array

struct	symt_basic

struct	symt_enum

struct	symt_function_signature

struct	symt_function_arg_type

struct	symt_pointer

struct	symt_typedef

struct	symt_udt

struct	module_format

struct	module

struct	loader_ops

struct	process

struct	line_info

struct	module_pair

struct	pdb_lookup

struct	cpu_stack_walk

struct	dump_memory

struct	dump_memory64

struct	dump_module

struct	dump_thread

struct	dump_context

union	ctx

struct	cpu

struct	_PEB32

struct	pdb_cmd_pair

Typedefs
typedef BOOL(*	enum_modules_cb) (const WCHAR , ULONG_PTR addr, void user)

typedef struct _PEB32	PEB32

typedef void(*	stabs_def_cb) (struct module module, ULONG_PTR load_offset, const char name, ULONG_PTR offset, BOOL is_public, BOOL is_global, unsigned char other, struct symt_compiland compiland, void user)

Enumerations
enum	location_kind { loc_error , loc_unavailable , loc_absolute , loc_register , loc_regrel , loc_tlsrel , loc_user }

enum	location_error { loc_err_internal = -1 , loc_err_too_complex = -2 , loc_err_out_of_scope = -3 , loc_err_cant_read = -4 , loc_err_no_location = -5 }

enum	module_type { DMT_UNKNOWN , DMT_ELF , DMT_PE , DMT_MACHO , DMT_PDB , DMT_DBG }

enum	format_info { DFI_ELF , DFI_PE , DFI_MACHO , DFI_DWARF , DFI_PDB , DFI_LAST }

enum	pdb_kind { PDB_JG , PDB_DS }

enum	cpu_addr { cpu_addr_pc , cpu_addr_stack , cpu_addr_frame }

Functions
void	pool_init (struct pool *a, size_t arena_size) DECLSPEC_HIDDEN

void	pool_destroy (struct pool *a) DECLSPEC_HIDDEN

void *	pool_alloc (struct pool *a, size_t len) DECLSPEC_HIDDEN

char *	pool_strdup (struct pool a, const char str) DECLSPEC_HIDDEN

void	vector_init (struct vector *v, unsigned elt_sz, unsigned bucket_sz) DECLSPEC_HIDDEN

unsigned	vector_length (const struct vector *v) DECLSPEC_HIDDEN

void *	vector_at (const struct vector *v, unsigned pos) DECLSPEC_HIDDEN

void *	vector_add (struct vector v, struct pool pool) DECLSPEC_HIDDEN

void	sparse_array_init (struct sparse_array *sa, unsigned elt_sz, unsigned bucket_sz) DECLSPEC_HIDDEN

void *	sparse_array_find (const struct sparse_array *sa, ULONG_PTR idx) DECLSPEC_HIDDEN

void *	sparse_array_add (struct sparse_array sa, ULONG_PTR key, struct pool pool) DECLSPEC_HIDDEN

unsigned	sparse_array_length (const struct sparse_array *sa) DECLSPEC_HIDDEN

void	hash_table_init (struct pool pool, struct hash_table ht, unsigned num_buckets) DECLSPEC_HIDDEN

void	hash_table_destroy (struct hash_table *ht) DECLSPEC_HIDDEN

void	hash_table_add (struct hash_table ht, struct hash_table_elt elt) DECLSPEC_HIDDEN

void	hash_table_iter_init (const struct hash_table ht, struct hash_table_iter hti, const char *name) DECLSPEC_HIDDEN

void *	hash_table_iter_up (struct hash_table_iter *hti) DECLSPEC_HIDDEN

static BOOL	read_process_memory (const struct process process, UINT64 addr, void buf, size_t size)

struct process *	process_find_by_handle (HANDLE hProcess) DECLSPEC_HIDDEN

BOOL	validate_addr64 (DWORD64 addr) DECLSPEC_HIDDEN

BOOL	pcs_callback (const struct process pcs, ULONG action, void data) DECLSPEC_HIDDEN

void *	fetch_buffer (struct process *pcs, unsigned size) DECLSPEC_HIDDEN

const char *	wine_dbgstr_addr (const ADDRESS64 *addr) DECLSPEC_HIDDEN

struct cpu *	cpu_find (DWORD) DECLSPEC_HIDDEN

const WCHAR *	process_getenv (const struct process process, const WCHAR name)

DWORD	calc_crc32 (HANDLE handle) DECLSPEC_HIDDEN

BOOL	elf_read_wine_loader_dbg_info (struct process *pcs, ULONG_PTR addr) DECLSPEC_HIDDEN

int	elf_is_in_thunk_area (ULONG_PTR addr, const struct elf_thunk_area *thunks) DECLSPEC_HIDDEN

BOOL	macho_read_wine_loader_dbg_info (struct process *pcs, ULONG_PTR addr) DECLSPEC_HIDDEN

void	minidump_add_memory_block (struct dump_context *dc, ULONG64 base, ULONG size, ULONG rva) DECLSPEC_HIDDEN

struct module *	module_find_by_addr (const struct process *pcs, DWORD64 addr, enum module_type type) DECLSPEC_HIDDEN

struct module *	module_find_by_nameW (const struct process pcs, const WCHAR name) DECLSPEC_HIDDEN

struct module *	module_find_by_nameA (const struct process pcs, const char name) DECLSPEC_HIDDEN

struct module *	module_is_already_loaded (const struct process pcs, const WCHAR imgname) DECLSPEC_HIDDEN

BOOL	module_get_debug (struct module_pair *) DECLSPEC_HIDDEN

struct module *	module_new (struct process pcs, const WCHAR name, enum module_type type, BOOL virtual, DWORD64 addr, DWORD64 size, ULONG_PTR stamp, ULONG_PTR checksum) DECLSPEC_HIDDEN

struct module *	module_get_containee (const struct process pcs, const struct module inner) DECLSPEC_HIDDEN

void	module_reset_debug_info (struct module *module) DECLSPEC_HIDDEN

BOOL	module_remove (struct process pcs, struct module module) DECLSPEC_HIDDEN

void	module_set_module (struct module module, const WCHAR name) DECLSPEC_HIDDEN

WCHAR *	get_wine_loader_name (struct process *pcs) DECLSPEC_HIDDEN

BOOL	pe_load_debug_directory (const struct process pcs, struct module module, const BYTE mapping, const IMAGE_SECTION_HEADER sectp, DWORD nsect, const IMAGE_DEBUG_DIRECTORY *dbg, int nDbg) DECLSPEC_HIDDEN

BOOL	pdb_fetch_file_info (const struct pdb_lookup pdb_lookup, unsigned matched) DECLSPEC_HIDDEN

BOOL	pdb_virtual_unwind (struct cpu_stack_walk csw, DWORD_PTR ip, union ctx context, struct pdb_cmd_pair *cpair) DECLSPEC_HIDDEN

BOOL	path_find_symbol_file (const struct process pcs, const struct module module, PCSTR full_path, enum module_type type, const GUID guid, DWORD dw1, DWORD dw2, WCHAR buffer, BOOL *is_unmatched) DECLSPEC_HIDDEN

WCHAR *	get_dos_file_name (const WCHAR *filename) DECLSPEC_HIDDEN

BOOL	search_dll_path (const struct process process, const WCHAR name, BOOL(match)(void , HANDLE, const WCHAR ), void param) DECLSPEC_HIDDEN

BOOL	search_unix_path (const WCHAR name, const WCHAR path, BOOL(match)(void , HANDLE, const WCHAR ), void param) DECLSPEC_HIDDEN

const WCHAR *	file_name (const WCHAR *str) DECLSPEC_HIDDEN

const char *	file_nameA (const char *str) DECLSPEC_HIDDEN

BOOL	pe_load_nt_header (HANDLE hProc, DWORD64 base, IMAGE_NT_HEADERS *nth) DECLSPEC_HIDDEN

struct module *	pe_load_native_module (struct process pcs, const WCHAR name, HANDLE hFile, DWORD64 base, DWORD size) DECLSPEC_HIDDEN

struct module *	pe_load_builtin_module (struct process pcs, const WCHAR name, DWORD64 base, DWORD64 size) DECLSPEC_HIDDEN

BOOL	pe_load_debug_info (const struct process pcs, struct module module) DECLSPEC_HIDDEN

const char *	pe_map_directory (struct module module, int dirno, DWORD size) DECLSPEC_HIDDEN

unsigned	source_new (struct module module, const char basedir, const char *source) DECLSPEC_HIDDEN

const char *	source_get (const struct module *module, unsigned idx) DECLSPEC_HIDDEN

int	source_rb_compare (const void key, const struct wine_rb_entry entry) DECLSPEC_HIDDEN

BOOL	stabs_parse (struct module module, ULONG_PTR load_offset, const char stabs, size_t nstab, size_t stabsize, const char strs, int strtablen, stabs_def_cb callback, void user) DECLSPEC_HIDDEN

BOOL	dwarf2_parse (struct module module, ULONG_PTR load_offset, const struct elf_thunk_area thunks, struct image_file_map *fmap) DECLSPEC_HIDDEN

BOOL	dwarf2_virtual_unwind (struct cpu_stack_walk csw, DWORD_PTR ip, union ctx ctx, DWORD64 *cfa) DECLSPEC_HIDDEN

BOOL	rsym_parse (struct module module, unsigned long load_offset, const void rsym, int rsymlen) DECLSPEC_HIDDEN

BOOL	sw_read_mem (struct cpu_stack_walk csw, DWORD64 addr, void ptr, DWORD sz) DECLSPEC_HIDDEN

DWORD64	sw_xlat_addr (struct cpu_stack_walk csw, ADDRESS64 addr) DECLSPEC_HIDDEN

void *	sw_table_access (struct cpu_stack_walk *csw, DWORD64 addr) DECLSPEC_HIDDEN

DWORD64	sw_module_base (struct cpu_stack_walk *csw, DWORD64 addr) DECLSPEC_HIDDEN

const char *	symt_get_name (const struct symt *sym) DECLSPEC_HIDDEN

WCHAR *	symt_get_nameW (const struct symt *sym) DECLSPEC_HIDDEN

BOOL	symt_get_address (const struct symt type, ULONG64 addr) DECLSPEC_HIDDEN

int __cdecl	symt_cmp_addr (const void p1, const void p2) DECLSPEC_HIDDEN

void	copy_symbolW (SYMBOL_INFOW siw, const SYMBOL_INFO si) DECLSPEC_HIDDEN

struct symt_ht *	symt_find_nearest (struct module *module, DWORD_PTR addr) DECLSPEC_HIDDEN

struct symt_compiland *	symt_new_compiland (struct module *module, ULONG_PTR address, unsigned src_idx) DECLSPEC_HIDDEN

struct symt_public *	symt_new_public (struct module module, struct symt_compiland parent, const char *typename, BOOL is_function, ULONG_PTR address, unsigned size) DECLSPEC_HIDDEN

struct symt_data *	symt_new_global_variable (struct module module, struct symt_compiland parent, const char name, unsigned is_static, struct location loc, ULONG_PTR size, struct symt type) DECLSPEC_HIDDEN

struct symt_function *	symt_new_function (struct module module, struct symt_compiland parent, const char name, ULONG_PTR addr, ULONG_PTR size, struct symt type) DECLSPEC_HIDDEN

BOOL	symt_normalize_function (struct module module, const struct symt_function func) DECLSPEC_HIDDEN

void	symt_add_func_line (struct module module, struct symt_function func, unsigned source_idx, int line_num, ULONG_PTR offset) DECLSPEC_HIDDEN

struct symt_data *	symt_add_func_local (struct module module, struct symt_function func, enum DataKind dt, const struct location loc, struct symt_block block, struct symt type, const char name) DECLSPEC_HIDDEN

struct symt_block *	symt_open_func_block (struct module module, struct symt_function func, struct symt_block *block, unsigned pc, unsigned len) DECLSPEC_HIDDEN

struct symt_block *	symt_close_func_block (struct module module, const struct symt_function func, struct symt_block *block, unsigned pc) DECLSPEC_HIDDEN

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) DECLSPEC_HIDDEN

BOOL	symt_fill_func_line_info (const struct module module, const struct symt_function func, DWORD64 addr, IMAGEHLP_LINE64 *line) DECLSPEC_HIDDEN

BOOL	symt_get_func_line_next (const struct module *module, PIMAGEHLP_LINE64 line) DECLSPEC_HIDDEN

struct symt_thunk *	symt_new_thunk (struct module module, struct symt_compiland parent, const char *name, THUNK_ORDINAL ord, ULONG_PTR addr, ULONG_PTR size) DECLSPEC_HIDDEN

struct symt_data *	symt_new_constant (struct module module, struct symt_compiland parent, const char name, struct symt type, const VARIANT *v) DECLSPEC_HIDDEN

struct symt_hierarchy_point *	symt_new_label (struct module module, struct symt_compiland compiland, const char *name, ULONG_PTR address) DECLSPEC_HIDDEN

struct symt *	symt_index2ptr (struct module *module, DWORD id) DECLSPEC_HIDDEN

DWORD	symt_ptr2index (struct module module, const struct symt sym) DECLSPEC_HIDDEN

void	symt_init_basic (struct module *module) DECLSPEC_HIDDEN

BOOL	symt_get_info (struct module module, const struct symt type, IMAGEHLP_SYMBOL_TYPE_INFO req, void *pInfo) DECLSPEC_HIDDEN

struct symt_basic *	symt_new_basic (struct module module, enum BasicType, const char typename, unsigned size) DECLSPEC_HIDDEN

struct symt_udt *	symt_new_udt (struct module module, const char typename, unsigned size, enum UdtKind kind) DECLSPEC_HIDDEN

BOOL	symt_set_udt_size (struct module module, struct symt_udt type, unsigned size) DECLSPEC_HIDDEN

BOOL	symt_add_udt_element (struct module module, struct symt_udt udt_type, const char name, struct symt elt_type, unsigned offset, unsigned size) DECLSPEC_HIDDEN

struct symt_enum *	symt_new_enum (struct module module, const char typename, struct symt *basetype) DECLSPEC_HIDDEN

BOOL	symt_add_enum_element (struct module module, struct symt_enum enum_type, const char *name, int value) DECLSPEC_HIDDEN

struct symt_array *	symt_new_array (struct module module, int min, int max, struct symt base, struct symt *index) DECLSPEC_HIDDEN

struct symt_function_signature *	symt_new_function_signature (struct module module, struct symt ret_type, enum CV_call_e call_conv) DECLSPEC_HIDDEN

BOOL	symt_add_function_signature_parameter (struct module module, struct symt_function_signature sig, struct symt *param) DECLSPEC_HIDDEN

struct symt_pointer *	symt_new_pointer (struct module module, struct symt ref_type, ULONG_PTR size) DECLSPEC_HIDDEN

struct symt_typedef *	symt_new_typedef (struct module module, struct symt ref, const char *name) DECLSPEC_HIDDEN

Variables
unsigned dbghelp_options	DECLSPEC_HIDDEN

Typedef Documentation

◆ enum_modules_cb

typedef BOOL(* enum_modules_cb) (const WCHAR *, ULONG_PTR addr, void *user)

Definition at line 416 of file dbghelp_private.h.

◆ PEB32

typedef struct _PEB32 PEB32

◆ stabs_def_cb

typedef void(* stabs_def_cb) (struct module *module, ULONG_PTR load_offset, const char *name, ULONG_PTR offset, BOOL is_public, BOOL is_global, unsigned char other, struct symt_compiland *compiland, void *user)

Definition at line 732 of file dbghelp_private.h.

Enumeration Type Documentation

◆ cpu_addr

enum cpu_addr

Enumerator
cpu_addr_pc
cpu_addr_stack
cpu_addr_frame

Definition at line 576 of file dbghelp_private.h.

576{cpu_addr_pc, cpu_addr_stack, cpu_addr_frame};

cpu_addr_frame

@ cpu_addr_frame

Definition: dbghelp_private.h:576

cpu_addr_pc

@ cpu_addr_pc

Definition: dbghelp_private.h:576

cpu_addr_stack

@ cpu_addr_stack

Definition: dbghelp_private.h:576

◆ format_info

enum format_info

Enumerator
DFI_ELF
DFI_PE
DFI_MACHO
DFI_DWARF
DFI_PDB
DFI_LAST

Definition at line 339 of file dbghelp_private.h.

{
    DFI_ELF,
    DFI_PE,
    DFI_MACHO,
    DFI_DWARF,
    DFI_PDB,
    DFI_LAST
};

◆ location_error

enum location_error

Enumerator
loc_err_internal
loc_err_too_complex
loc_err_out_of_scope
loc_err_cant_read
loc_err_no_location

Definition at line 144 of file dbghelp_private.h.

                    {loc_err_internal = -1,     /* internal while computing */
                     loc_err_too_complex = -2,  /* couldn't compute location (even at runtime) */
                     loc_err_out_of_scope = -3, /* variable isn't available at current address */
                     loc_err_cant_read = -4,    /* couldn't read memory at given address */
                     loc_err_no_location = -5,  /* likely optimized away (by compiler) */
};

◆ location_kind

enum location_kind

Enumerator
loc_error
loc_unavailable
loc_absolute
loc_register
loc_regrel
loc_tlsrel
loc_user

Definition at line 134 of file dbghelp_private.h.

                   {loc_error,          /* reg is the error code */
                    loc_unavailable,    /* location is not available */
                    loc_absolute,       /* offset is the location */
                    loc_register,       /* reg is the location */
                    loc_regrel,         /* [reg+offset] is the location */
                    loc_tlsrel,         /* offset is the address of the TLS index */
                    loc_user,           /* value is debug information dependent,
                                           reg & offset can be used ad libidem */
};

◆ module_type

enum module_type

Enumerator
DMT_UNKNOWN
DMT_ELF
DMT_PE
DMT_MACHO
DMT_PDB
DMT_DBG

Definition at line 323 of file dbghelp_private.h.

{
    DMT_UNKNOWN,        /* for lookup, not actually used for a module */
    DMT_ELF,            /* a real ELF shared module */
    DMT_PE,             /* a native or builtin PE module */
    DMT_MACHO,          /* a real Mach-O shared module */
    DMT_PDB,            /* .PDB file */
    DMT_DBG,            /* .DBG file */
};

◆ pdb_kind

enum pdb_kind

Enumerator
PDB_JG
PDB_DS

Definition at line 476 of file dbghelp_private.h.

476{PDB_JG, PDB_DS};

PDB_DS

@ PDB_DS

Definition: dbghelp_private.h:476

PDB_JG

@ PDB_JG

Definition: dbghelp_private.h:476

Function Documentation

◆ calc_crc32()

DWORD calc_crc32 ( HANDLE handle )

Definition at line 874 of file dbghelp.c.

{
    BYTE buffer[8192];
    DWORD crc = 0;
    DWORD len;
 
    SetFilePointer(handle, 0, 0, FILE_BEGIN);
    while (ReadFile(handle, buffer, sizeof(buffer), &len, NULL) && len)
        crc = RtlComputeCrc32(crc, buffer, len);
    return crc;
}

Referenced by elf_fetch_file_info(), elf_load_file_from_fmap(), image_check_debug_link(), macho_fetch_file_info(), and macho_load_file().

◆ copy_symbolW()

void copy_symbolW	(	SYMBOL_INFOW *	siw,
		const SYMBOL_INFO *	si
	)

Definition at line 1029 of file symbol.c.

{
    siw->SizeOfStruct = si->SizeOfStruct;
    siw->TypeIndex = si->TypeIndex; 
    siw->Reserved[0] = si->Reserved[0];
    siw->Reserved[1] = si->Reserved[1];
    siw->Index = si->Index;
    siw->Size = si->Size;
    siw->ModBase = si->ModBase;
    siw->Flags = si->Flags;
    siw->Value = si->Value;
    siw->Address = si->Address;
    siw->Register = si->Register;
    siw->Scope = si->Scope;
    siw->Tag = si->Tag;
    siw->NameLen = si->NameLen;
    siw->MaxNameLen = si->MaxNameLen;
    MultiByteToWideChar(CP_ACP, 0, si->Name, -1, siw->Name, siw->MaxNameLen);
}

Referenced by enum_types_AtoW(), sym_enumW(), and SymFromAddrW().

◆ cpu_find()

struct cpu * cpu_find ( DWORD machine )

Definition at line 183 of file dbghelp.c.

{
    struct cpu** cpu;
 
    for (cpu = dbghelp_cpus ; *cpu; cpu++)
    {
        if (cpu[0]->machine == machine) return cpu[0];
    }
    return NULL;
}

Referenced by StackWalk(), and StackWalk64().

◆ dwarf2_parse()

BOOL dwarf2_parse	(	struct module *	module,
		ULONG_PTR	load_offset,
		const struct elf_thunk_area *	thunks,
		struct image_file_map *	fmap
	)

Definition at line 3509 of file dwarf.c.

{
    dwarf2_section_t    eh_frame, section[section_max];
    dwarf2_traverse_context_t   mod_ctx;
    struct image_section_map    debug_sect, debug_str_sect, debug_abbrev_sect,
                                debug_line_sect, debug_ranges_sect, eh_frame_sect;
    BOOL                ret = TRUE;
    struct module_format* dwarf2_modfmt;
 
    if (!dwarf2_init_section(&eh_frame,                fmap, ".eh_frame",     NULL,             &eh_frame_sect))
        /* lld produces .eh_fram to avoid generating a long name */
        dwarf2_init_section(&eh_frame,                fmap, ".eh_fram",      NULL,             &eh_frame_sect);
    dwarf2_init_section(&section[section_debug],  fmap, ".debug_info",   ".zdebug_info",   &debug_sect);
    dwarf2_init_section(&section[section_abbrev], fmap, ".debug_abbrev", ".zdebug_abbrev", &debug_abbrev_sect);
    dwarf2_init_section(&section[section_string], fmap, ".debug_str",    ".zdebug_str",    &debug_str_sect);
    dwarf2_init_section(&section[section_line],   fmap, ".debug_line",   ".zdebug_line",   &debug_line_sect);
    dwarf2_init_section(&section[section_ranges], fmap, ".debug_ranges", ".zdebug_ranges", &debug_ranges_sect);
 
    /* to do anything useful we need either .eh_frame or .debug_info */
    if ((!eh_frame.address || eh_frame.address == IMAGE_NO_MAP) &&
        (!section[section_debug].address || section[section_debug].address == IMAGE_NO_MAP))
    {
        ret = FALSE;
        goto leave;
    }
 
    if (fmap->modtype == DMT_ELF && debug_sect.fmap)
    {
        /* debug info might have a different base address than .so file
         * when elf file is prelinked after splitting off debug info
         * adjust symbol base addresses accordingly
         */
        load_offset += fmap->u.elf.elf_start - debug_sect.fmap->u.elf.elf_start;
    }
 
    TRACE("Loading Dwarf2 information for %s\n", debugstr_w(module->module.ModuleName));
 
    mod_ctx.data = section[section_debug].address;
    mod_ctx.end_data = mod_ctx.data + section[section_debug].size;
    mod_ctx.word_size = 0; /* will be correctly set later on */
 
    dwarf2_modfmt = HeapAlloc(GetProcessHeap(), 0,
                              sizeof(*dwarf2_modfmt) + sizeof(*dwarf2_modfmt->u.dwarf2_info));
    if (!dwarf2_modfmt)
    {
        ret = FALSE;
        goto leave;
    }
    dwarf2_modfmt->module = module;
    dwarf2_modfmt->remove = dwarf2_module_remove;
    dwarf2_modfmt->loc_compute = dwarf2_location_compute;
    dwarf2_modfmt->u.dwarf2_info = (struct dwarf2_module_info_s*)(dwarf2_modfmt + 1);
    dwarf2_modfmt->u.dwarf2_info->word_size = 0; /* will be correctly set later on */
    dwarf2_modfmt->module->format_info[DFI_DWARF] = dwarf2_modfmt;
 
    /* As we'll need later some sections' content, we won't unmap these
     * sections upon existing this function
     */
    dwarf2_init_section(&dwarf2_modfmt->u.dwarf2_info->debug_loc,   fmap, ".debug_loc",   ".zdebug_loc",   NULL);
    dwarf2_init_section(&dwarf2_modfmt->u.dwarf2_info->debug_frame, fmap, ".debug_frame", ".zdebug_frame", NULL);
    dwarf2_modfmt->u.dwarf2_info->eh_frame = eh_frame;
 
    while (mod_ctx.data < mod_ctx.end_data)
    {
        dwarf2_parse_compilation_unit(section, dwarf2_modfmt->module, thunks, &mod_ctx, load_offset);
    }
    dwarf2_modfmt->module->module.SymType = SymDia;
    dwarf2_modfmt->module->module.CVSig = 'D' | ('W' << 8) | ('A' << 16) | ('R' << 24);
    /* FIXME: we could have a finer grain here */
    dwarf2_modfmt->module->module.GlobalSymbols = TRUE;
    dwarf2_modfmt->module->module.TypeInfo = TRUE;
    dwarf2_modfmt->module->module.SourceIndexed = TRUE;
    dwarf2_modfmt->module->module.Publics = TRUE;
 
    /* set the word_size for eh_frame parsing */
    dwarf2_modfmt->u.dwarf2_info->word_size = fmap->addr_size / 8;
 
leave:
    dwarf2_fini_section(&section[section_debug]);
    dwarf2_fini_section(&section[section_abbrev]);
    dwarf2_fini_section(&section[section_string]);
    dwarf2_fini_section(&section[section_line]);
    dwarf2_fini_section(&section[section_ranges]);
 
    image_unmap_section(&debug_sect);
    image_unmap_section(&debug_abbrev_sect);
    image_unmap_section(&debug_str_sect);
    image_unmap_section(&debug_line_sect);
    image_unmap_section(&debug_ranges_sect);
    if (!ret) image_unmap_section(&eh_frame_sect);
 
    return ret;
}

Referenced by elf_load_debug_info_from_map(), macho_load_debug_info(), and pe_load_dwarf().

◆ dwarf2_virtual_unwind()

BOOL dwarf2_virtual_unwind	(	struct cpu_stack_walk *	csw,
		DWORD_PTR	ip,
		union ctx *	ctx,
		DWORD64 *	cfa
	)

Definition at line 3258 of file dwarf.c.

{
    struct module_pair pair;
    struct frame_info info;
    dwarf2_traverse_context_t cie_ctx, fde_ctx;
    struct module_format* modfmt;
    const unsigned char* end;
    DWORD_PTR delta;
 
    if (!(pair.pcs = process_find_by_handle(csw->hProcess)) ||
        !(pair.requested = module_find_by_addr(pair.pcs, ip, DMT_UNKNOWN)) ||
        !module_get_debug(&pair))
        return FALSE;
    modfmt = pair.effective->format_info[DFI_DWARF];
    if (!modfmt) return FALSE;
    memset(&info, 0, sizeof(info));
    fde_ctx.data = modfmt->u.dwarf2_info->eh_frame.address;
    fde_ctx.end_data = fde_ctx.data + modfmt->u.dwarf2_info->eh_frame.size;
    fde_ctx.word_size = modfmt->u.dwarf2_info->word_size;
    /* let offsets relative to the eh_frame sections be correctly computed, as we'll map
     * in this process the IMAGE section at a different address as the one expected by
     * the image
     */
    delta = pair.effective->module.BaseOfImage + modfmt->u.dwarf2_info->eh_frame.rva -
        (DWORD_PTR)modfmt->u.dwarf2_info->eh_frame.address;
    if (!dwarf2_get_cie(ip, pair.effective, delta, &fde_ctx, &cie_ctx, &info, TRUE))
    {
        fde_ctx.data = modfmt->u.dwarf2_info->debug_frame.address;
        fde_ctx.end_data = fde_ctx.data + modfmt->u.dwarf2_info->debug_frame.size;
        fde_ctx.word_size = modfmt->u.dwarf2_info->word_size;
        delta = pair.effective->reloc_delta;
        if (!dwarf2_get_cie(ip, pair.effective, delta, &fde_ctx, &cie_ctx, &info, FALSE))
        {
            TRACE("Couldn't find information for %lx\n", ip);
            return FALSE;
        }
    }
 
    TRACE("function %lx/%lx code_align %lu data_align %ld retaddr %s\n",
          ip, info.ip, info.code_align, info.data_align,
          csw->cpu->fetch_regname(csw->cpu->map_dwarf_register(info.retaddr_reg, pair.effective, TRUE)));
 
    /* if at very beginning of function, return and use default unwinder */
    if (ip == info.ip) return FALSE;
    execute_cfa_instructions(pair.effective, &cie_ctx, ip, &info);
 
    if (info.aug_z_format)  /* get length of augmentation data */
    {
        ULONG_PTR len = dwarf2_leb128_as_unsigned(&fde_ctx);
        end = fde_ctx.data + len;
    }
    else end = NULL;
    dwarf2_parse_augmentation_ptr(&fde_ctx, info.lsda_encoding); /* handler_data */
    if (end) fde_ctx.data = end;
 
    execute_cfa_instructions(pair.effective, &fde_ctx, ip, &info);
 
    /* if there is no information about retaddr, use default unwinder */
    if (info.state.rules[info.retaddr_reg] == RULE_UNSET) return FALSE;
 
    apply_frame_state(pair.effective, csw, context, &info.state, cfa);
 
    return TRUE;
}

Referenced by fetch_next_frame32().

◆ elf_is_in_thunk_area()

int elf_is_in_thunk_area	(	ULONG_PTR	addr,
		const struct elf_thunk_area *	thunks
	)

Definition at line 602 of file elf_module.c.

{
    unsigned i;
 
    if (thunks) for (i = 0; thunks[i].symname; i++)
    {
        if (addr >= thunks[i].rva_start && addr < thunks[i].rva_end)
            return i;
    }
    return -1;
}

Referenced by dwarf2_parse_subprogram(), and elf_new_wine_thunks().

◆ elf_read_wine_loader_dbg_info()

BOOL elf_read_wine_loader_dbg_info	(	struct process *	pcs,
		ULONG_PTR	addr
	)

Definition at line 1753 of file elf_module.c.

{
    struct elf_info     elf_info;
    WCHAR *loader;
    BOOL ret;
 
    elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_MODULE;
    loader = get_wine_loader_name(pcs);
    ret = elf_search_and_load_file(pcs, loader, addr, 0, &elf_info);
    heap_free(loader);
    if (!ret || !elf_info.dbg_hdr_addr) return FALSE;
 
    TRACE("Found ELF debug header %#lx\n", elf_info.dbg_hdr_addr);
    elf_info.module->format_info[DFI_ELF]->u.elf_info->elf_loader = 1;
    module_set_module(elf_info.module, S_WineLoaderW);
    pcs->dbg_hdr_addr = elf_info.dbg_hdr_addr;
    pcs->loader = &elf_loader_ops;
    return TRUE;
}

Referenced by check_live_target().

◆ fetch_buffer()

void * fetch_buffer	(	struct process *	pcs,
		unsigned	size
	)

Definition at line 128 of file dbghelp.c.

{
    if (size > pcs->buffer_size)
    {
        if (pcs->buffer)
            pcs->buffer = HeapReAlloc(GetProcessHeap(), 0, pcs->buffer, size);
        else
            pcs->buffer = HeapAlloc(GetProcessHeap(), 0, size);
        pcs->buffer_size = (pcs->buffer) ? size : 0;
    }
    return pcs->buffer;
}

Referenced by copy_line_W64_from_64(), and symt_fill_func_line_info().

◆ file_name()

const WCHAR * file_name ( const WCHAR * str )

Definition at line 45 of file path.c.

{
    const WCHAR*      p;
 
    for (p = str + lstrlenW(str) - 1; p >= str && !is_sep(*p); p--);
    return p + 1;
}

◆ file_nameA()

const char * file_nameA ( const char * str )

Definition at line 37 of file path.c.

{
    const char*       p;
 
    for (p = str + strlen(str) - 1; p >= str && !is_sepA(*p); p--);
    return p + 1;
}

Referenced by elf_lookup_symtab(), FindDebugInfoFile(), is_wine_loader(), and test_query_process_image_file_name().

◆ get_dos_file_name()

WCHAR * get_dos_file_name ( const WCHAR * filename )

Definition at line 671 of file path.c.

{
    WCHAR *dos_path;
    size_t len;
 
#ifndef __REACTOS__
    if (*filename == '/')
    {
        char *unix_path;
        len = WideCharToMultiByte(CP_UNIXCP, 0, filename, -1, NULL, 0, NULL, NULL);
        unix_path = heap_alloc(len * sizeof(WCHAR));
        WideCharToMultiByte(CP_UNIXCP, 0, filename, -1, unix_path, len, NULL, NULL);
        dos_path = wine_get_dos_file_name(unix_path);
        heap_free(unix_path);
    }
    else
#endif
    {
        len = lstrlenW(filename);
        dos_path = heap_alloc((len + 1) * sizeof(WCHAR));
        memcpy(dos_path, filename, (len + 1) * sizeof(WCHAR));
    }
    return dos_path;
}

Referenced by elf_map_file(), image_check_debug_link(), and macho_map_file().

◆ get_wine_loader_name()

WCHAR * get_wine_loader_name ( struct process * pcs )

Definition at line 150 of file module.c.

{
    static const WCHAR wineW[] = {'w','i','n','e',0};
    static const WCHAR suffixW[] = {'6','4',0};
    WCHAR *buffer, *p;
    const char *env;
 
    /* All binaries are loaded with WINELOADER (if run from tree) or by the
     * main executable
     */
    if ((env = getenv("WINELOADER")))
    {
        DWORD len = 2 + MultiByteToWideChar( CP_UNIXCP, 0, env, -1, NULL, 0 );
        buffer = heap_alloc( len * sizeof(WCHAR) );
        MultiByteToWideChar( CP_UNIXCP, 0, env, -1, buffer, len );
    }
    else
    {
        buffer = heap_alloc( sizeof(wineW) + 2 * sizeof(WCHAR) );
        lstrcpyW( buffer, wineW );
    }
 
    p = buffer + lstrlenW( buffer ) - lstrlenW( suffixW );
    if (p > buffer && !wcscmp( p, suffixW ))
        *p = 0;
 
    if (pcs->is_64bit)
        lstrcatW(buffer, suffixW);
 
    TRACE( "returning %s\n", debugstr_w(buffer) );
    return buffer;
}

Referenced by elf_read_wine_loader_dbg_info(), and macho_search_loader().

◆ hash_table_add()

void hash_table_add	(	struct hash_table *	ht,
		struct hash_table_elt *	elt
	)

Definition at line 378 of file storage.c.

{
    unsigned                    hash = hash_table_hash(elt->name, ht->num_buckets);
 
    if (!ht->buckets)
    {
        ht->buckets = pool_alloc(ht->pool, ht->num_buckets * sizeof(struct hash_table_bucket));
        assert(ht->buckets);
        memset(ht->buckets, 0, ht->num_buckets * sizeof(struct hash_table_bucket));
    }
 
    /* in some cases, we need to get back the symbols of same name in the order
     * in which they've been inserted. So insert new elements at the end of the list.
     */
    if (!ht->buckets[hash].first)
    {
        ht->buckets[hash].first = elt;
    }
    else
    {
        ht->buckets[hash].last->next = elt;
    }
    ht->buckets[hash].last = elt;
    elt->next = NULL;
    ht->num_elts++;
}

Referenced by elf_hash_symtab(), macho_stabs_def_cb(), pev_set_value(), symt_add_module_ht(), symt_new_basic(), symt_new_typedef(), symt_new_udt(), and symt_ptr2index().

◆ hash_table_destroy()

void hash_table_destroy ( struct hash_table * ht )

Definition at line 342 of file storage.c.

{
#if defined(USE_STATS)
    int                         i;
    unsigned                    len;
    unsigned                    min = 0xffffffff, max = 0, sq = 0;
    struct hash_table_elt*      elt;
    double                      mean, variance;
 
    for (i = 0; i < ht->num_buckets; i++)
    {
        for (len = 0, elt = ht->buckets[i]; elt; elt = elt->next) len++;
        if (len < min) min = len;
        if (len > max) max = len;
        sq += len * len;
    }
    mean = (double)ht->num_elts / ht->num_buckets;
    variance = (double)sq / ht->num_buckets - mean * mean;
    FIXME("STATS: elts[num:%-4u size:%u mean:%f] buckets[min:%-4u variance:%+f max:%-4u]\n",
          ht->num_elts, ht->num_buckets, mean, min, variance, max);
 
    for (i = 0; i < ht->num_buckets; i++)
    {
        for (len = 0, elt = ht->buckets[i]; elt; elt = elt->next) len++;
        if (len == max)
        {
            FIXME("Longest bucket:\n");
            for (elt = ht->buckets[i]; elt; elt = elt->next)
                FIXME("\t%s\n", elt->name);
            break;
        }
 
    }
#endif
}

Referenced by module_remove(), and module_reset_debug_info().

◆ hash_table_init()

void hash_table_init	(	struct pool *	pool,
		struct hash_table *	ht,
		unsigned	num_buckets
	)

Definition at line 334 of file storage.c.

{
    ht->num_elts = 0;
    ht->num_buckets = num_buckets;
    ht->pool = pool;
    ht->buckets = NULL;
}

Referenced by elf_load_debug_info(), macho_load_debug_info(), module_new(), and pev_init().

◆ hash_table_iter_init()

void hash_table_iter_init	(	const struct hash_table *	ht,
		struct hash_table_iter *	hti,
		const char *	name
	)

Definition at line 405 of file storage.c.

{
    hti->ht = ht;
    if (name)
    {
        hti->last = hash_table_hash(name, ht->num_buckets);
        hti->index = hti->last - 1;
    }
    else
    {
        hti->last = ht->num_buckets - 1;
        hti->index = -1;
    }
    hti->element = NULL;
}

Referenced by codeview_add_type_struct(), elf_finish_stabs_info(), elf_lookup_symtab(), elf_new_public_symbols(), elf_new_wine_thunks(), find_name(), macho_finish_stabs(), pe_locate_with_coff_symbol_table(), pev_get_val(), pev_set_value(), SymEnumLines(), symt_enum_module(), symt_find_type_by_name(), and symt_ptr2index().

◆ hash_table_iter_up()

void * hash_table_iter_up ( struct hash_table_iter * hti )

Definition at line 422 of file storage.c.

{
    if (!hti->ht->buckets) return NULL;
 
    if (hti->element) hti->element = hti->element->next;
    while (!hti->element && hti->index < hti->last)
        hti->element = hti->ht->buckets[++hti->index].first;
    return hti->element;
}

Referenced by codeview_add_type_struct(), elf_finish_stabs_info(), elf_lookup_symtab(), elf_new_public_symbols(), elf_new_wine_thunks(), find_name(), macho_finish_stabs(), pe_locate_with_coff_symbol_table(), pev_get_val(), pev_set_value(), SymEnumLines(), symt_enum_module(), symt_find_type_by_name(), and symt_ptr2index().

◆ macho_read_wine_loader_dbg_info()

BOOL macho_read_wine_loader_dbg_info	(	struct process *	pcs,
		ULONG_PTR	addr
	)

Definition at line 1911 of file macho_module.c.

{
    struct macho_info     macho_info;
 
    TRACE("(%p/%p)\n", pcs, pcs->handle);
    pcs->dbg_hdr_addr = addr;
    macho_info.flags = MACHO_INFO_MODULE;
    if (!macho_search_loader(pcs, &macho_info)) return FALSE;
    macho_info.module->format_info[DFI_MACHO]->u.macho_info->is_loader = 1;
    module_set_module(macho_info.module, S_WineLoaderW);
    pcs->loader = &macho_loader_ops;
    TRACE("Found macho debug header %#lx\n", pcs->dbg_hdr_addr);
    return TRUE;
}

Referenced by check_live_target().

◆ minidump_add_memory_block()

void minidump_add_memory_block	(	struct dump_context *	dc,
		ULONG64	base,
		ULONG	size,
		ULONG	rva
	)

Definition at line 355 of file minidump.c.

{
    if (!dc->mem)
    {
        dc->alloc_mem = 32;
        dc->mem = HeapAlloc(GetProcessHeap(), 0, dc->alloc_mem * sizeof(*dc->mem));
    }
    else if (dc->num_mem >= dc->alloc_mem)
    {
        dc->alloc_mem *= 2;
        dc->mem = HeapReAlloc(GetProcessHeap(), 0, dc->mem,
                              dc->alloc_mem * sizeof(*dc->mem));
    }
    if (dc->mem)
    {
        dc->mem[dc->num_mem].base = base;
        dc->mem[dc->num_mem].size = size;
        dc->mem[dc->num_mem].rva  = rva;
        dc->num_mem++;
    }
    else dc->num_mem = dc->alloc_mem = 0;
}

Referenced by arm64_fetch_minidump_thread(), arm_fetch_minidump_thread(), dump_threads(), i386_fetch_minidump_thread(), x86_64_fetch_minidump_module(), and x86_64_fetch_minidump_thread().

◆ module_find_by_addr()

struct module * module_find_by_addr	(	const struct process *	pcs,
		DWORD64	addr,
		enum module_type	type
	)

Definition at line 420 of file module.c.

{
    struct module*      module;
 
    if (type == DMT_UNKNOWN)
    {
        if ((module = module_find_by_addr(pcs, addr, DMT_PE)) ||
            (module = module_find_by_addr(pcs, addr, DMT_ELF)) ||
            (module = module_find_by_addr(pcs, addr, DMT_MACHO)))
            return module;
    }
    else
    {
        for (module = pcs->lmodules; module; module = module->next)
        {
            if (type == module->type && addr >= module->module.BaseOfImage &&
                addr < module->module.BaseOfImage + module->module.ImageSize)
                return module;
        }
    }
    SetLastError(ERROR_MOD_NOT_FOUND);
    return module;
}

Referenced by dwarf2_virtual_unwind(), module_find_by_addr(), pdb_virtual_unwind(), sym_enum(), SymAddSymbolW(), SymEnumLines(), SymEnumSourceFilesW(), SymEnumTypes(), SymFromAddr(), SymFunctionTableAccess64(), SymGetLineFromAddr64(), SymGetLineNext64(), SymGetLinePrev64(), SymGetModuleBase64(), SymGetModuleInfoW64(), SymGetTypeFromName(), SymGetTypeInfo(), symt_enum_locals(), SymUnloadModule(), SymUnloadModule64(), and x86_64_fetch_minidump_module().

◆ module_find_by_nameA()

struct module * module_find_by_nameA	(	const struct process *	pcs,
		const char *	name
	)

Definition at line 291 of file module.c.

{
    WCHAR wname[MAX_PATH];
 
    MultiByteToWideChar(CP_ACP, 0, name, -1, wname, ARRAY_SIZE(wname));
    return module_find_by_nameW(pcs, wname);
}

Referenced by SymFromName().

◆ module_find_by_nameW()

struct module * module_find_by_nameW	(	const struct process *	pcs,
		const WCHAR *	name
	)

Definition at line 279 of file module.c.

{
    struct module*      module;
 
    for (module = pcs->lmodules; module; module = module->next)
    {
        if (!wcsicmp(name, module->module.ModuleName)) return module;
    }
    SetLastError(ERROR_INVALID_NAME);
    return NULL;
}

Referenced by module_find_by_nameA(), and SymEnumSourceFilesW().

◆ module_get_containee()

struct module * module_get_containee	(	const struct process *	pcs,
		const struct module *	inner
	)

Definition at line 349 of file module.c.

{
    struct module*      module;
 
    for (module = pcs->lmodules; module; module = module->next)
    {
        if (module != outer &&
            outer->module.BaseOfImage <= module->module.BaseOfImage &&
            outer->module.BaseOfImage + outer->module.ImageSize >=
            module->module.BaseOfImage + module->module.ImageSize)
            return module;
    }
    return NULL;
}

Referenced by sym_enum(), and SymFromName().

◆ module_get_debug()

BOOL module_get_debug ( struct module_pair * pair )

Definition at line 374 of file module.c.

{
    IMAGEHLP_DEFERRED_SYMBOL_LOADW64    idslW64;
 
    if (!pair->requested) return FALSE;
    /* for a PE builtin, always get info from container */
    if (!(pair->effective = module_get_container(pair->pcs, pair->requested)))
        pair->effective = pair->requested;
    /* if deferred, force loading */
    if (pair->effective->module.SymType == SymDeferred)
    {
        BOOL ret;
 
        if (pair->effective->is_virtual) ret = FALSE;
        else if (pair->effective->type == DMT_PE)
        {
            idslW64.SizeOfStruct = sizeof(idslW64);
            idslW64.BaseOfImage = pair->effective->module.BaseOfImage;
            idslW64.CheckSum = pair->effective->module.CheckSum;
            idslW64.TimeDateStamp = pair->effective->module.TimeDateStamp;
            memcpy(idslW64.FileName, pair->effective->module.ImageName,
                   sizeof(pair->effective->module.ImageName));
            idslW64.Reparse = FALSE;
            idslW64.hFile = INVALID_HANDLE_VALUE;
 
            pcs_callback(pair->pcs, CBA_DEFERRED_SYMBOL_LOAD_START, &idslW64);
            ret = pe_load_debug_info(pair->pcs, pair->effective);
            pcs_callback(pair->pcs,
                         ret ? CBA_DEFERRED_SYMBOL_LOAD_COMPLETE : CBA_DEFERRED_SYMBOL_LOAD_FAILURE,
                         &idslW64);
        }
        else ret = pair->pcs->loader->load_debug_info(pair->pcs, pair->effective);
 
        if (!ret) pair->effective->module.SymType = SymNone;
        assert(pair->effective->module.SymType != SymDeferred);
        pair->effective->module.NumSyms = pair->effective->ht_symbols.num_elts;
    }
    return pair->effective->module.SymType != SymNone;
}

Referenced by dwarf2_virtual_unwind(), find_name(), pdb_virtual_unwind(), sym_enum(), SymAddSymbolW(), SymEnumLines(), SymEnumSourceFilesW(), SymEnumTypes(), SymFromAddr(), SymGetLineFromAddr64(), SymGetLineNext64(), SymGetLinePrev64(), SymGetTypeFromName(), SymGetTypeInfo(), and symt_enum_locals().

◆ module_is_already_loaded()

struct module * module_is_already_loaded	(	const struct process *	pcs,
		const WCHAR *	imgname
	)

Definition at line 303 of file module.c.

{
    struct module*      module;
    const WCHAR*        filename;
 
    /* first compare the loaded image name... */
    for (module = pcs->lmodules; module; module = module->next)
    {
        if (!wcsicmp(name, module->module.LoadedImageName))
            return module;
    }
    /* then compare the standard filenames (without the path) ... */
    filename = get_filename(name, NULL);
    for (module = pcs->lmodules; module; module = module->next)
    {
        if (!wcsicmp(filename, get_filename(module->module.LoadedImageName, NULL)))
            return module;
    }
    SetLastError(ERROR_INVALID_NAME);
    return NULL;
}

Referenced by elf_load_cb(), elf_search_and_load_file(), macho_search_and_load_file(), and SymLoadModuleExW().

◆ module_new()

struct module * module_new	(	struct process *	pcs,
		const WCHAR *	name,
		enum module_type	type,
		BOOL	virtual,
		DWORD64	addr,
		DWORD64	size,
		ULONG_PTR	stamp,
		ULONG_PTR	checksum
	)

Definition at line 198 of file module.c.

{
    struct module*      module;
    unsigned            i;
 
    assert(type == DMT_ELF || type == DMT_PE || type == DMT_MACHO);
    if (!(module = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*module))))
    return NULL;
 
    module->next = pcs->lmodules;
    pcs->lmodules = module;
 
    TRACE("=> %s %s-%s %s\n",
          get_module_type(type, virtual),
      wine_dbgstr_longlong(mod_addr), wine_dbgstr_longlong(mod_addr + size),
          debugstr_w(name));
 
    pool_init(&module->pool, 65536);
 
    module->process = pcs;
    module->module.SizeOfStruct = sizeof(module->module);
    module->module.BaseOfImage = mod_addr;
    module->module.ImageSize = size;
    module_set_module(module, name);
    module->module.ImageName[0] = '\0';
    lstrcpynW(module->module.LoadedImageName, name, ARRAY_SIZE(module->module.LoadedImageName));
    module->module.SymType = SymNone;
    module->module.NumSyms = 0;
    module->module.TimeDateStamp = stamp;
    module->module.CheckSum = checksum;
 
    memset(module->module.LoadedPdbName, 0, sizeof(module->module.LoadedPdbName));
    module->module.CVSig = 0;
    memset(module->module.CVData, 0, sizeof(module->module.CVData));
    module->module.PdbSig = 0;
    memset(&module->module.PdbSig70, 0, sizeof(module->module.PdbSig70));
    module->module.PdbAge = 0;
    module->module.PdbUnmatched = FALSE;
    module->module.DbgUnmatched = FALSE;
    module->module.LineNumbers = FALSE;
    module->module.GlobalSymbols = FALSE;
    module->module.TypeInfo = FALSE;
    module->module.SourceIndexed = FALSE;
    module->module.Publics = FALSE;
 
    module->reloc_delta       = 0;
    module->type              = type;
    module->is_virtual        = virtual;
    for (i = 0; i < DFI_LAST; i++) module->format_info[i] = NULL;
    module->sortlist_valid    = FALSE;
    module->sorttab_size      = 0;
    module->addr_sorttab      = NULL;
    module->num_sorttab       = 0;
    module->num_symbols       = 0;
 
    vector_init(&module->vsymt, sizeof(struct symt*), 128);
    /* FIXME: this seems a bit too high (on a per module basis)
     * need some statistics about this
     */
    hash_table_init(&module->pool, &module->ht_symbols, 4096);
    hash_table_init(&module->pool, &module->ht_types,   4096);
#ifdef __x86_64__
    hash_table_init(&module->pool, &module->ht_symaddr, 4096);
#endif
    vector_init(&module->vtypes, sizeof(struct symt*),  32);
 
    module->sources_used      = 0;
    module->sources_alloc     = 0;
    module->sources           = 0;
    wine_rb_init(&module->sources_offsets_tree, source_rb_compare);
 
    return module;
}

Referenced by elf_load_file_from_fmap(), macho_load_file(), pe_load_builtin_module(), pe_load_native_module(), and SymLoadModuleExW().

◆ module_remove()

BOOL module_remove	(	struct process *	pcs,
		struct module *	module
	)

Definition at line 889 of file module.c.

{
    struct module_format*modfmt;
    struct module**     p;
    unsigned            i;
 
    TRACE("%s (%p)\n", debugstr_w(module->module.ModuleName), module);
 
    for (i = 0; i < DFI_LAST; i++)
    {
        if ((modfmt = module->format_info[i]) && modfmt->remove)
            modfmt->remove(pcs, module->format_info[i]);
    }
    hash_table_destroy(&module->ht_symbols);
    hash_table_destroy(&module->ht_types);
    HeapFree(GetProcessHeap(), 0, module->sources);
    HeapFree(GetProcessHeap(), 0, module->addr_sorttab);
    HeapFree(GetProcessHeap(), 0, module->real_path);
    pool_destroy(&module->pool);
    /* native dbghelp doesn't invoke registered callback(,CBA_SYMBOLS_UNLOADED,) here
     * so do we
     */
    for (p = &pcs->lmodules; *p; p = &(*p)->next)
    {
        if (*p == module)
        {
            *p = module->next;
            HeapFree(GetProcessHeap(), 0, module);
            return TRUE;
        }
    }
    FIXME("This shouldn't happen\n");
    return FALSE;
}

Referenced by elf_synchronize_module_list(), macho_synchronize_module_list(), SymCleanup(), SymUnloadModule(), and SymUnloadModule64().

◆ module_reset_debug_info()

void module_reset_debug_info ( struct module * module )

Definition at line 1328 of file module.c.

{
    module->sortlist_valid = TRUE;
    module->sorttab_size = 0;
    module->addr_sorttab = NULL;
    module->num_sorttab = module->num_symbols = 0;
    hash_table_destroy(&module->ht_symbols);
    module->ht_symbols.num_buckets = 0;
    module->ht_symbols.buckets = NULL;
    hash_table_destroy(&module->ht_types);
    module->ht_types.num_buckets = 0;
    module->ht_types.buckets = NULL;
    module->vtypes.num_elts = 0;
    hash_table_destroy(&module->ht_symbols);
    module->sources_used = module->sources_alloc = 0;
    module->sources = NULL;
}

Referenced by stabs_parse().

◆ module_set_module()

void module_set_module	(	struct module *	module,
		const WCHAR *	name
	)

Definition at line 142 of file module.c.

{
    module_fill_module(name, module->module.ModuleName, ARRAY_SIZE(module->module.ModuleName));
    module_fill_module(name, module->modulename, ARRAY_SIZE(module->modulename));
}

Referenced by elf_read_wine_loader_dbg_info(), macho_read_wine_loader_dbg_info(), module_new(), and SymLoadModuleExW().

◆ path_find_symbol_file()

BOOL path_find_symbol_file	(	const struct process *	pcs,
		const struct module *	module,
		PCSTR	full_path,
		enum module_type	type,
		const GUID *	guid,
		DWORD	dw1,
		DWORD	dw2,
		WCHAR *	buffer,
		BOOL *	is_unmatched
	)

Definition at line 596 of file path.c.

{
    struct module_find  mf;
    WCHAR               full_pathW[MAX_PATH];
    WCHAR*              ptr;
    const WCHAR*        filename;
    WCHAR*              searchPath = pcs->search_path;
 
    TRACE("(pcs = %p, full_path = %s, guid = %s, dw1 = 0x%08x, dw2 = 0x%08x, buffer = %p)\n",
          pcs, debugstr_a(full_path), debugstr_guid(guid), dw1, dw2, buffer);
 
    mf.guid = guid;
    mf.dw1 = dw1;
    mf.dw2 = dw2;
    mf.matched = 0;
 
    MultiByteToWideChar(CP_ACP, 0, full_path, -1, full_pathW, MAX_PATH);
    filename = file_name(full_pathW);
    mf.kind = type;
    *is_unmatched = FALSE;
 
    /* first check full path to file */
    if (module_find_cb(full_pathW, &mf))
    {
        lstrcpyW( buffer, full_pathW );
        return TRUE;
    }
 
    /* FIXME: Use Environment-Variables (see MS docs)
                 _NT_SYMBOL_PATH and _NT_ALT_SYMBOL_PATH
       FIXME: Implement "Standard Path Elements" (Path) ... (see MS docs)
              do a search for (every?) path-element like this ...
              <path>
              <path>\dll
              <path>\symbols\dll
              (dll may be exe, or sys depending on the file extension)   */
 
    /* 2. check module-path */
    file_pathW(module->module.LoadedImageName, buffer);
    if (do_searchW(filename, buffer, FALSE, module_find_cb, &mf)) return TRUE;
    if (module->real_path)
    {
        file_pathW(module->real_path, buffer);
        if (do_searchW(filename, buffer, FALSE, module_find_cb, &mf)) return TRUE;
    }
 
    while (searchPath)
    {
        ptr = wcschr(searchPath, ';');
        if (ptr)
        {
            memcpy(buffer, searchPath, (ptr - searchPath) * sizeof(WCHAR));
            buffer[ptr - searchPath] = '\0';
            searchPath = ptr + 1;
        }
        else
        {
            lstrcpyW(buffer, searchPath);
            searchPath = NULL;
        }
        /* return first fully matched file */
        if (do_searchW(filename, buffer, FALSE, module_find_cb, &mf)) return TRUE;
    }
    /* if no fully matching file is found, return the best matching file if any */
    if ((dbghelp_options & SYMOPT_LOAD_ANYTHING) && mf.matched)
    {
        lstrcpyW( buffer, mf.filename );
        *is_unmatched = TRUE;
        return TRUE;
    }
    return FALSE;
}

Referenced by map_pdb_file(), and pe_load_dbg_file().

◆ pcs_callback()

BOOL pcs_callback	(	const struct process *	pcs,
		ULONG	action,
		void *	data
	)

Definition at line 731 of file dbghelp.c.

{
    IMAGEHLP_DEFERRED_SYMBOL_LOAD64 idsl;
 
    TRACE("%p %u %p\n", pcs, action, data);
 
    if (!pcs->reg_cb) return FALSE;
    if (!pcs->reg_is_unicode)
    {
        IMAGEHLP_DEFERRED_SYMBOL_LOADW64*   idslW;
 
        switch (action)
        {
        case CBA_DEBUG_INFO:
        case CBA_DEFERRED_SYMBOL_LOAD_CANCEL:
        case CBA_SET_OPTIONS:
        case CBA_SYMBOLS_UNLOADED:
            break;
        case CBA_DEFERRED_SYMBOL_LOAD_COMPLETE:
        case CBA_DEFERRED_SYMBOL_LOAD_FAILURE:
        case CBA_DEFERRED_SYMBOL_LOAD_PARTIAL:
        case CBA_DEFERRED_SYMBOL_LOAD_START:
            idslW = data;
            idsl.SizeOfStruct = sizeof(idsl);
            idsl.BaseOfImage = idslW->BaseOfImage;
            idsl.CheckSum = idslW->CheckSum;
            idsl.TimeDateStamp = idslW->TimeDateStamp;
            WideCharToMultiByte(CP_ACP, 0, idslW->FileName, -1,
                                idsl.FileName, sizeof(idsl.FileName), NULL, NULL);
            idsl.Reparse = idslW->Reparse;
            data = &idsl;
            break;
        case CBA_DUPLICATE_SYMBOL:
        case CBA_EVENT:
        case CBA_READ_MEMORY:
        default:
            FIXME("No mapping for action %u\n", action);
            return FALSE;
        }
    }
    return pcs->reg_cb(pcs->handle, action, (ULONG64)(DWORD_PTR)data, pcs->reg_user);
}

Referenced by module_get_debug(), and SymSetOptions().

◆ pdb_fetch_file_info()

BOOL pdb_fetch_file_info	(	const struct pdb_lookup *	pdb_lookup,
		unsigned *	matched
	)

Definition at line 2913 of file msc.c.

{
    HANDLE              hFile, hMap = NULL;
    char*               image = NULL;
    BOOL                ret;
    struct pdb_file_info pdb_file;
 
    if ((hFile = CreateFileA(pdb_lookup->filename, GENERIC_READ, FILE_SHARE_READ, NULL,
                             OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) == INVALID_HANDLE_VALUE ||
        ((hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) == NULL) ||
        ((image = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) == NULL))
    {
        WARN("Unable to open .PDB file: %s\n", pdb_lookup->filename);
        ret = FALSE;
    }
    else
    {
        ret = pdb_init(pdb_lookup, &pdb_file, image, matched);
        pdb_free_file(&pdb_file);
    }
 
    if (image) UnmapViewOfFile(image);
    if (hMap) CloseHandle(hMap);
    if (hFile != INVALID_HANDLE_VALUE) CloseHandle(hFile);
 
    return ret;
}

Referenced by module_find_cb().

◆ pdb_virtual_unwind()

BOOL pdb_virtual_unwind	(	struct cpu_stack_walk *	csw,
		DWORD_PTR	ip,
		union ctx *	context,
		struct pdb_cmd_pair *	cpair
	)

Definition at line 3200 of file msc.c.

{
    struct module_pair          pair;
    struct pdb_module_info*     pdb_info;
    PDB_FPO_DATA*               fpoext;
    unsigned                    i, size, strsize;
    char*                       strbase;
    BOOL                        ret = TRUE;
 
    if (!(pair.pcs = process_find_by_handle(csw->hProcess)) ||
        !(pair.requested = module_find_by_addr(pair.pcs, ip, DMT_UNKNOWN)) ||
        !module_get_debug(&pair))
        return FALSE;
    if (!pair.effective->format_info[DFI_PDB]) return FALSE;
    pdb_info = pair.effective->format_info[DFI_PDB]->u.pdb_info;
    TRACE("searching %lx => %lx\n", ip, ip - (DWORD_PTR)pair.effective->module.BaseOfImage);
    ip -= (DWORD_PTR)pair.effective->module.BaseOfImage;
 
    strbase = pdb_read_strings(&pdb_info->pdb_files[0]);
    if (!strbase) return FALSE;
    strsize = *(const DWORD*)(strbase + 8);
    fpoext = pdb_read_file(&pdb_info->pdb_files[0], pdb_info->pdb_files[0].fpoext_stream);
    size = pdb_get_file_size(&pdb_info->pdb_files[0], pdb_info->pdb_files[0].fpoext_stream);
    if (fpoext && (size % sizeof(*fpoext)) == 0)
    {
        size /= sizeof(*fpoext);
        for (i = 0; i < size; i++)
        {
            if (fpoext[i].start <= ip && ip < fpoext[i].start + fpoext[i].func_size)
            {
                TRACE("\t%08x %08x %8x %8x %4x %4x %4x %08x %s\n",
                      fpoext[i].start, fpoext[i].func_size, fpoext[i].locals_size,
                      fpoext[i].params_size, fpoext[i].maxstack_size, fpoext[i].prolog_size,
                      fpoext[i].savedregs_size, fpoext[i].flags,
                      fpoext[i].str_offset < strsize ?
                          wine_dbgstr_a(strbase + 12 + fpoext[i].str_offset) : "<out of bounds>");
                if (fpoext[i].str_offset < strsize)
                    ret = pdb_parse_cmd_string(csw, &fpoext[i], strbase + 12 + fpoext[i].str_offset, cpair);
                else
                    ret = FALSE;
                break;
            }
        }
    }
    else ret = FALSE;
    pdb_free(fpoext);
    pdb_free(strbase);
 
    return ret;
}

Referenced by fetch_next_frame32().

◆ pe_load_builtin_module()

struct module * pe_load_builtin_module	(	struct process *	pcs,
		const WCHAR *	name,
		DWORD64	base,
		DWORD64	size
	)

Definition at line 896 of file pe_module.c.

{
    struct module*      module = NULL;
 
    if (base && pcs->dbg_hdr_addr)
    {
        IMAGE_NT_HEADERS    nth;
 
        if (pe_load_nt_header(pcs->handle, base, &nth))
        {
            if (!size) size = nth.OptionalHeader.SizeOfImage;
            module = module_new(pcs, name, DMT_PE, FALSE, base, size,
                                nth.FileHeader.TimeDateStamp,
                                nth.OptionalHeader.CheckSum);
        }
    }
    return module;
}

Referenced by SymLoadModuleExW().

◆ pe_load_debug_directory()

BOOL pe_load_debug_directory	(	const struct process *	pcs,
		struct module *	module,
		const BYTE *	mapping,
		const IMAGE_SECTION_HEADER *	sectp,
		DWORD	nsect,
		const IMAGE_DEBUG_DIRECTORY *	dbg,
		int	nDbg
	)

Definition at line 3391 of file msc.c.

{
    BOOL                        ret;
    int                         i;
    struct msc_debug_info       msc_dbg;
 
    msc_dbg.module = module;
    msc_dbg.nsect  = nsect;
    msc_dbg.sectp  = sectp;
    msc_dbg.nomap  = 0;
    msc_dbg.omapp  = NULL;
 
    __TRY
    {
        ret = FALSE;
 
        /* First, watch out for OMAP data */
        for (i = 0; i < nDbg; i++)
        {
            if (dbg[i].Type == IMAGE_DEBUG_TYPE_OMAP_FROM_SRC)
            {
                msc_dbg.nomap = dbg[i].SizeOfData / sizeof(OMAP_DATA);
                msc_dbg.omapp = (const OMAP_DATA*)(mapping + dbg[i].PointerToRawData);
                break;
            }
        }
  
        /* Now, try to parse CodeView debug info */
        for (i = 0; i < nDbg; i++)
        {
            if (dbg[i].Type == IMAGE_DEBUG_TYPE_CODEVIEW)
            {
                msc_dbg.root = mapping + dbg[i].PointerToRawData;
                if ((ret = codeview_process_info(pcs, &msc_dbg))) goto done;
            }
        }
    
        /* If not found, try to parse COFF debug info */
        for (i = 0; i < nDbg; i++)
        {
            if (dbg[i].Type == IMAGE_DEBUG_TYPE_COFF)
            {
                msc_dbg.root = mapping + dbg[i].PointerToRawData;
                if ((ret = coff_process_info(&msc_dbg))) goto done;
            }
        }
    done:
     /* FIXME: this should be supported... this is the debug information for
      * functions compiled without a frame pointer (FPO = frame pointer omission)
      * the associated data helps finding out the relevant information
      */
        for (i = 0; i < nDbg; i++)
            if (dbg[i].Type == IMAGE_DEBUG_TYPE_FPO)
                FIXME("This guy has FPO information\n");
#if 0
 
#define FRAME_FPO   0
#define FRAME_TRAP  1
#define FRAME_TSS   2
 
typedef struct _FPO_DATA 
{
    DWORD       ulOffStart;            /* offset 1st byte of function code */
    DWORD       cbProcSize;            /* # bytes in function */
    DWORD       cdwLocals;             /* # bytes in locals/4 */
    WORD        cdwParams;             /* # bytes in params/4 */
 
    WORD        cbProlog : 8;          /* # bytes in prolog */
    WORD        cbRegs   : 3;          /* # regs saved */
    WORD        fHasSEH  : 1;          /* TRUE if SEH in func */
    WORD        fUseBP   : 1;          /* TRUE if EBP has been allocated */
    WORD        reserved : 1;          /* reserved for future use */
    WORD        cbFrame  : 2;          /* frame type */
} FPO_DATA;
#endif
 
    }
    __EXCEPT_PAGE_FAULT
    {
        ERR("Got a page fault while loading symbols\n");
        ret = FALSE;
    }
    __ENDTRY
    return ret;
}

Referenced by pe_load_dbg_file(), and pe_load_msc_debug_info().

◆ pe_load_debug_info()

BOOL pe_load_debug_info	(	const struct process *	pcs,
		struct module *	module
	)

Definition at line 751 of file pe_module.c.

{
    BOOL                ret = FALSE;
 
    if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
    {
        ret = image_check_alternate(&module->format_info[DFI_PE]->u.pe_info->fmap, module);
        ret = pe_load_stabs(pcs, module) || ret;
        ret = pe_load_dwarf(module) || ret;
        #ifndef DBGHELP_STATIC_LIB
        ret = pe_load_msc_debug_info(pcs, module) || ret;
        ret = pe_load_rsym(module) || ret;
        #endif
 
        ret = ret || pe_load_coff_symbol_table(module); /* FIXME */
        /* if we still have no debug info (we could only get SymExport at this
         * point), then do the SymExport except if we have an ELF container,
         * in which case we'll rely on the export's on the ELF side
         */
    }
    /* FIXME shouldn't we check that? if (!module_get_debug(pcs, module)) */
    if (pe_load_export_debug_info(pcs, module) && !ret)
        ret = TRUE;
 
    return ret;
}

Referenced by module_get_debug(), and pe_load_native_module().

◆ pe_load_native_module()

struct module * pe_load_native_module	(	struct process *	pcs,
		const WCHAR *	name,
		HANDLE	hFile,
		DWORD64	base,
		DWORD	size
	)

Definition at line 803 of file pe_module.c.

{
    struct module*              module = NULL;
    BOOL                        opened = FALSE;
    struct module_format*       modfmt;
    WCHAR                       loaded_name[MAX_PATH];
 
    loaded_name[0] = '\0';
    if (!hFile)
    {
        assert(name);
 
        if ((hFile = FindExecutableImageExW(name, pcs->search_path, loaded_name, NULL, NULL)) == NULL)
            return NULL;
        opened = TRUE;
    }
    else if (name) lstrcpyW(loaded_name, name);
    else if (dbghelp_options & SYMOPT_DEFERRED_LOADS)
        FIXME("Trouble ahead (no module name passed in deferred mode)\n");
    if (!(modfmt = HeapAlloc(GetProcessHeap(), 0, sizeof(struct module_format) + sizeof(struct pe_module_info))))
        return NULL;
    modfmt->u.pe_info = (struct pe_module_info*)(modfmt + 1);
    if (pe_map_file(hFile, &modfmt->u.pe_info->fmap, DMT_PE))
    {
#ifndef __REACTOS__
        struct builtin_search builtin = { NULL };
        if (modfmt->u.pe_info->fmap.u.pe.builtin && search_dll_path(pcs, loaded_name, search_builtin_pe, &builtin))
        {
            TRACE("reloaded %s from %s\n", debugstr_w(loaded_name), debugstr_w(builtin.path));
            image_unmap_file(&modfmt->u.pe_info->fmap);
            modfmt->u.pe_info->fmap = builtin.fmap;
        }
#endif
        if (!base) base = modfmt->u.pe_info->fmap.u.pe.ntheader.OptionalHeader.ImageBase;
        if (!size) size = modfmt->u.pe_info->fmap.u.pe.ntheader.OptionalHeader.SizeOfImage;
 
        module = module_new(pcs, loaded_name, DMT_PE, FALSE, base, size,
                            modfmt->u.pe_info->fmap.u.pe.ntheader.FileHeader.TimeDateStamp,
                            modfmt->u.pe_info->fmap.u.pe.ntheader.OptionalHeader.CheckSum);
        if (module)
        {
#ifdef __REACTOS__
            module->real_path = NULL;
#else
            module->real_path = builtin.path;
#endif
            modfmt->module = module;
            modfmt->remove = pe_module_remove;
            modfmt->loc_compute = NULL;
 
            module->format_info[DFI_PE] = modfmt;
            if (dbghelp_options & SYMOPT_DEFERRED_LOADS)
                module->module.SymType = SymDeferred;
            else
                pe_load_debug_info(pcs, module);
            module->reloc_delta = base - modfmt->u.pe_info->fmap.u.pe.ntheader.OptionalHeader.ImageBase;
        }
        else
        {
            ERR("could not load the module '%s'\n", debugstr_w(loaded_name));
#ifndef __REACTOS__
            heap_free(builtin.path);
#endif
            image_unmap_file(&modfmt->u.pe_info->fmap);
        }
    }
    if (!module) HeapFree(GetProcessHeap(), 0, modfmt);
 
    if (opened) CloseHandle(hFile);
 
    return module;
}

Referenced by SymLoadModuleExW().

◆ pe_load_nt_header()

BOOL pe_load_nt_header	(	HANDLE	hProc,
		DWORD64	base,
		IMAGE_NT_HEADERS *	nth
	)

Definition at line 881 of file pe_module.c.

{
    IMAGE_DOS_HEADER    dos;
 
    return ReadProcessMemory(hProc, (char*)(DWORD_PTR)base, &dos, sizeof(dos), NULL) &&
        dos.e_magic == IMAGE_DOS_SIGNATURE &&
        ReadProcessMemory(hProc, (char*)(DWORD_PTR)(base + dos.e_lfanew),
                          nth, sizeof(*nth), NULL) &&
        nth->Signature == IMAGE_NT_SIGNATURE;
}

Referenced by fetch_pe_module_info_cb(), and pe_load_builtin_module().

◆ pe_map_directory()

const char * pe_map_directory	(	struct module *	module,
		int	dirno,
		DWORD *	size
	)

Definition at line 331 of file pe_module.c.

{
    IMAGE_NT_HEADERS*   nth;
    void*               mapping;
 
    if (module->type != DMT_PE || !module->format_info[DFI_PE]) return NULL;
    if (dirno >= IMAGE_NUMBEROF_DIRECTORY_ENTRIES ||
        !(mapping = pe_map_full(&module->format_info[DFI_PE]->u.pe_info->fmap, &nth)))
        return NULL;
    if (size) *size = nth->OptionalHeader.DataDirectory[dirno].Size;
    return RtlImageRvaToVa(nth, mapping,
                           nth->OptionalHeader.DataDirectory[dirno].VirtualAddress, NULL);
}

Referenced by x86_64_fetch_minidump_module(), and x86_64_find_runtime_function().

◆ pool_alloc()

void * pool_alloc	(	struct pool *	a,
		size_t	len
	)

Definition at line 89 of file storage.c.

{
    struct pool_arena*  arena;
    void*               ret;
    size_t size;
 
    len = (len + 3) & ~3; /* round up size on DWORD boundary */
 
    LIST_FOR_EACH_ENTRY( arena, &pool->arena_list, struct pool_arena, entry )
    {
        if (arena->end - arena->current >= len)
        {
            ret = arena->current;
            arena->current += len;
            if (arena->current + 16 >= arena->end)
            {
                list_remove( &arena->entry );
                list_add_tail( &pool->arena_full, &arena->entry );
            }
            return ret;
        }
    }
 
    size = max( pool->arena_size, len );
    arena = HeapAlloc(GetProcessHeap(), 0, size + sizeof(struct pool_arena));
    if (!arena) return NULL;
 
    ret = arena + 1;
    arena->current = (char*)ret + len;
    arena->end = (char*)ret + size;
    if (arena->current + 16 >= arena->end)
        list_add_tail( &pool->arena_full, &arena->entry );
    else
        list_add_head( &pool->arena_list, &arena->entry );
    return ret;
}

Referenced by dwarf2_compute_location_attr(), dwarf2_get_cpp_name(), dwarf2_parse_abbrev_set(), dwarf2_parse_line_numbers(), dwarf2_parse_variable(), dwarf2_read_one_debug_info(), elf_hash_symtab(), hash_table_add(), macho_stabs_def_cb(), pev_set_value(), pool_strdup(), source_new(), symt_add_enum_element(), symt_add_func_local(), symt_add_function_point(), symt_add_function_signature_parameter(), symt_add_udt_element(), symt_new_array(), symt_new_basic(), symt_new_compiland(), symt_new_constant(), symt_new_enum(), symt_new_function(), symt_new_function_signature(), symt_new_global_variable(), symt_new_label(), symt_new_pointer(), symt_new_public(), symt_new_thunk(), symt_new_typedef(), symt_new_udt(), symt_open_func_block(), symt_ptr2index(), and vector_add().

◆ pool_destroy()

void pool_destroy ( struct pool * a )

Definition at line 50 of file storage.c.

{
    struct pool_arena*  arena;
    struct pool_arena*  next;
 
#ifdef USE_STATS
    size_t alloc, used, num;
 
    alloc = used = num = 0;
    LIST_FOR_EACH_ENTRY( arena, &pool->arena_list, struct pool_arena, entry )
    {
        alloc += arena->end - (char *)arena;
        used += arena->current - (char*)arena;
        num++;
    }
    LIST_FOR_EACH_ENTRY( arena, &pool->arena_full, struct pool_arena, entry )
    {
        alloc += arena->end - (char *)arena;
        used += arena->current - (char*)arena;
        num++;
    }
    if (alloc == 0) alloc = 1;      /* avoid division by zero */
    FIXME("STATS: pool %p has allocated %u kbytes, used %u kbytes in %u arenas, non-allocation ratio: %.2f%%\n",
          pool, (unsigned)(alloc >> 10), (unsigned)(used >> 10), (unsigned)num,
          100.0 - (float)used / (float)alloc * 100.0);
#endif
 
    LIST_FOR_EACH_ENTRY_SAFE( arena, next, &pool->arena_list, struct pool_arena, entry )
    {
        list_remove( &arena->entry );
        HeapFree(GetProcessHeap(), 0, arena);
    }
    LIST_FOR_EACH_ENTRY_SAFE( arena, next, &pool->arena_full, struct pool_arena, entry )
    {
        list_remove( &arena->entry );
        HeapFree(GetProcessHeap(), 0, arena);
    }
}

Referenced by dwarf2_parse_compilation_unit(), elf_load_debug_info(), macho_load_debug_info(), module_remove(), pev_free(), and rsym_parse().

◆ pool_init()

void pool_init	(	struct pool *	a,
		size_t	arena_size
	)

Definition at line 43 of file storage.c.

{
    list_init( &a->arena_list );
    list_init( &a->arena_full );
    a->arena_size = arena_size;
}

Referenced by dwarf2_parse_compilation_unit(), elf_load_debug_info(), macho_load_debug_info(), module_new(), pev_init(), and rsym_parse().

◆ pool_strdup()

char * pool_strdup	(	struct pool *	a,
		const char *	str
	)

Definition at line 126 of file storage.c.

{
    char* ret;
    if ((ret = pool_alloc(pool, strlen(str) + 1))) strcpy(ret, str);
    return ret;
}

Referenced by dwarf2_parse_variable(), macho_stabs_def_cb(), pev_push(), pev_set_value(), symt_add_enum_element(), symt_add_func_local(), symt_add_function_point(), symt_add_udt_element(), symt_new_basic(), symt_new_constant(), symt_new_enum(), symt_new_function(), symt_new_global_variable(), symt_new_label(), symt_new_public(), symt_new_thunk(), symt_new_typedef(), symt_new_udt(), and symt_ptr2index().

◆ process_find_by_handle()

struct process * process_find_by_handle ( HANDLE hProcess )

Definition at line 99 of file dbghelp.c.

{
    struct process* p;
 
    for (p = process_first; p && p->handle != hProcess; p = p->next);
    if (!p) SetLastError(ERROR_INVALID_HANDLE);
    return p;
}

Referenced by dwarf2_virtual_unwind(), MiniDumpWriteDump(), pdb_virtual_unwind(), reg_cb64to32(), sym_enum(), sym_register_cb(), SymAddSymbolW(), SymEnumerateModulesW64(), SymEnumLines(), SymEnumSourceFilesW(), SymEnumTypes(), SymFindFileInPathW(), SymFromAddr(), SymFromName(), SymFunctionTableAccess64(), SymGetLineFromAddr64(), SymGetLineFromAddrW64(), SymGetLineNext64(), SymGetLinePrev64(), SymGetModuleBase64(), SymGetModuleInfoW64(), SymGetSearchPathW(), SymGetTypeFromName(), SymGetTypeInfo(), SymInitializeW(), SymLoadModuleExW(), SymRefreshModuleList(), SymSetContext(), SymSetScopeFromAddr(), SymSetSearchPathW(), SymUnloadModule(), SymUnloadModule64(), and x86_64_fetch_minidump_module().

◆ process_getenv()

const WCHAR * process_getenv	(	const struct process *	process,
		const WCHAR *	name
	)

Definition at line 335 of file dbghelp.c.

{
    size_t name_len;
    const WCHAR *iter;
 
    if (!process->environment) return NULL;
    name_len = lstrlenW(name);
 
    for (iter = process->environment; *iter; iter += lstrlenW(iter) + 1)
    {
        if (!wcsnicmp(iter, name, name_len) && iter[name_len] == '=')
            return iter + name_len + 1;
    }
 
    return NULL;
}

Referenced by elf_search_and_load_file(), macho_search_and_load_file(), and search_dll_path().

◆ read_process_memory()

static BOOL read_process_memory	(	const struct process *	process,
		UINT64	addr,
		void *	buf,
		size_t	size
	)

inlinestatic

Definition at line 451 of file dbghelp_private.h.

{
    return ReadProcessMemory(process->handle, (void*)(UINT_PTR)addr, buf, size, NULL);
}

Referenced by check_live_target(), dump_memory64_info(), dump_memory_info(), elf_enum_modules_internal(), image_uses_split_segs(), macho_enum_modules_internal(), macho_search_loader(), and x86_64_fetch_minidump_module().

◆ rsym_parse()

BOOL rsym_parse	(	struct module *	module,
		unsigned long	load_offset,
		const void *	rsym,
		int	rsymlen
	)

Definition at line 79 of file rsym.c.

{
    const ROSSYM_HEADER* RosSymHeader;
    const ROSSYM_ENTRY* First, *Last, *Entry;
    const CHAR* Strings;
 
    struct pool pool;
    struct sparse_array file_table, func_table;
    rsym_func_entry_t* first_func = NULL;
 
 
    RosSymHeader = rsym_ptr;
 
    if (RosSymHeader->SymbolsOffset < sizeof(ROSSYM_HEADER)
        || RosSymHeader->StringsOffset < RosSymHeader->SymbolsOffset + RosSymHeader->SymbolsLength
        || rsymlen < RosSymHeader->StringsOffset + RosSymHeader->StringsLength
        || 0 != (RosSymHeader->SymbolsLength % sizeof(ROSSYM_ENTRY)))
    {
        WARN("Invalid ROSSYM_HEADER\n");
        return FALSE;
    }
 
    First = (const ROSSYM_ENTRY *)((const char*)rsym_ptr + RosSymHeader->SymbolsOffset);
    Last = First + RosSymHeader->SymbolsLength / sizeof(ROSSYM_ENTRY);
    Strings = (const CHAR*)rsym_ptr + RosSymHeader->StringsOffset;
 
    pool_init(&pool, 65536);
    sparse_array_init(&file_table, sizeof(rsym_file_entry_t), 64);
    sparse_array_init(&func_table, sizeof(rsym_func_entry_t), 128);
 
    for (Entry = First; Entry != Last; Entry++)
    {
        ULONG Address = load_offset + Entry->Address;
        if (!Entry->FileOffset)
        {
            rsym_func_entry_t* func = sparse_array_find(&func_table, Entry->FunctionOffset);
 
            /* We do not want to define a data point where there is already a function! */
            if (!func || func->Address != Address)
            {
                const char* SymbolName = Strings + Entry->FunctionOffset;
                if (!is_metadata_sym(SymbolName))
                {
                    /* TODO: How should we determine the size? */
                    ULONG Size = sizeof(ULONG);
                    if (use_raw_address(SymbolName))
                        Address = Entry->Address;
 
                    symt_new_public(module, NULL, SymbolName, FALSE, Address, Size);
                }
                else
                {
                    /* Maybe use it to fill some metadata? */
                }
            }
        }
        else
        {
            rsym_file_entry_t* file = sparse_array_find(&file_table, Entry->FileOffset);
            rsym_func_entry_t* func = sparse_array_find(&func_table, Entry->FunctionOffset);
 
            if (!file)
            {
                file = sparse_array_add(&file_table, Entry->FileOffset, &pool);
                file->File = Strings + Entry->FileOffset;
                file->Source = source_new(module, NULL, Strings + Entry->FileOffset);
            }
 
            if (!func)
            {
                func = sparse_array_add(&func_table, Entry->FunctionOffset, &pool);
                func->func = symt_new_function(module, NULL, Strings + Entry->FunctionOffset,
                    Address, 0, NULL);
                func->Address = Address;
                func->next = first_func;
                first_func = func;
            }
 
            /* TODO: What if we have multiple chunks scattered around? */
            symt_add_func_line(module, func->func, file->Source, Entry->SourceLine, Address - func->Address);
        }
    }
 
    while (first_func)
    {
        /* TODO: Size of function? */
        rsym_finalize_function(module, first_func->func);
        first_func = first_func->next;
    }
 
    module->module.SymType = SymDia;
    module->module.CVSig = 'R' | ('S' << 8) | ('Y' << 16) | ('M' << 24);
    module->module.LineNumbers = TRUE;
    module->module.GlobalSymbols = TRUE;
    module->module.TypeInfo = FALSE;
    module->module.SourceIndexed = TRUE;
    module->module.Publics = TRUE;
 
    pool_destroy(&pool);
 
    return TRUE;
}

Referenced by pe_load_rsym().

◆ search_dll_path()

BOOL search_dll_path	(	const struct process *	process,
		const WCHAR *	name,
		BOOL()(void , HANDLE, const WCHAR *)	match,
		void *	param
	)

Definition at line 697 of file path.c.

{
    const WCHAR *env;
    size_t len, i;
    HANDLE file;
    WCHAR *buf;
    BOOL ret;
 
    name = file_name(name);
 
    if ((env = process_getenv(process, L"WINEBUILDDIR")))
    {
        WCHAR *p, *end;
        const WCHAR dllsW[] = { '\\','d','l','l','s','\\' };
        const WCHAR programsW[] = { '\\','p','r','o','g','r','a','m','s','\\' };
        const WCHAR dot_dllW[] = {'.','d','l','l',0};
        const WCHAR dot_exeW[] = {'.','e','x','e',0};
        const WCHAR dot_soW[] = {'.','s','o',0};
 
 
        len = lstrlenW(env);
        if (!(buf = heap_alloc((len + 8 + 3 * lstrlenW(name)) * sizeof(WCHAR)))) return FALSE;
        wcscpy(buf, env);
        end = buf + len;
 
        memcpy(end, dllsW, sizeof(dllsW));
        lstrcpyW(end + ARRAY_SIZE(dllsW), name);
        if ((p = wcsrchr(end, '.')) && !lstrcmpW(p, dot_soW)) *p = 0;
        if ((p = wcsrchr(end, '.')) && !lstrcmpW(p, dot_dllW)) *p = 0;
        p = end + lstrlenW(end);
        *p++ = '\\';
        lstrcpyW(p, name);
        file = CreateFileW(buf, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
        if (file != INVALID_HANDLE_VALUE)
        {
            ret = match(param, file, buf);
            CloseHandle(file);
            if (ret) goto found;
        }
 
        memcpy(end, programsW, sizeof(programsW));
        end += ARRAY_SIZE(programsW);
        lstrcpyW(end, name);
        if ((p = wcsrchr(end, '.')) && !lstrcmpW(p, dot_soW)) *p = 0;
        if ((p = wcsrchr(end, '.')) && !lstrcmpW(p, dot_exeW)) *p = 0;
        p = end + lstrlenW(end);
        *p++ = '\\';
        lstrcpyW(p, name);
        file = CreateFileW(buf, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
        if (file != INVALID_HANDLE_VALUE)
        {
            ret = match(param, file, buf);
            CloseHandle(file);
            if (ret) goto found;
        }
 
        heap_free(buf);
    }
 
    for (i = 0;; i++)
    {
        WCHAR env_name[64];
        swprintf(env_name, ARRAY_SIZE(env_name), L"WINEDLLDIR%u", i);
        if (!(env = process_getenv(process, env_name))) return FALSE;
        len = wcslen(env) + wcslen(name) + 2;
        if (!(buf = heap_alloc(len * sizeof(WCHAR)))) return FALSE;
        swprintf(buf, len, L"%s\\%s", env, name);
        file = CreateFileW(buf, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
        if (file != INVALID_HANDLE_VALUE)
        {
            ret = match(param, file, buf);
            CloseHandle(file);
            if (ret) goto found;
        }
        heap_free(buf);
    }
 
    return FALSE;
 
found:
    TRACE("found %s\n", debugstr_w(buf));
    heap_free(buf);
    return TRUE;
}

Referenced by elf_search_and_load_file(), macho_search_and_load_file(), and pe_load_native_module().

◆ search_unix_path()

BOOL search_unix_path	(	const WCHAR *	name,
		const WCHAR *	path,
		BOOL()(void , HANDLE, const WCHAR *)	match,
		void *	param
	)

Definition at line 782 of file path.c.

{
    const WCHAR *iter, *next;
    size_t size, len;
    WCHAR *dos_path;
    char *buf;
    BOOL ret = FALSE;
 
    if (!path) return FALSE;
    name = file_name(name);
 
    size = WideCharToMultiByte(CP_UNIXCP, 0, name, -1, NULL, 0, NULL, NULL)
        + WideCharToMultiByte(CP_UNIXCP, 0, path, -1, NULL, 0, NULL, NULL);
    if (!(buf = heap_alloc(size))) return FALSE;
 
    for (iter = path;; iter = next + 1)
    {
        if (!(next = wcschr(iter, ':'))) next = iter + lstrlenW(iter);
        if (*iter == '/')
        {
            len = WideCharToMultiByte(CP_UNIXCP, 0, iter, next - iter, buf, size, NULL, NULL);
            if (buf[len - 1] != '/') buf[len++] = '/';
            WideCharToMultiByte(CP_UNIXCP, 0, name, -1, buf + len, size - len, NULL, NULL);
            if ((dos_path = wine_get_dos_file_name(buf)))
            {
                HANDLE file = CreateFileW(dos_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
                if (file != INVALID_HANDLE_VALUE)
                {
                    ret = match(param, file, dos_path);
                    CloseHandle(file);
                    if (ret) TRACE("found %s\n", debugstr_w(dos_path));
                }
                heap_free(dos_path);
                if (ret) break;
            }
        }
        if (*next != ':') break;
    }
 
    heap_free(buf);
    return ret;
}

Referenced by elf_search_and_load_file(), and macho_search_and_load_file().

◆ source_get()

const char * source_get	(	const struct module *	module,
		unsigned	idx
	)

Definition at line 130 of file source.c.

{
    if (idx == -1) return "";
    assert(module->sources);
    return module->sources + idx;
}

Referenced by coff_process_info(), dwarf2_set_line_number(), elf_lookup_symtab(), SymEnumLines(), SymGetLinePrev64(), symt_add_func_line(), symt_fill_func_line_info(), symt_get_func_line_next(), and symt_new_compiland().

◆ source_new()

unsigned source_new	(	struct module *	module,
		const char *	basedir,
		const char *	source
	)

Definition at line 66 of file source.c.

{
    unsigned    ret = -1;
    const char* full;
    char*       tmp = NULL;
 
    if (!name) return ret;
    if (!base || *name == '/')
        full = name;
    else
    {
        unsigned bsz = strlen(base);
 
        tmp = HeapAlloc(GetProcessHeap(), 0, bsz + 1 + strlen(name) + 1);
        if (!tmp) return ret;
        full = tmp;
        strcpy(tmp, base);
        if (tmp[bsz - 1] != '/') tmp[bsz++] = '/';
        strcpy(&tmp[bsz], name);
    }
    rb_module = module;
    if (!module->sources || (ret = source_find(full)) == (unsigned)-1)
    {
        char* new;
        int len = strlen(full) + 1;
        struct source_rb* rb;
 
        if (module->sources_used + len + 1 > module->sources_alloc)
        {
            if (!module->sources)
            {
                module->sources_alloc = (module->sources_used + len + 1 + 255) & ~255;
                new = HeapAlloc(GetProcessHeap(), 0, module->sources_alloc);
            }
            else
            {
                module->sources_alloc = max( module->sources_alloc * 2,
                                             (module->sources_used + len + 1 + 255) & ~255 );
                new = HeapReAlloc(GetProcessHeap(), 0, module->sources,
                                  module->sources_alloc);
            }
            if (!new) goto done;
            module->sources = new;
        }
        ret = module->sources_used;
        memcpy(module->sources + module->sources_used, full, len);
        module->sources_used += len;
        module->sources[module->sources_used] = '\0';
        if ((rb = pool_alloc(&module->pool, sizeof(*rb))))
        {
            rb->source = ret;
            wine_rb_put(&module->sources_offsets_tree, full, &rb->entry);
        }
    }
done:
    HeapFree(GetProcessHeap(), 0, tmp);
    return ret;
}

Referenced by codeview_snarf(), codeview_snarf_linetab(), codeview_snarf_linetab2(), coff_add_file(), dwarf2_parse_compilation_unit(), dwarf2_parse_line_numbers(), elf_hash_symtab(), pe_load_coff_symbol_table(), rsym_parse(), and stabs_parse().

◆ source_rb_compare()

int source_rb_compare	(	const void *	key,
		const struct wine_rb_entry *	entry
	)

Definition at line 40 of file source.c.

{
    const struct source_rb *t = WINE_RB_ENTRY_VALUE(entry, const struct source_rb, entry);
 
    return strcmp((const char*)key, rb_module->sources + t->source);
}

Referenced by module_new().

◆ sparse_array_add()

void * sparse_array_add	(	struct sparse_array *	sa,
		ULONG_PTR	key,
		struct pool *	pool
	)

Definition at line 281 of file storage.c.

{
    unsigned            idx, i;
    struct key2index*   pk2i;
    struct key2index*   to;
 
    pk2i = sparse_array_lookup(sa, key, &idx);
    if (pk2i && pk2i->key == key)
    {
        FIXME("re-adding an existing key\n");
        return NULL;
    }
    to = vector_add(&sa->key2index, pool);
    if (pk2i)
    {
        /* we need to shift vector's content... */
        /* let's do it brute force... (FIXME) */
        assert(sa->key2index.num_elts >= 2);
        for (i = sa->key2index.num_elts - 1; i > idx; i--)
        {
            pk2i = vector_at(&sa->key2index, i - 1);
            *to = *pk2i;
            to = pk2i;
        }
    }
 
    to->key = key;
    to->index = sa->elements.num_elts;
 
    return vector_add(&sa->elements, pool);
}

Referenced by dwarf2_parse_abbrev_set(), dwarf2_read_one_debug_info(), and rsym_parse().

◆ sparse_array_find()

void * sparse_array_find	(	const struct sparse_array *	sa,
		ULONG_PTR	idx
	)

Definition at line 271 of file storage.c.

{
    unsigned            idx;
    struct key2index*   pk2i;
 
    if ((pk2i = sparse_array_lookup(sa, key, &idx)) && pk2i->key == key)
        return vector_at(&sa->elements, pk2i->index);
    return NULL;
}

Referenced by dwarf2_abbrev_table_find_entry(), dwarf2_find_attribute(), dwarf2_get_cpp_name(), dwarf2_get_di_children(), dwarf2_lookup_type(), and rsym_parse().

◆ sparse_array_init()

void sparse_array_init	(	struct sparse_array *	sa,
		unsigned	elt_sz,
		unsigned	bucket_sz
	)

Definition at line 213 of file storage.c.

{
    vector_init(&sa->key2index, sizeof(struct key2index), bucket_sz);
    vector_init(&sa->elements, elt_sz, bucket_sz);
}

Referenced by dwarf2_parse_abbrev_set(), dwarf2_parse_compilation_unit(), and rsym_parse().

◆ sparse_array_length()

unsigned sparse_array_length ( const struct sparse_array * sa )

Definition at line 314 of file storage.c.

{
    return sa->elements.num_elts;
}

Referenced by dwarf2_parse_abbrev_set().

◆ stabs_parse()

BOOL stabs_parse	(	struct module *	module,
		ULONG_PTR	load_offset,
		const char *	stabs,
		size_t	nstab,
		size_t	stabsize,
		const char *	strs,
		int	strtablen,
		stabs_def_cb	callback,
		void *	user
	)

Definition at line 1241 of file stabs.c.

{
    struct symt_function*       curr_func = NULL;
    struct symt_block*          block = NULL;
    struct symt_compiland*      compiland = NULL;
    char*                       srcpath = NULL;
    int                         i;
    const char*                 ptr;
    char*                       stabbuff;
    unsigned int                stabbufflen;
    const struct stab_nlist*    stab_ptr;
    const char*                 strs_end;
    int                         strtabinc;
    char                        symname[4096];
    unsigned                    incl[32];
    int                         incl_stk = -1;
    int                         source_idx = -1;
    struct pending_list         pending_block;
    struct pending_list         pending_func;
    BOOL                        ret = TRUE;
    struct location             loc;
    unsigned char               type;
    uint64_t                    n_value;
 
    strs_end = strs + strtablen;
 
    memset(stabs_basic, 0, sizeof(stabs_basic));
    memset(&pending_block, 0, sizeof(pending_block));
    memset(&pending_func, 0, sizeof(pending_func));
 
    /*
     * Allocate a buffer into which we can build stab strings for cases
     * where the stab is continued over multiple lines.
     */
    stabbufflen = 65536;
    stabbuff = HeapAlloc(GetProcessHeap(), 0, stabbufflen);
 
    strtabinc = 0;
    stabbuff[0] = '\0';
    for (i = 0; i < nstab; i++)
    {
        stab_ptr = (struct stab_nlist *)(pv_stab_ptr + i * stabsize);
        n_value = stabsize == sizeof(struct macho64_nlist) ? ((struct macho64_nlist *)stab_ptr)->n_value : stab_ptr->n_value;
        ptr = strs + stab_ptr->n_strx;
        if ((ptr > strs_end) || (ptr + strlen(ptr) > strs_end))
        {
            WARN("Bad stabs string %p\n", ptr);
            continue;
        }
        if (*ptr != '\0' && (ptr[strlen(ptr) - 1] == '\\'))
        {
            /*
             * Indicates continuation.  Append this to the buffer, and go onto the
             * next record.  Repeat the process until we find a stab without the
             * '/' character, as this indicates we have the whole thing.
             */
            stabbuf_append(&stabbuff, &stabbufflen, ptr);
            continue;
        }
        else if (stabbuff[0] != '\0')
        {
            stabbuf_append(&stabbuff, &stabbufflen, ptr);
            ptr = stabbuff;
        }
 
        if (stab_ptr->n_type & N_STAB)
            type = stab_ptr->n_type;
        else
        {
            type = (stab_ptr->n_type & N_TYPE);
            if (module->type == DMT_MACHO) type &= ~N_PEXT;
        }
 
        /* only symbol entries contain a typedef */
        switch (type)
        {
        case N_GSYM:
        case N_LCSYM:
        case N_STSYM:
        case N_RSYM:
        case N_LSYM:
        case N_ROSYM:
        case N_PSYM:
            if (strchr(ptr, '=') != NULL)
            {
                /*
                 * The stabs aren't in writable memory, so copy it over so we are
                 * sure we can scribble on it.
                 */
                if (ptr != stabbuff)
                {
                    stabbuff[0] = 0;
                    stabbuf_append(&stabbuff, &stabbufflen, ptr);
                    ptr = stabbuff;
                }
                stab_strcpy(symname, sizeof(symname), ptr);
                if (!stabs_parse_typedef(module, ptr, symname))
                {
                    /* skip this definition */
                    stabbuff[0] = '\0';
                    continue;
                }
            }
        }
 
        switch (type)
        {
        case N_GSYM:
            /*
             * These are useless with ELF.  They have no value, and you have to
             * read the normal symbol table to get the address.  Thus we
             * ignore them, and when we process the normal symbol table
             * we should do the right thing.
             *
             * With a.out or mingw, they actually do make some amount of sense.
             */
            stab_strcpy(symname, sizeof(symname), ptr);
            loc.kind = loc_absolute;
            loc.reg = 0;
            loc.offset = load_offset + n_value;
            symt_new_global_variable(module, compiland, symname, TRUE /* FIXME */,
                                     loc, 0, stabs_parse_type(ptr));
            break;
        case N_LCSYM:
        case N_STSYM:
            /* These are static symbols and BSS symbols. */
            stab_strcpy(symname, sizeof(symname), ptr);
            loc.kind = loc_absolute;
            loc.reg = 0;
            loc.offset = load_offset + n_value;
            symt_new_global_variable(module, compiland, symname, TRUE /* FIXME */,
                                     loc, 0, stabs_parse_type(ptr));
            break;
        case N_LBRAC:
            if (curr_func)
            {
                block = symt_open_func_block(module, curr_func, block,
                                             n_value, 0);
                pending_flush(&pending_block, module, curr_func, block);
            }
            break;
        case N_RBRAC:
            if (curr_func)
                block = symt_close_func_block(module, curr_func, block,
                                              n_value);
            break;
        case N_PSYM:
            /* These are function parameters. */
            if (curr_func != NULL)
            {
                struct symt*    param_type = stabs_parse_type(ptr);
                stab_strcpy(symname, sizeof(symname), ptr);
                loc.kind = loc_regrel;
                loc.reg = dbghelp_current_cpu->frame_regno;
                loc.offset = n_value;
                symt_add_func_local(module, curr_func,
                                    (int)n_value >= 0 ? DataIsParam : DataIsLocal,
                                    &loc, NULL, param_type, symname);
                symt_add_function_signature_parameter(module,
                                                      (struct symt_function_signature*)curr_func->type,
                                                      param_type);
            }
            break;
        case N_RSYM:
            /* These are registers (as local variables) */
            if (curr_func != NULL)
            {
                loc.kind = loc_register;
                loc.offset = 0;
 
                switch (n_value)
                {
                case  0: loc.reg = CV_REG_EAX; break;
                case  1: loc.reg = CV_REG_ECX; break;
                case  2: loc.reg = CV_REG_EDX; break;
                case  3: loc.reg = CV_REG_EBX; break;
                case  4: loc.reg = CV_REG_ESP; break;
                case  5: loc.reg = CV_REG_EBP; break;
                case  6: loc.reg = CV_REG_ESI; break;
                case  7: loc.reg = CV_REG_EDI; break;
                case 11:
                case 12:
                case 13:
                case 14:
                case 15:
                case 16:
                case 17:
                case 18:
                case 19: loc.reg = CV_REG_ST0 + n_value - 12; break;
                case 21:
                case 22:
                case 23:
                case 24:
                case 25:
                case 26:
                case 27:
                case 28: loc.reg = CV_REG_XMM0 + n_value - 21; break;
                case 29:
                case 30:
                case 31:
                case 32:
                case 33:
                case 34:
                case 35:
                case 36: loc.reg = CV_REG_MM0 + n_value - 29; break;
                default:
                    FIXME("Unknown register value (%lu)\n", (ULONG_PTR)n_value);
                    loc.reg = CV_REG_NONE;
                    break;
                }
                stab_strcpy(symname, sizeof(symname), ptr);
                if (ptr[strlen(symname) + 1] == 'P')
                {
                    struct symt*    param_type = stabs_parse_type(ptr);
                    stab_strcpy(symname, sizeof(symname), ptr);
                    symt_add_func_local(module, curr_func, DataIsParam, &loc,
                                        NULL, param_type, symname);
                    symt_add_function_signature_parameter(module,
                                                          (struct symt_function_signature*)curr_func->type,
                                                          param_type);
                }
                else
                    pending_add_var(&pending_block, ptr, DataIsLocal, &loc);
            }
            break;
        case N_LSYM:
            /* These are local variables */
            loc.kind = loc_regrel;
            loc.reg = dbghelp_current_cpu->frame_regno;
            loc.offset = n_value;
            if (curr_func != NULL) pending_add_var(&pending_block, ptr, DataIsLocal, &loc);
            break;
        case N_SLINE:
            /*
             * This is a line number.  These are always relative to the start
             * of the function (N_FUN), and this makes the lookup easier.
             */
            assert(source_idx >= 0);
            if (curr_func != NULL)
            {
                ULONG_PTR offset = n_value;
                if (module->type == DMT_MACHO)
                    offset -= curr_func->address - load_offset;
                symt_add_func_line(module, curr_func, source_idx,
                                   stab_ptr->n_desc, offset);
            }
            else pending_add_line(&pending_func, source_idx, stab_ptr->n_desc,
                                  n_value, load_offset);
            break;
        case N_FUN:
            /*
             * For now, just declare the various functions.  Later
             * on, we will add the line number information and the
             * local symbols.
             */
            /*
             * Copy the string to a temp buffer so we
             * can kill everything after the ':'.  We do
             * it this way because otherwise we end up dirtying
             * all of the pages related to the stabs, and that
             * sucks up swap space like crazy.
             */
            stab_strcpy(symname, sizeof(symname), ptr);
            if (*symname)
            {
                struct symt_function_signature* func_type;
 
                if (curr_func)
                {
                    /* First, clean up the previous function we were working on.
                     * Assume size of the func is the delta between current offset
                     * and offset of last function
                     */
                    stabs_finalize_function(module, curr_func,
                                            n_value ?
                                                (load_offset + n_value - curr_func->address) : 0);
                }
                func_type = symt_new_function_signature(module,
                                                        stabs_parse_type(ptr), -1);
                curr_func = symt_new_function(module, compiland, symname,
                                              load_offset + n_value, 0,
                                              &func_type->symt);
                pending_flush(&pending_func, module, curr_func, NULL);
            }
            else
            {
                /* some versions of GCC to use a N_FUN "" to mark the end of a function
                 * and n_value contains the size of the func
                 */
                stabs_finalize_function(module, curr_func, n_value);
                curr_func = NULL;
            }
            break;
        case N_SO:
            /*
             * This indicates a new source file.  Append the records
             * together, to build the correct path name.
             */
            if (*ptr == '\0') /* end of N_SO file */
            {
                /* Nuke old path. */
                HeapFree(GetProcessHeap(), 0, srcpath);
                srcpath = NULL;
                stabs_finalize_function(module, curr_func, 0);
                curr_func = NULL;
                source_idx = -1;
                incl_stk = -1;
                assert(block == NULL);
                compiland = NULL;
            }
            else
            {
                int len = strlen(ptr);
                if (ptr[len-1] != '/')
                {
                    stabs_reset_includes();
                    source_idx = source_new(module, srcpath, ptr);
                    compiland = symt_new_compiland(module, 0 /* FIXME */, source_idx);
                }
                else
                {
                    srcpath = HeapAlloc(GetProcessHeap(), 0, len + 1);
                    strcpy(srcpath, ptr);
                }
            }
            break;
        case N_SOL:
            source_idx = source_new(module, srcpath, ptr);
            break;
        case N_UNDF:
            strs += strtabinc;
            strtabinc = n_value;
            /* I'm not sure this is needed, so trace it before we obsolete it */
            if (curr_func)
            {
                FIXME("UNDF: curr_func %s\n", curr_func->hash_elt.name);
                stabs_finalize_function(module, curr_func, 0); /* FIXME */
                curr_func = NULL;
            }
            break;
        case N_OPT:
            /* Ignore this. We don't care what it points to. */
            break;
        case N_BINCL:
            stabs_add_include(stabs_new_include(ptr, n_value));
            assert(incl_stk < (int) ARRAY_SIZE(incl) - 1);
            incl[++incl_stk] = source_idx;
            source_idx = source_new(module, NULL, ptr);
            break;
        case N_EINCL:
            assert(incl_stk >= 0);
            source_idx = incl[incl_stk--];
            break;
    case N_EXCL:
            if (stabs_add_include(stabs_find_include(ptr, n_value)) < 0)
            {
                ERR("Excluded header not found (%s,%ld)\n", ptr, (ULONG_PTR)n_value);
                module_reset_debug_info(module);
                ret = FALSE;
                goto done;
            }
            break;
        case N_MAIN:
            /* Always ignore these. GCC doesn't even generate them. */
            break;
        case N_BNSYM:
        case N_ENSYM:
        case N_OSO:
        case N_INDR:
            /* Always ignore these, they seem to be used only on Darwin. */
            break;
        case N_ABS:
        case N_SECT:
            /* FIXME: Other definition types (N_TEXT, N_DATA, N_BSS, ...)? */
            if (callback)
            {
                BOOL is_public = (stab_ptr->n_type & N_EXT);
                BOOL is_global = is_public;
 
                /* "private extern"; shared among compilation units in a shared
                 * library, but not accessible from outside the library. */
                if (stab_ptr->n_type & N_PEXT)
                {
                    is_public = FALSE;
                    is_global = TRUE;
                }
 
                if (*ptr == '_') ptr++;
                stab_strcpy(symname, sizeof(symname), ptr);
 
                callback(module, load_offset, symname, n_value,
                         is_public, is_global, stab_ptr->n_other, compiland, user);
            }
            break;
        default:
            ERR("Unknown stab type 0x%02x\n", type);
            break;
        }
        stabbuff[0] = '\0';
        TRACE("0x%02x %lx %s\n",
              stab_ptr->n_type, (ULONG_PTR)n_value, debugstr_a(strs + stab_ptr->n_strx));
    }
    module->module.SymType = SymDia;
    module->module.CVSig = 'S' | ('T' << 8) | ('A' << 16) | ('B' << 24);
    /* FIXME: we could have a finer grain here */
    module->module.LineNumbers = TRUE;
    module->module.GlobalSymbols = TRUE;
    module->module.TypeInfo = TRUE;
    module->module.SourceIndexed = TRUE;
    module->module.Publics = TRUE;
done:
    HeapFree(GetProcessHeap(), 0, stabbuff);
    stabs_free_includes();
    HeapFree(GetProcessHeap(), 0, pending_block.objs);
    HeapFree(GetProcessHeap(), 0, pending_func.objs);
    HeapFree(GetProcessHeap(), 0, srcpath);
 
    return ret;
}

Referenced by elf_load_debug_info_from_map(), macho_parse_symtab(), and pe_load_stabs().

◆ sw_module_base()

DWORD64 sw_module_base	(	struct cpu_stack_walk *	csw,
		DWORD64	addr
	)

Definition at line 127 of file stack.c.

{
    if (csw->is32)
        return csw->u.s32.f_modl_bas(csw->hProcess, addr);
    else
        return csw->u.s64.f_modl_bas(csw->hProcess, addr);
}

Referenced by i386_stack_walk().

◆ sw_read_mem()

BOOL sw_read_mem	(	struct cpu_stack_walk *	csw,
		DWORD64	addr,
		void *	ptr,
		DWORD	sz
	)

Definition at line 95 of file stack.c.

{
    DWORD bytes_read = 0;
    if (csw->is32)
        return csw->u.s32.f_read_mem(csw->hProcess, addr, ptr, sz, &bytes_read);
    else
        return csw->u.s64.f_read_mem(csw->hProcess, addr, ptr, sz, &bytes_read);
}

Referenced by apply_frame_state(), eval_expression(), fetch_next_frame32(), i386_stack_walk(), pev_deref(), and set_context_reg().

◆ sw_table_access()

void * sw_table_access	(	struct cpu_stack_walk *	csw,
		DWORD64	addr
	)

Definition at line 119 of file stack.c.

{
    if (csw->is32)
        return csw->u.s32.f_tabl_acs(csw->hProcess, addr);
    else
        return csw->u.s64.f_tabl_acs(csw->hProcess, addr);
}

Referenced by i386_stack_walk().

◆ sw_xlat_addr()

DWORD64 sw_xlat_addr	(	struct cpu_stack_walk *	csw,
		ADDRESS64 *	addr
	)

Definition at line 104 of file stack.c.

{
    if (addr->Mode == AddrModeFlat) return addr->Offset;
    if (csw->is32)
    {
        ADDRESS         addr32;
 
        addr_64to32(addr, &addr32);
        return csw->u.s32.f_xlat_adr(csw->hProcess, csw->hThread, &addr32);
    }
    else if (csw->u.s64.f_xlat_adr)
        return csw->u.s64.f_xlat_adr(csw->hProcess, csw->hThread, addr);
    return addr_to_linear(csw->hProcess, csw->hThread, addr);
}

Referenced by i386_stack_walk().

◆ symt_add_enum_element()

BOOL symt_add_enum_element	(	struct module *	module,
		struct symt_enum *	enum_type,
		const char *	name,
		int	value
	)

Definition at line 319 of file type.c.

{
    struct symt_data*   e;
    struct symt**       p;
 
    assert(enum_type->symt.tag == SymTagEnum);
    e = pool_alloc(&module->pool, sizeof(*e));
    if (e == NULL) return FALSE;
 
    e->symt.tag = SymTagData;
    e->hash_elt.name = pool_strdup(&module->pool, name);
    e->hash_elt.next = NULL;
    e->kind = DataIsConstant;
    e->container = &enum_type->symt;
    e->type = enum_type->base_type;
    e->u.value.n1.n2.vt = VT_I4;
    e->u.value.n1.n2.n3.lVal = value;
 
    p = vector_add(&enum_type->vchildren, &module->pool);
    if (!p) return FALSE; /* FIXME we leak e */
    *p = &e->symt;
 
    return TRUE;
}

Referenced by codeview_add_type_enum_field_list(), dwarf2_parse_enumerator(), and stabs_pts_read_enum().

◆ symt_add_func_line()

void symt_add_func_line	(	struct module *	module,
		struct symt_function *	func,
		unsigned	source_idx,
		int	line_num,
		ULONG_PTR	offset
	)

Definition at line 326 of file symbol.c.

{
    struct line_info*   dli;
    BOOL                last_matches = FALSE;
    int                 i;
 
    if (func == NULL || !(dbghelp_options & SYMOPT_LOAD_LINES)) return;
 
    TRACE_(dbghelp_symt)("(%p)%s:%lx %s:%u\n", 
                         func, func->hash_elt.name, offset, 
                         source_get(module, source_idx), line_num);
 
    assert(func->symt.tag == SymTagFunction);
 
    for (i=vector_length(&func->vlines)-1; i>=0; i--)
    {
        dli = vector_at(&func->vlines, i);
        if (dli->is_source_file)
        {
            last_matches = (source_idx == dli->u.source_file);
            break;
        }
    }
 
    if (!last_matches)
    {
        /* we shouldn't have line changes on first line of function */
        dli = vector_add(&func->vlines, &module->pool);
        dli->is_source_file = 1;
        dli->is_first       = dli->is_last = 0;
        dli->line_number    = 0;
        dli->u.source_file  = source_idx;
    }
    dli = vector_add(&func->vlines, &module->pool);
    dli->is_source_file = 0;
    dli->is_first       = dli->is_last = 0;
    dli->line_number    = line_num;
    dli->u.pc_offset    = func->address + offset;
}

Referenced by codeview_snarf_linetab(), codeview_snarf_linetab2(), coff_process_info(), dwarf2_set_line_number(), pending_flush(), rsym_parse(), and stabs_parse().

◆ symt_add_func_local()

struct symt_data * symt_add_func_local	(	struct module *	module,
		struct symt_function *	func,
		enum DataKind	dt,
		const struct location *	loc,
		struct symt_block *	block,
		struct symt *	type,
		const char *	name
	)

Definition at line 378 of file symbol.c.

{
    struct symt_data*   locsym;
    struct symt**       p;
 
    TRACE_(dbghelp_symt)("Adding local symbol (%s:%s): %s %p\n",
                         debugstr_w(module->module.ModuleName), func->hash_elt.name,
                         name, type);
 
    assert(func);
    assert(func->symt.tag == SymTagFunction);
    assert(dt == DataIsParam || dt == DataIsLocal);
 
    locsym = pool_alloc(&module->pool, sizeof(*locsym));
    locsym->symt.tag      = SymTagData;
    locsym->hash_elt.name = pool_strdup(&module->pool, name);
    locsym->hash_elt.next = NULL;
    locsym->kind          = dt;
    locsym->container     = block ? &block->symt : &func->symt;
    locsym->type          = type;
    locsym->u.var         = *loc;
    if (block)
        p = vector_add(&block->vchildren, &module->pool);
    else
        p = vector_add(&func->vchildren, &module->pool);
    *p = &locsym->symt;
    return locsym;
}

Referenced by codeview_snarf(), dwarf2_parse_variable(), pending_flush(), and stabs_parse().

◆ symt_add_function_point()

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
	)

Definition at line 452 of file symbol.c.

{
    struct symt_hierarchy_point*sym;
    struct symt**               p;
 
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag = point;
        sym->parent   = &func->symt;
        sym->loc      = *loc;
        sym->hash_elt.name = name ? pool_strdup(&module->pool, name) : NULL;
        p = vector_add(&func->vchildren, &module->pool);
        *p = &sym->symt;
    }
    return sym;
}

Referenced by codeview_snarf(), dwarf2_parse_subprogram(), dwarf2_parse_subprogram_label(), rsym_finalize_function(), and stabs_finalize_function().

◆ symt_add_function_signature_parameter()

BOOL symt_add_function_signature_parameter	(	struct module *	module,
		struct symt_function_signature *	sig,
		struct symt *	param
	)

Definition at line 394 of file type.c.

{
    struct symt**                       p;
    struct symt_function_arg_type*      arg;
 
    assert(sig_type->symt.tag == SymTagFunctionType);
    arg = pool_alloc(&module->pool, sizeof(*arg));
    if (!arg) return FALSE;
    arg->symt.tag = SymTagFunctionArgType;
    arg->arg_type = param;
    arg->container = &sig_type->symt;
    p = vector_add(&sig_type->vchildren, &module->pool);
    if (!p) return FALSE; /* FIXME we leak arg */
    *p = &arg->symt;
 
    return TRUE;
}

Referenced by codeview_add_func_signature_args(), dwarf2_parse_subroutine_type(), dwarf2_parse_variable(), and stabs_parse().

◆ symt_add_udt_element()

BOOL symt_add_udt_element	(	struct module *	module,
		struct symt_udt *	udt_type,
		const char *	name,
		struct symt *	elt_type,
		unsigned	offset,
		unsigned	size
	)

Definition at line 264 of file type.c.

{
    struct symt_data*   m;
    struct symt**       p;
 
    assert(udt_type->symt.tag == SymTagUDT);
 
    TRACE_(dbghelp_symt)("Adding %s to UDT %s\n", name, udt_type->hash_elt.name);
    if (name)
    {
        unsigned int    i;
        for (i=0; i<vector_length(&udt_type->vchildren); i++)
        {
            m = *(struct symt_data**)vector_at(&udt_type->vchildren, i);
            assert(m);
            assert(m->symt.tag == SymTagData);
            if (strcmp(m->hash_elt.name, name) == 0)
                return TRUE;
        }
    }
 
    if ((m = pool_alloc(&module->pool, sizeof(*m))) == NULL) return FALSE;
    memset(m, 0, sizeof(*m));
    m->symt.tag      = SymTagData;
    m->hash_elt.name = name ? pool_strdup(&module->pool, name) : "";
    m->hash_elt.next = NULL;
 
    m->kind            = DataIsMember;
    m->container       = &udt_type->symt;
    m->type            = elt_type;
    m->u.member.offset = offset;
    m->u.member.length = ((offset & 7) || (size & 7)) ? size : 0;
    p = vector_add(&udt_type->vchildren, &module->pool);
    *p = &m->symt;
 
    return TRUE;
}

Referenced by codeview_add_udt_element(), dwarf2_parse_udt_member(), and stabs_pts_read_aggregate().

◆ symt_close_func_block()

struct symt_block * symt_close_func_block	(	struct module *	module,
		const struct symt_function *	func,
		struct symt_block *	block,
		unsigned	pc
	)

Definition at line 440 of file symbol.c.

{
    assert(func);
    assert(func->symt.tag == SymTagFunction);
 
    if (pc) block->size = func->address + pc - block->address;
    return (block->container->tag == SymTagBlock) ? 
        CONTAINING_RECORD(block->container, struct symt_block, symt) : NULL;
}

Referenced by codeview_snarf(), dwarf2_parse_inlined_subroutine(), dwarf2_parse_subprogram_block(), and stabs_parse().

◆ symt_cmp_addr()

int __cdecl symt_cmp_addr	(	const void *	p1,
		const void *	p2
	)

Definition at line 57 of file symbol.c.

{
    const struct symt*  sym1 = *(const struct symt* const *)p1;
    const struct symt*  sym2 = *(const struct symt* const *)p2;
    ULONG64     a1, a2;
 
    symt_get_address(sym1, &a1);
    symt_get_address(sym2, &a2);
    return cmp_addr(a1, a2);
}

Referenced by coff_process_info(), and resort_symbols().

◆ symt_fill_func_line_info()

BOOL symt_fill_func_line_info	(	const struct module *	module,
		const struct symt_function *	func,
		DWORD64	addr,
		IMAGEHLP_LINE64 *	line
	)

Definition at line 1480 of file symbol.c.

{
    struct line_info*   dli = NULL;
    BOOL                found = FALSE;
    int                 i;
 
    assert(func->symt.tag == SymTagFunction);
 
    for (i=vector_length(&func->vlines)-1; i>=0; i--)
    {
        dli = vector_at(&func->vlines, i);
        if (!dli->is_source_file)
        {
            if (found || dli->u.pc_offset > addr) continue;
            line->LineNumber = dli->line_number;
            line->Address    = dli->u.pc_offset;
            line->Key        = dli;
            found = TRUE;
            continue;
        }
        if (found)
        {
            if (dbghelp_opt_native)
            {
                /* Return native file paths when using winedbg */
                line->FileName = (char*)source_get(module, dli->u.source_file);
            }
            else
            {
                WCHAR *dospath = wine_get_dos_file_name(source_get(module, dli->u.source_file));
                DWORD len = WideCharToMultiByte(CP_ACP, 0, dospath, -1, NULL, 0, NULL, NULL);
                line->FileName = fetch_buffer(module->process, len);
                WideCharToMultiByte(CP_ACP, 0, dospath, -1, line->FileName, len, NULL, NULL);
                HeapFree( GetProcessHeap(), 0, dospath );
            }
            return TRUE;
        }
    }
    return FALSE;
}

Referenced by rsym_finalize_function(), stabs_finalize_function(), and SymGetLineFromAddr64().

◆ symt_find_nearest()

struct symt_ht * symt_find_nearest	(	struct module *	module,
		DWORD_PTR	addr
	)

Definition at line 903 of file symbol.c.

{
    int         mid, high, low;
    ULONG64     ref_addr, ref_size;
 
    if (!module->sortlist_valid || !module->addr_sorttab)
    {
        if (!resort_symbols(module)) return NULL;
    }
 
    /*
     * Binary search to find closest symbol.
     */
    low = 0;
    high = module->num_sorttab;
 
    symt_get_address(&module->addr_sorttab[0]->symt, &ref_addr);
    if (addr <= ref_addr)
    {
        low = symt_get_best_at(module, 0);
        return module->addr_sorttab[low];
    }
 
    if (high)
    {
        symt_get_address(&module->addr_sorttab[high - 1]->symt, &ref_addr);
        symt_get_length(module, &module->addr_sorttab[high - 1]->symt, &ref_size);
        if (addr >= ref_addr + ref_size) return NULL;
    }
    
    while (high > low + 1)
    {
        mid = (high + low) / 2;
        if (cmp_sorttab_addr(module, mid, addr) < 0)
            low = mid;
        else
            high = mid;
    }
    if (low != high && high != module->num_sorttab &&
        cmp_sorttab_addr(module, high, addr) <= 0)
        low = high;
 
    /* If found symbol is a public symbol, check if there are any other entries that
     * might also have the same address, but would get better information
     */
    low = symt_get_best_at(module, low);
 
    return module->addr_sorttab[low];
}

Referenced by codeview_add_variable(), codeview_snarf_linetab(), codeview_snarf_linetab2(), dwarf2_set_line_number(), elf_new_wine_thunks(), macho_finish_stabs(), SymFromAddr(), SymGetLineFromAddr64(), symt_enum_locals(), and symt_new_public().

◆ symt_get_address()

BOOL symt_get_address	(	const struct symt *	type,
		ULONG64 *	addr
	)

Definition at line 119 of file type.c.

{
    switch (type->tag)
    {
    case SymTagData:
        switch (((const struct symt_data*)type)->kind)
        {
        case DataIsGlobal:
        case DataIsFileStatic:
            *addr = ((const struct symt_data*)type)->u.var.offset;
            break;
        default: return FALSE;
        }
        break;
    case SymTagFunction:
        *addr = ((const struct symt_function*)type)->address;
        break;
    case SymTagPublicSymbol:
        *addr = ((const struct symt_public*)type)->address;
        break;
    case SymTagFuncDebugStart:
    case SymTagFuncDebugEnd:
    case SymTagLabel:
        if (!((const struct symt_hierarchy_point*)type)->parent ||
            !symt_get_address(((const struct symt_hierarchy_point*)type)->parent, addr))
            return FALSE;
        *addr += ((const struct symt_hierarchy_point*)type)->loc.offset;
        break;
    case SymTagThunk:
        *addr = ((const struct symt_thunk*)type)->address;
        break;
    case SymTagCompiland:
        *addr = ((const struct symt_compiland*)type)->address;
        break;
    default:
        FIXME("Unsupported sym-tag %s for get-address\n", symt_get_tag_str(type->tag));
        return FALSE;
    }
    return TRUE;
}

Referenced by cmp_sorttab_addr(), coff_process_info(), elf_new_wine_thunks(), macho_finish_stabs(), symt_add_module_ht(), symt_cmp_addr(), symt_fill_sym_info(), symt_find_nearest(), symt_get_address(), symt_get_best_at(), symt_get_info(), and where_to_insert().

◆ symt_get_func_line_next()

BOOL symt_get_func_line_next	(	const struct module *	module,
		PIMAGEHLP_LINE64	line
	)

Definition at line 1734 of file symbol.c.

{
    struct line_info*   li;
 
    if (line->Key == 0) return FALSE;
    li = line->Key;
    while (!li->is_last)
    {
        li++;
        if (!li->is_source_file)
        {
            line->LineNumber = li->line_number;
            line->Address    = li->u.pc_offset;
            line->Key        = li;
            return TRUE;
        }
        line->FileName = (char*)source_get(module, li->u.source_file);
    }
    return FALSE;
}

Referenced by rsym_finalize_function(), stabs_finalize_function(), and SymGetLineNext64().

◆ symt_get_info()

BOOL symt_get_info	(	struct module *	module,
		const struct symt *	type,
		IMAGEHLP_SYMBOL_TYPE_INFO	req,
		void *	pInfo
	)

Definition at line 536 of file type.c.

{
    unsigned            len;
 
    if (!type) return FALSE;
 
/* helper to typecast pInfo to its expected type (_t) */
#define X(_t) (*((_t*)pInfo))
 
    switch (req)
    {
    case TI_FINDCHILDREN:
        {
            const struct vector*        v;
            struct symt**               pt;
            unsigned                    i;
            TI_FINDCHILDREN_PARAMS*     tifp = pInfo;
 
            switch (type->tag)
            {
            case SymTagUDT:          v = &((const struct symt_udt*)type)->vchildren; break;
            case SymTagEnum:         v = &((const struct symt_enum*)type)->vchildren; break;
            case SymTagFunctionType: v = &((const struct symt_function_signature*)type)->vchildren; break;
            case SymTagFunction:     v = &((const struct symt_function*)type)->vchildren; break;
            default:
                FIXME("Unsupported sym-tag %s for find-children\n", 
                      symt_get_tag_str(type->tag));
                return FALSE;
            }
            for (i = 0; i < tifp->Count; i++)
            {
                if (!(pt = vector_at(v, tifp->Start + i))) return FALSE;
                tifp->ChildId[i] = symt_ptr2index(module, *pt);
            }
        }
        break;
 
    case TI_GET_ADDRESS:
        return symt_get_address(type, (ULONG64*)pInfo);
 
    case TI_GET_BASETYPE:
        switch (type->tag)
        {
        case SymTagBaseType:
            X(DWORD) = ((const struct symt_basic*)type)->bt;
            break;
        case SymTagEnum:
            X(DWORD) = btInt;
            break;
        default:
            return FALSE;
        }
        break;
 
    case TI_GET_BITPOSITION:
        if (type->tag == SymTagData &&
            ((const struct symt_data*)type)->kind == DataIsMember &&
            ((const struct symt_data*)type)->u.member.length != 0)
            X(DWORD) = ((const struct symt_data*)type)->u.member.offset & 7;
        else return FALSE;
        break;
 
    case TI_GET_CHILDRENCOUNT:
        switch (type->tag)
        {
        case SymTagUDT:
            X(DWORD) = vector_length(&((const struct symt_udt*)type)->vchildren);
            break;
        case SymTagEnum:
            X(DWORD) = vector_length(&((const struct symt_enum*)type)->vchildren);
            break;
        case SymTagFunctionType:
            X(DWORD) = vector_length(&((const struct symt_function_signature*)type)->vchildren);
            break;
        case SymTagFunction:
            X(DWORD) = vector_length(&((const struct symt_function*)type)->vchildren);
            break;
        case SymTagPointerType: /* MS does it that way */
        case SymTagArrayType: /* MS does it that way */
        case SymTagThunk: /* MS does it that way */
            X(DWORD) = 0;
            break;
        default:
            FIXME("Unsupported sym-tag %s for get-children-count\n", 
                  symt_get_tag_str(type->tag));
            /* fall through */
        case SymTagData:
        case SymTagPublicSymbol:
        case SymTagBaseType:
            return FALSE;
        }
        break;
 
    case TI_GET_COUNT:
        switch (type->tag)
        {
        case SymTagArrayType:
            X(DWORD) = symt_array_count(module, (const struct symt_array*)type);
            break;
        case SymTagFunctionType:
            /* this seems to be wrong for (future) C++ methods, where 'this' parameter
             * should be included in this value (and not in GET_CHILDREN_COUNT)
             */
            X(DWORD) = vector_length(&((const struct symt_function_signature*)type)->vchildren);
            break;
        default: return FALSE;
        }
        break;
 
    case TI_GET_DATAKIND:
        if (type->tag != SymTagData) return FALSE;
        X(DWORD) = ((const struct symt_data*)type)->kind;
        break;
 
    case TI_GET_LENGTH:
        switch (type->tag)
        {
        case SymTagBaseType:
            X(DWORD64) = ((const struct symt_basic*)type)->size;
            break;
        case SymTagFunction:
            X(DWORD64) = ((const struct symt_function*)type)->size;
            break;
        case SymTagPointerType:
            X(DWORD64) = ((const struct symt_pointer*)type)->size;
            break;
        case SymTagUDT:
            X(DWORD64) = ((const struct symt_udt*)type)->size;
            break;
        case SymTagEnum:
            X(DWORD64) = sizeof(int); /* FIXME: should be size of base-type of enum !!! */
            break;
        case SymTagData:
            if (((const struct symt_data*)type)->kind != DataIsMember ||
                !((const struct symt_data*)type)->u.member.length)
                return FALSE;
            X(DWORD64) = ((const struct symt_data*)type)->u.member.length;
            break;
        case SymTagArrayType:
            if (!symt_get_info(module, ((const struct symt_array*)type)->base_type,
                               TI_GET_LENGTH, pInfo))
                return FALSE;
            X(DWORD64) *= symt_array_count(module, (const struct symt_array*)type);
            break;
        case SymTagPublicSymbol:
            X(DWORD64) = ((const struct symt_public*)type)->size;
            break;
        case SymTagTypedef:
            return symt_get_info(module, ((const struct symt_typedef*)type)->type, TI_GET_LENGTH, pInfo);
        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));
            /* fall through */
        case SymTagFunctionType:
            return FALSE;
        }
        break;
 
    case TI_GET_LEXICALPARENT:
        switch (type->tag)
        {
        case SymTagBlock:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_block*)type)->container);
            break;
        case SymTagData:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_data*)type)->container);
            break;
        case SymTagFunction:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_function*)type)->container);
            break;
        case SymTagThunk:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_thunk*)type)->container);
            break;
        case SymTagFunctionArgType:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_function_arg_type*)type)->container);
            break;
        default:
            FIXME("Unsupported sym-tag %s for get-lexical-parent\n", 
                  symt_get_tag_str(type->tag));
            return FALSE;
        }
        break;
 
    case TI_GET_NESTED:
        switch (type->tag)
        {
        case SymTagUDT:
        case SymTagEnum:
            X(DWORD) = 0;
            break;
        default:
            return FALSE;
        }
        break;
 
    case TI_GET_OFFSET:
        switch (type->tag)
        {
        case SymTagData:
            switch (((const struct symt_data*)type)->kind)
            {
            case DataIsParam:
            case DataIsLocal:
                X(ULONG) = ((const struct symt_data*)type)->u.var.offset; 
                break;
            case DataIsMember:
                X(ULONG) = ((const struct symt_data*)type)->u.member.offset >> 3; 
                break;
            default:
                FIXME("Unknown kind (%u) for get-offset\n",     
                      ((const struct symt_data*)type)->kind);
                return FALSE;
            }
            break;
        default:
            FIXME("Unsupported sym-tag %s for get-offset\n", 
                  symt_get_tag_str(type->tag));
            return FALSE;
        }
        break;
 
    case TI_GET_SYMNAME:
        {
            const char* name = symt_get_name(type);
            if (!name) return FALSE;
            len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0);
            X(WCHAR*) = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
            if (!X(WCHAR*)) return FALSE;
            MultiByteToWideChar(CP_ACP, 0, name, -1, X(WCHAR*), len);
        }
        break;
 
    case TI_GET_SYMTAG:
        X(DWORD) = type->tag;
        break;
 
    case TI_GET_TYPE:
    case TI_GET_TYPEID:
        switch (type->tag)
        {
            /* hierarchical => hierarchical */
        case SymTagArrayType:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_array*)type)->base_type);
            break;
        case SymTagPointerType:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_pointer*)type)->pointsto);
            break;
        case SymTagFunctionType:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_function_signature*)type)->rettype);
            break;
        case SymTagTypedef:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_typedef*)type)->type);
            break;
            /* lexical => hierarchical */
        case SymTagData:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_data*)type)->type);
            break;
        case SymTagFunction:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_function*)type)->type);
            break;
        case SymTagEnum:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_enum*)type)->base_type);
            break;
        case SymTagFunctionArgType:
            X(DWORD) = symt_ptr2index(module, ((const struct symt_function_arg_type*)type)->arg_type);
            break;
        default:
            FIXME("Unsupported sym-tag %s for get-type\n", 
                  symt_get_tag_str(type->tag));
        /* fall through */
        case SymTagPublicSymbol:
        case SymTagThunk:
        case SymTagLabel:
            return FALSE;
        }
        break;
 
    case TI_GET_UDTKIND:
        if (type->tag != SymTagUDT) return FALSE;
        X(DWORD) = ((const struct symt_udt*)type)->kind;
        break;
 
    case TI_GET_VALUE:
        if (type->tag != SymTagData) return FALSE;
        switch (((const struct symt_data*)type)->kind)
        {
        case DataIsConstant: X(VARIANT) = ((const struct symt_data*)type)->u.value; break;
        case DataIsLocal:
        case DataIsParam:
            {
                struct location loc = ((const struct symt_data*)type)->u.var;
                unsigned                i;
                struct module_format*   modfmt;
 
                if (loc.kind < loc_user) return FALSE;
                for (i = 0; i < DFI_LAST; i++)
                {
                    modfmt = module->format_info[i];
                    if (modfmt && modfmt->loc_compute)
                    {
                        modfmt->loc_compute(module->process, modfmt,
                                            (const struct symt_function*)((const struct symt_data*)type)->container, &loc);
                        break;
                    }
                }
                if (loc.kind != loc_absolute) return FALSE;
                X(VARIANT).n1.n2.vt = VT_UI4; /* FIXME */
                X(VARIANT).n1.n2.n3.uiVal = loc.offset;
            }
            break;
        default: return FALSE;
        }
        break;
 
    case TI_GET_CALLING_CONVENTION:
        if (type->tag != SymTagFunctionType) return FALSE;
        if (((const struct symt_function_signature*)type)->call_conv == -1)
        {
            FIXME("No support for calling convention for this signature\n");
            X(DWORD) = CV_CALL_FAR_C; /* FIXME */
        }
        else X(DWORD) = ((const struct symt_function_signature*)type)->call_conv;
        break;
    case TI_GET_ARRAYINDEXTYPEID:
        if (type->tag != SymTagArrayType) return FALSE;
        X(DWORD) = symt_ptr2index(module, ((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_SYMINDEX:
    case TI_GET_THISADJUST:
    case TI_GET_VIRTUALBASECLASS:
    case TI_GET_VIRTUALBASEPOINTEROFFSET:
    case TI_GET_VIRTUALTABLESHAPEID:
    case TI_IS_EQUIV_TO:
        FIXME("Unsupported GetInfo request (%u)\n", req);
        return FALSE;
    default:
        FIXME("Unknown GetInfo request (%u)\n", req);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by codeview_add_udt_element(), dwarf2_parse_udt_member(), macho_finish_stabs(), stabs_pts_read_aggregate(), SymEnumTypes(), SymGetTypeInfo(), symt_array_count(), symt_fill_sym_info(), symt_get_info(), symt_get_length(), and symt_new_global_variable().

◆ symt_get_name()

const char * symt_get_name ( const struct symt * sym )

Definition at line 81 of file type.c.

{
    switch (sym->tag)
    {
    /* lexical tree */
    case SymTagData:            return ((const struct symt_data*)sym)->hash_elt.name;
    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_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;
    case SymTagTypedef:         return ((const struct symt_typedef*)sym)->hash_elt.name;
    case SymTagUDT:             return ((const struct symt_udt*)sym)->hash_elt.name;
    default:
        FIXME("Unsupported sym-tag %s\n", symt_get_tag_str(sym->tag));
        /* fall through */
    case SymTagArrayType:
    case SymTagPointerType:
    case SymTagFunctionType:
        return NULL;
    }
}

Referenced by stabs_pts_read_aggregate(), stabs_pts_read_type_def(), SymEnumTypes(), symt_fill_sym_info(), symt_get_info(), and symt_get_nameW().

◆ symt_get_nameW()

WCHAR * symt_get_nameW ( const struct symt * sym )

Definition at line 106 of file type.c.

{
    const char* name = symt_get_name(sym);
    WCHAR* nameW;
    DWORD sz;
 
    if (!name) return NULL;
    sz = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0);
    if ((nameW = HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR))))
        MultiByteToWideChar(CP_ACP, 0, name, -1, nameW, sz);
    return nameW;
}

Referenced by symt_enum_locals_helper(), and symt_enum_module().

◆ symt_index2ptr()

struct symt * symt_index2ptr	(	struct module *	module,
		DWORD	id
	)

Definition at line 110 of file symbol.c.

{
#if defined(__x86_64__) || defined(__arm64__)
    if (!id-- || id >= vector_length(&module->vsymt)) return NULL;
    return *(struct symt**)vector_at(&module->vsymt, id);
#else
    return (struct symt*)id;
#endif
}

Referenced by SymGetTypeInfo(), symt_fill_sym_info(), and symt_get_length().

◆ symt_init_basic()

void symt_init_basic ( struct module * module )

◆ symt_new_array()

struct symt_array * symt_new_array	(	struct module *	module,
		int	min,
		int	max,
		struct symt *	base,
		struct symt *	index
	)

Definition at line 345 of file type.c.

{
    struct symt_array*  sym;
 
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag   = SymTagArrayType;
        sym->start      = min;
        sym->end        = max;
        sym->base_type  = base;
        sym->index_type = index;
        symt_add_type(module, &sym->symt);
    }
    return sym;
}

Referenced by codeview_add_type_array(), dwarf2_parse_array_type(), and stabs_pts_read_array().

◆ symt_new_basic()

struct symt_basic * symt_new_basic	(	struct module *	module,
		enum	BasicType,
		const char *	typename,
		unsigned	size
	)

Definition at line 192 of file type.c.

{
    struct symt_basic*          sym;
 
    if (typename)
    {
        sym = (struct symt_basic*)symt_find_type_by_name(module, SymTagBaseType,
                                                         typename);
        if (sym && sym->bt == bt && sym->size == size)
            return sym;
    }
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag = SymTagBaseType;
        if (typename)
        {
            sym->hash_elt.name = pool_strdup(&module->pool, typename);
            hash_table_add(&module->ht_types, &sym->hash_elt);
        } else sym->hash_elt.name = NULL;
        sym->bt = bt;
        sym->size = size;
        symt_add_type(module, &sym->symt);
    }
    return sym;
}

Referenced by codeview_init_basic_types(), dwarf2_parse_base_type(), dwarf2_parse_compilation_unit(), dwarf2_parse_enumeration_type(), dwarf2_parse_unspecified_type(), stabs_get_basic(), stabs_pts_read_range(), and stabs_pts_read_type_def().

◆ symt_new_compiland()

struct symt_compiland * symt_new_compiland	(	struct module *	module,
		ULONG_PTR	address,
		unsigned	src_idx
	)

Definition at line 207 of file symbol.c.

{
    struct symt_compiland*    sym;
 
    TRACE_(dbghelp_symt)("Adding compiland symbol %s:%s\n",
                         debugstr_w(module->module.ModuleName), source_get(module, src_idx));
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag = SymTagCompiland;
        sym->address  = address;
        sym->source   = src_idx;
        vector_init(&sym->vchildren, sizeof(struct symt*), 32);
    }
    return sym;
}

Referenced by codeview_snarf(), coff_add_file(), dwarf2_parse_compilation_unit(), elf_hash_symtab(), pe_load_coff_symbol_table(), and stabs_parse().

◆ symt_new_constant()

struct symt_data * symt_new_constant	(	struct module *	module,
		struct symt_compiland *	parent,
		const char *	name,
		struct symt *	type,
		const VARIANT *	v
	)

Definition at line 525 of file symbol.c.

{
    struct symt_data*  sym;
 
    TRACE_(dbghelp_symt)("Adding constant value %s:%s\n",
                         debugstr_w(module->module.ModuleName), name);
 
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag      = SymTagData;
        sym->hash_elt.name = pool_strdup(&module->pool, name);
        sym->kind          = DataIsConstant;
        sym->container     = compiland ? &compiland->symt : NULL;
        sym->type          = type;
        sym->u.value       = *v;
        symt_add_module_ht(module, (struct symt_ht*)sym);
        if (compiland)
        {
            struct symt**       p;
            p = vector_add(&compiland->vchildren, &module->pool);
            *p = &sym->symt;
        }
    }
    return sym;
}

Referenced by codeview_snarf(), and dwarf2_parse_variable().

◆ symt_new_enum()

struct symt_enum * symt_new_enum	(	struct module *	module,
		const char *	typename,
		struct symt *	basetype
	)

Definition at line 304 of file type.c.

{
    struct symt_enum*   sym;
 
    if ((sym = pool_alloc(&module->pool, sizeof(*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;
}

Referenced by codeview_add_type_enum(), dwarf2_parse_enumeration_type(), and stabs_pts_read_type_def().

◆ symt_new_function()

struct symt_function * symt_new_function	(	struct module *	module,
		struct symt_compiland *	parent,
		const char *	name,
		ULONG_PTR	addr,
		ULONG_PTR	size,
		struct symt *	type
	)

Definition at line 293 of file symbol.c.

{
    struct symt_function*       sym;
    struct symt**               p;
 
    TRACE_(dbghelp_symt)("Adding global function %s:%s @%lx-%lx\n",
                         debugstr_w(module->module.ModuleName), name, addr, addr + size - 1);
 
    assert(!sig_type || sig_type->tag == SymTagFunctionType);
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag  = SymTagFunction;
        sym->hash_elt.name = pool_strdup(&module->pool, name);
        sym->container = &compiland->symt;
        sym->address   = addr;
        sym->type      = sig_type;
        sym->size      = size;
        vector_init(&sym->vlines,  sizeof(struct line_info), 64);
        vector_init(&sym->vchildren, sizeof(struct symt*), 8);
        symt_add_module_ht(module, (struct symt_ht*)sym);
        if (compiland)
        {
            p = vector_add(&compiland->vchildren, &module->pool);
            *p = &sym->symt;
        }
    }
    return sym;
}

Referenced by codeview_snarf(), coff_process_info(), dwarf2_parse_subprogram(), elf_new_wine_thunks(), macho_finish_stabs(), rsym_parse(), and stabs_parse().

◆ symt_new_function_signature()

struct symt_function_signature * symt_new_function_signature	(	struct module *	module,
		struct symt *	ret_type,
		enum CV_call_e	call_conv
	)

Definition at line 377 of file type.c.

{
    struct symt_function_signature*     sym;
 
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag = SymTagFunctionType;
        sym->rettype  = ret_type;
        vector_init(&sym->vchildren, sizeof(struct symt*), 4);
        sym->call_conv = call_conv;
        symt_add_type(module, &sym->symt);
    }
    return sym;
}

Referenced by codeview_new_func_signature(), dwarf2_parse_subprogram(), dwarf2_parse_subroutine_type(), stabs_parse(), and stabs_pts_read_type_def().

◆ symt_new_global_variable()

struct symt_data * symt_new_global_variable	(	struct module *	module,
		struct symt_compiland *	parent,
		const char *	name,
		unsigned	is_static,
		struct location	loc,
		ULONG_PTR	size,
		struct symt *	type
	)

Definition at line 256 of file symbol.c.

{
    struct symt_data*   sym;
    struct symt**       p;
    DWORD64             tsz;
 
    TRACE_(dbghelp_symt)("Adding global symbol %s:%s %d@%lx %p\n",
                         debugstr_w(module->module.ModuleName), name, loc.kind, loc.offset, type);
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag      = SymTagData;
        sym->hash_elt.name = pool_strdup(&module->pool, name);
        sym->kind          = is_static ? DataIsFileStatic : DataIsGlobal;
        sym->container     = compiland ? &compiland->symt : NULL;
        sym->type          = type;
        sym->u.var         = loc;
        if (type && size && symt_get_info(module, type, TI_GET_LENGTH, &tsz))
        {
            if (tsz != size)
                FIXME("Size mismatch for %s.%s between type (%s) and src (%lu)\n",
                      debugstr_w(module->module.ModuleName), name,
                      wine_dbgstr_longlong(tsz), size);
        }
        symt_add_module_ht(module, (struct symt_ht*)sym);
        if (compiland)
        {
            p = vector_add(&compiland->vchildren, &module->pool);
            *p = &sym->symt;
        }
    }
    return sym;
}

Referenced by codeview_add_variable(), coff_process_info(), dwarf2_parse_variable(), elf_new_wine_thunks(), macho_finish_stabs(), and stabs_parse().

◆ symt_new_label()

struct symt_hierarchy_point * symt_new_label	(	struct module *	module,
		struct symt_compiland *	compiland,
		const char *	name,
		ULONG_PTR	address
	)

Definition at line 554 of file symbol.c.

{
    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);
        sym->loc.kind      = loc_absolute;
        sym->loc.offset    = address;
        sym->parent        = compiland ? &compiland->symt : NULL;
        symt_add_module_ht(module, (struct symt_ht*)sym);
        if (compiland)
        {
            struct symt**       p;
            p = vector_add(&compiland->vchildren, &module->pool);
            *p = &sym->symt;
        }
    }
    return sym;
}

Referenced by codeview_snarf().

◆ symt_new_pointer()

struct symt_pointer * symt_new_pointer	(	struct module *	module,
		struct symt *	ref_type,
		ULONG_PTR	size
	)

Definition at line 414 of file type.c.

{
    struct symt_pointer*        sym;
 
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag = SymTagPointerType;
        sym->pointsto = ref_type;
        sym->size     = size;
        symt_add_type(module, &sym->symt);
    }
    return sym;
}

Referenced by codeview_add_type_pointer(), codeview_init_basic_types(), dwarf2_parse_pointer_type(), dwarf2_parse_reference_type(), and stabs_pts_read_type_def().

◆ symt_new_public()

struct symt_public * symt_new_public	(	struct module *	module,
		struct symt_compiland *	parent,
		const char *	typename,
		BOOL	is_function,
		ULONG_PTR	address,
		unsigned	size
	)

Definition at line 224 of file symbol.c.

{
    struct symt_public* sym;
    struct symt**       p;
 
    TRACE_(dbghelp_symt)("Adding public symbol %s:%s @%lx\n",
                         debugstr_w(module->module.ModuleName), name, address);
    if ((dbghelp_options & SYMOPT_AUTO_PUBLICS) &&
        symt_find_nearest(module, address) != NULL)
        return NULL;
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag      = SymTagPublicSymbol;
        sym->hash_elt.name = pool_strdup(&module->pool, name);
        sym->container     = compiland ? &compiland->symt : NULL;
        sym->is_function   = is_function;
        sym->address       = address;
        sym->size          = size;
        symt_add_module_ht(module, (struct symt_ht*)sym);
        if (compiland)
        {
            p = vector_add(&compiland->vchildren, &module->pool);
            *p = &sym->symt;
        }
    }
    return sym;
}

Referenced by codeview_snarf_public(), elf_new_public_symbols(), macho_finish_stabs(), pe_load_coff_symbol_table(), pe_load_export_debug_info(), and rsym_parse().

◆ symt_new_thunk()

struct symt_thunk * symt_new_thunk	(	struct module *	module,
		struct symt_compiland *	parent,
		const char *	name,
		THUNK_ORDINAL	ord,
		ULONG_PTR	addr,
		ULONG_PTR	size
	)

Definition at line 496 of file symbol.c.

{
    struct symt_thunk*  sym;
 
    TRACE_(dbghelp_symt)("Adding global thunk %s:%s @%lx-%lx\n",
                         debugstr_w(module->module.ModuleName), name, addr, addr + size - 1);
 
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag  = SymTagThunk;
        sym->hash_elt.name = pool_strdup(&module->pool, name);
        sym->container = &compiland->symt;
        sym->address   = addr;
        sym->size      = size;
        sym->ordinal   = ord;
        symt_add_module_ht(module, (struct symt_ht*)sym);
        if (compiland)
        {
            struct symt**       p;
            p = vector_add(&compiland->vchildren, &module->pool);
            *p = &sym->symt;
        }
    }
    return sym;
}

Referenced by codeview_snarf(), and elf_new_wine_thunks().

◆ symt_new_typedef()

struct symt_typedef * symt_new_typedef	(	struct module *	module,
		struct symt *	ref,
		const char *	name
	)

Definition at line 428 of file type.c.

{
    struct symt_typedef* sym;
 
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag = SymTagTypedef;
        sym->type     = ref;
        sym->hash_elt.name = pool_strdup(&module->pool, name);
        hash_table_add(&module->ht_types, &sym->hash_elt);
        symt_add_type(module, &sym->symt);
    }
    return sym;
}

Referenced by codeview_snarf(), and dwarf2_parse_typedef().

◆ symt_new_udt()

struct symt_udt * symt_new_udt	(	struct module *	module,
		const char *	typename,
		unsigned	size,
		enum UdtKind	kind
	)

Definition at line 219 of file type.c.

{
    struct symt_udt*            sym;
 
    TRACE_(dbghelp_symt)("Adding udt %s:%s\n",
                         debugstr_w(module->module.ModuleName), typename);
    if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
    {
        sym->symt.tag = SymTagUDT;
        sym->kind     = kind;
        sym->size     = size;
        if (typename)
        {
            sym->hash_elt.name = pool_strdup(&module->pool, typename);
            hash_table_add(&module->ht_types, &sym->hash_elt);
        } else sym->hash_elt.name = NULL;
        vector_init(&sym->vchildren, sizeof(struct symt*), 8);
        symt_add_type(module, &sym->symt);
    }
    return sym;
}

Referenced by codeview_add_type_struct(), codeview_parse_one_type(), dwarf2_parse_udt_type(), and stabs_pts_read_type_def().

◆ symt_normalize_function()

BOOL symt_normalize_function	(	struct module *	module,
		const struct symt_function *	func
	)

Definition at line 473 of file symbol.c.

{
    unsigned            len;
    struct line_info*   dli;
 
    assert(func);
    /* We aren't adding any more locals or line numbers to this function.
     * Free any spare memory that we might have allocated.
     */
    assert(func->symt.tag == SymTagFunction);
 
/* EPP     vector_pool_normalize(&func->vlines,    &module->pool); */
/* EPP     vector_pool_normalize(&func->vchildren, &module->pool); */
 
    len = vector_length(&func->vlines);
    if (len--)
    {
        dli = vector_at(&func->vlines,   0);  dli->is_first = 1;
        dli = vector_at(&func->vlines, len);  dli->is_last  = 1;
    }
    return TRUE;
}

Referenced by codeview_snarf(), dwarf2_parse_subprogram(), rsym_finalize_function(), and stabs_finalize_function().

◆ symt_open_func_block()

struct symt_block * symt_open_func_block	(	struct module *	module,
		struct symt_function *	func,
		struct symt_block *	block,
		unsigned	pc,
		unsigned	len
	)

Definition at line 413 of file symbol.c.

{
    struct symt_block*  block;
    struct symt**       p;
 
    assert(func);
    assert(func->symt.tag == SymTagFunction);
 
    assert(!parent_block || parent_block->symt.tag == SymTagBlock);
    block = pool_alloc(&module->pool, sizeof(*block));
    block->symt.tag = SymTagBlock;
    block->address  = func->address + pc;
    block->size     = len;
    block->container = parent_block ? &parent_block->symt : &func->symt;
    vector_init(&block->vchildren, sizeof(struct symt*), 4);
    if (parent_block)
        p = vector_add(&parent_block->vchildren, &module->pool);
    else
        p = vector_add(&func->vchildren, &module->pool);
    *p = &block->symt;
 
    return block;
}

Referenced by codeview_snarf(), dwarf2_parse_inlined_subroutine(), dwarf2_parse_subprogram_block(), and stabs_parse().

◆ symt_ptr2index()

DWORD symt_ptr2index	(	struct module *	module,
		const struct symt *	sym
	)

Definition at line 68 of file symbol.c.

{
#ifdef __x86_64__
    const struct symt** c;
    int len = vector_length(&module->vsymt);
    struct hash_table_iter hti;
    void *ptr;
    struct symt_idx_to_ptr *idx_to_ptr;
    /* place enough storage on the stack to represent a pointer in %p form */
    char ptrbuf[3 + (sizeof(void *) * 2)];
 
    /* make a string representation of the pointer to use as a hash key */
    sprintf(ptrbuf, "%p", sym);
    hash_table_iter_init(&module->ht_symaddr, &hti, ptrbuf);
 
    /* try to find the pointer in our ht */
    while ((ptr = hash_table_iter_up(&hti))) {
        idx_to_ptr = CONTAINING_RECORD(ptr, struct symt_idx_to_ptr, hash_elt);
        if (idx_to_ptr->sym == sym)
            return idx_to_ptr->idx;
    }
 
    /* not found */
    /* add the symbol to our symbol vector */
    c = vector_add(&module->vsymt, &module->pool);
 
    /* add an idx to ptr mapping so we can find it again by address */
    if ((idx_to_ptr = pool_alloc(&module->pool, sizeof(*idx_to_ptr)))) 
    {
        idx_to_ptr->hash_elt.name = pool_strdup(&module->pool, ptrbuf);
        idx_to_ptr->sym = sym;
        idx_to_ptr->idx = len + 1;
        hash_table_add(&module->ht_symaddr, &idx_to_ptr->hash_elt);
    }
 
    if (c) *c = sym;
    return len + 1;
#else
    return (DWORD)sym;
#endif
}

Referenced by SymEnumTypes(), SymGetTypeFromName(), symt_fill_sym_info(), and symt_get_info().

◆ symt_set_udt_size()

BOOL symt_set_udt_size	(	struct module *	module,
		struct symt_udt *	type,
		unsigned	size
	)

Definition at line 242 of file type.c.

{
    assert(udt->symt.tag == SymTagUDT);
    if (vector_length(&udt->vchildren) != 0)
    {
        if (udt->size != size)
            FIXME_(dbghelp_symt)("Changing size for %s from %u to %u\n", 
                                 udt->hash_elt.name, udt->size, size);
        return TRUE;
    }
    udt->size = size;
    return TRUE;
}

Referenced by codeview_add_type_struct(), and stabs_pts_read_aggregate().

◆ validate_addr64()

BOOL validate_addr64 ( DWORD64 addr )

Definition at line 112 of file dbghelp.c.

{
    if (sizeof(void*) == sizeof(int) && (addr >> 32))
    {
        FIXME("Unsupported address %s\n", wine_dbgstr_longlong(addr));
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    return TRUE;
}

Referenced by fetch_pe_module_info_cb(), reg_cb64to32(), SymGetModuleBase(), SymLoadModuleExW(), and SymUnloadModule64().

◆ vector_add()

void * vector_add	(	struct vector *	v,
		struct pool *	pool
	)

Definition at line 171 of file storage.c.

{
    unsigned    ncurr = v->num_elts++;
 
    /* check that we don't wrap around */
    assert(v->num_elts > ncurr);
    if (ncurr == (v->num_buckets << v->shift))
    {
        if(v->num_buckets == v->buckets_allocated)
        {
            /* Double the bucket cache, so it scales well with big vectors.*/
            unsigned    new_reserved;
            void*       new;
 
            new_reserved = 2*v->buckets_allocated;
            if(new_reserved == 0) new_reserved = 1;
 
            /* Don't even try to resize memory.
               Pool datastructure is very inefficient with reallocs. */
            new = pool_alloc(pool, new_reserved * sizeof(void*));
            memcpy(new, v->buckets, v->buckets_allocated * sizeof(void*));
            v->buckets = new;
            v->buckets_allocated = new_reserved;
        }
        v->buckets[v->num_buckets] = pool_alloc(pool, v->elt_size << v->shift);
        return v->buckets[v->num_buckets++];
    }
    return vector_at(v, ncurr);
}

Referenced by dwarf2_parse_line_numbers(), dwarf2_read_one_debug_info(), pev_push(), sparse_array_add(), symt_add_enum_element(), symt_add_func_line(), symt_add_func_local(), symt_add_function_point(), symt_add_function_signature_parameter(), symt_add_type(), symt_add_udt_element(), symt_new_constant(), symt_new_function(), symt_new_global_variable(), symt_new_label(), symt_new_public(), symt_new_thunk(), symt_open_func_block(), and symt_ptr2index().

◆ vector_at()

void * vector_at	(	const struct vector *	v,
		unsigned	pos
	)

Definition at line 162 of file storage.c.

{
    unsigned o;
 
    if (pos >= v->num_elts) return NULL;
    o = pos & ((1 << v->shift) - 1);
    return (char*)v->buckets[pos >> v->shift] + o * v->elt_size;
}

Referenced by dwarf2_parse_array_type(), dwarf2_parse_compilation_unit(), dwarf2_parse_enumeration_type(), dwarf2_parse_inlined_subroutine(), dwarf2_parse_line_numbers(), dwarf2_parse_namespace(), dwarf2_parse_subprogram(), dwarf2_parse_subprogram_block(), dwarf2_parse_subroutine_type(), dwarf2_parse_udt_type(), dwarf2_set_line_number(), loc_compute_frame(), pev_pop(), pev_push(), sparse_array_add(), sparse_array_find(), sparse_array_lookup(), SymEnumLines(), SymEnumTypes(), symt_add_func_line(), symt_add_udt_element(), symt_enum_locals_helper(), symt_fill_func_line_info(), symt_get_info(), symt_index2ptr(), symt_normalize_function(), and vector_add().

◆ vector_init()

void vector_init	(	struct vector *	v,
		unsigned	elt_sz,
		unsigned	bucket_sz
	)

Definition at line 133 of file storage.c.

{
    v->buckets = NULL;
    /* align size on DWORD boundaries */
    v->elt_size = (esz + 3) & ~3;
    switch (bucket_sz)
    {
    case    2: v->shift =  1; break;
    case    4: v->shift =  2; break;
    case    8: v->shift =  3; break;
    case   16: v->shift =  4; break;
    case   32: v->shift =  5; break;
    case   64: v->shift =  6; break;
    case  128: v->shift =  7; break;
    case  256: v->shift =  8; break;
    case  512: v->shift =  9; break;
    case 1024: v->shift = 10; break;
    default: assert(0);
    }
    v->num_buckets = 0;
    v->buckets_allocated = 0;
    v->num_elts = 0;
}

Referenced by dwarf2_parse_line_numbers(), dwarf2_read_one_debug_info(), module_new(), pev_init(), sparse_array_init(), symt_new_compiland(), symt_new_enum(), symt_new_function(), symt_new_function_signature(), symt_new_udt(), and symt_open_func_block().

◆ vector_length()

unsigned vector_length ( const struct vector * v )

Definition at line 157 of file storage.c.

{
    return v->num_elts;
}

Referenced by dwarf2_parse_array_type(), dwarf2_parse_compilation_unit(), dwarf2_parse_enumeration_type(), dwarf2_parse_inlined_subroutine(), dwarf2_parse_namespace(), dwarf2_parse_subprogram(), dwarf2_parse_subprogram_block(), dwarf2_parse_subroutine_type(), dwarf2_parse_udt_type(), loc_compute_frame(), pev_push(), SymEnumLines(), SymEnumTypes(), symt_add_func_line(), symt_add_udt_element(), symt_enum_locals_helper(), symt_fill_func_line_info(), symt_get_info(), symt_index2ptr(), symt_normalize_function(), symt_ptr2index(), and symt_set_udt_size().

◆ wine_dbgstr_addr()

const char * wine_dbgstr_addr ( const ADDRESS64 * addr )

Definition at line 142 of file dbghelp.c.

{
    if (!addr) return "(null)";
    switch (addr->Mode)
    {
    case AddrModeFlat:
        return wine_dbg_sprintf("flat<%s>", wine_dbgstr_longlong(addr->Offset));
    case AddrMode1616:
        return wine_dbg_sprintf("1616<%04x:%04x>", addr->Segment, (DWORD)addr->Offset);
    case AddrMode1632:
        return wine_dbg_sprintf("1632<%04x:%08x>", addr->Segment, (DWORD)addr->Offset);
    case AddrModeReal:
        return wine_dbg_sprintf("real<%04x:%04x>", addr->Segment, (DWORD)addr->Offset);
    default:
        return "unknown";
    }
}

Referenced by i386_stack_walk().

Variable Documentation

◆ DECLSPEC_HIDDEN

const struct loader_ops no_loader_ops DECLSPEC_HIDDEN

extern

Definition at line 129 of file dbghelp_private.h.

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ enum_modules_cb

◆ PEB32

◆ stabs_def_cb

Enumeration Type Documentation

◆ cpu_addr

◆ format_info

◆ location_error

◆ location_kind

◆ module_type

◆ pdb_kind

Function Documentation

◆ calc_crc32()

◆ copy_symbolW()

◆ cpu_find()

◆ dwarf2_parse()

◆ dwarf2_virtual_unwind()

◆ elf_is_in_thunk_area()

◆ elf_read_wine_loader_dbg_info()

◆ fetch_buffer()

◆ file_name()

◆ file_nameA()

◆ get_dos_file_name()

◆ get_wine_loader_name()

◆ hash_table_add()

◆ hash_table_destroy()

◆ hash_table_init()

◆ hash_table_iter_init()

◆ hash_table_iter_up()

◆ macho_read_wine_loader_dbg_info()

◆ minidump_add_memory_block()

◆ module_find_by_addr()

◆ module_find_by_nameA()

◆ module_find_by_nameW()

◆ module_get_containee()

◆ module_get_debug()

◆ module_is_already_loaded()

◆ module_new()

◆ module_remove()

◆ module_reset_debug_info()

◆ module_set_module()

◆ path_find_symbol_file()

◆ pcs_callback()

◆ pdb_fetch_file_info()

◆ pdb_virtual_unwind()

◆ pe_load_builtin_module()

◆ pe_load_debug_directory()

◆ pe_load_debug_info()

◆ pe_load_native_module()

◆ pe_load_nt_header()

◆ pe_map_directory()

◆ pool_alloc()

◆ pool_destroy()

◆ pool_init()

◆ pool_strdup()

◆ process_find_by_handle()

◆ process_getenv()

◆ read_process_memory()

◆ rsym_parse()

◆ search_dll_path()

◆ search_unix_path()

◆ source_get()

◆ source_new()

◆ source_rb_compare()

◆ sparse_array_add()

◆ sparse_array_find()

◆ sparse_array_init()

◆ sparse_array_length()

◆ stabs_parse()

◆ sw_module_base()

◆ sw_read_mem()

◆ sw_table_access()

◆ sw_xlat_addr()

◆ symt_add_enum_element()

◆ symt_add_func_line()