ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

dbghelp: Use LONG_PTR instead of long type. 

Signed-off-by: Jacek Caban <jacek@codeweavers.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Jacek Caban 2020-03-26 16:51:49 +01:00 committed by Alexandre Julliard
parent 8d702a3aa5
commit f803da493a
13 changed files with 193 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dlls/dbghelp/cpu_i386.c
View File

@ -48,7 +48,7 @@ static ADDRESS_MODE get_selector_type(HANDLE hThread, const CONTEXT* ctx, WORD s
} }
static BOOL i386_build_addr(HANDLE hThread, const CONTEXT* ctx, ADDRESS64* addr, static BOOL i386_build_addr(HANDLE hThread, const CONTEXT* ctx, ADDRESS64* addr,
unsigned seg, unsigned long offset) unsigned seg, ULONG_PTR offset)
{ {
addr->Mode = AddrModeFlat; addr->Mode = AddrModeFlat;
addr->Segment = seg; addr->Segment = seg;

68
dlls/dbghelp/dbghelp_private.h
View File

@ -71,8 +71,8 @@ struct sparse_array
}; };
void sparse_array_init(struct sparse_array* sa, unsigned elt_sz, unsigned bucket_sz) 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, unsigned long idx) DECLSPEC_HIDDEN; void* sparse_array_find(const struct sparse_array* sa, ULONG_PTR idx) DECLSPEC_HIDDEN;
void* sparse_array_add(struct sparse_array* sa, unsigned long key, struct pool* pool) 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; unsigned sparse_array_length(const struct sparse_array* sa) DECLSPEC_HIDDEN;
struct hash_table_elt struct hash_table_elt
@ -138,7 +138,7 @@ struct location
{ {
unsigned kind : 8, unsigned kind : 8,
reg; reg;
unsigned long offset; ULONG_PTR offset;
}; };
struct symt struct symt
@ -156,8 +156,8 @@ struct symt_ht
struct symt_block struct symt_block
{ {
struct symt symt; struct symt symt;
unsigned long address; ULONG_PTR address;
unsigned long size; ULONG_PTR size;
struct symt* container; /* block, or func */ struct symt* container; /* block, or func */
struct vector vchildren; /* sub-blocks & local variables */ struct vector vchildren; /* sub-blocks & local variables */
}; };
@ -165,7 +165,7 @@ struct symt_block
struct symt_compiland struct symt_compiland
{ {
struct symt symt; struct symt symt;
unsigned long address; ULONG_PTR address;
unsigned source; unsigned source;
struct vector vchildren; /* global variables & functions */ struct vector vchildren; /* global variables & functions */
}; };
@ -194,8 +194,8 @@ struct symt_data
/* DataIs{Member} (all values are in bits, not bytes) */ /* DataIs{Member} (all values are in bits, not bytes) */
struct struct
{ {
long offset; LONG_PTR offset;
unsigned long length; ULONG_PTR length;
} member; } member;
/* DataIsConstant */ /* DataIsConstant */
VARIANT value; VARIANT value;
@ -206,10 +206,10 @@ struct symt_function
{ {
struct symt symt; struct symt symt;
struct hash_table_elt hash_elt; /* if global symbol */ struct hash_table_elt hash_elt; /* if global symbol */
unsigned long address; ULONG_PTR address;
struct symt* container; /* compiland */ struct symt* container; /* compiland */
struct symt* type; /* points to function_signature */ struct symt* type; /* points to function_signature */
unsigned long size; ULONG_PTR size;
struct vector vlines; struct vector vlines;
struct vector vchildren; /* locals, params, blocks, start/end, labels */ struct vector vchildren; /* locals, params, blocks, start/end, labels */
}; };
@ -228,8 +228,8 @@ struct symt_public
struct hash_table_elt hash_elt; struct hash_table_elt hash_elt;
struct symt* container; /* compiland */ struct symt* container; /* compiland */
BOOL is_function; BOOL is_function;
unsigned long address; ULONG_PTR address;
unsigned long size; ULONG_PTR size;
}; };
struct symt_thunk struct symt_thunk
@ -237,8 +237,8 @@ struct symt_thunk
struct symt symt; struct symt symt;
struct hash_table_elt hash_elt; struct hash_table_elt hash_elt;
struct symt* container; /* compiland */ struct symt* container; /* compiland */
unsigned long address; ULONG_PTR address;
unsigned long size; ULONG_PTR size;
THUNK_ORDINAL ordinal; /* FIXME: doesn't seem to be accessible */ THUNK_ORDINAL ordinal; /* FIXME: doesn't seem to be accessible */
}; };
@ -257,7 +257,7 @@ struct symt_basic
struct symt symt; struct symt symt;
struct hash_table_elt hash_elt; struct hash_table_elt hash_elt;
enum BasicType bt; enum BasicType bt;
unsigned long size; ULONG_PTR size;
}; };
struct symt_enum struct symt_enum
@ -287,7 +287,7 @@ struct symt_pointer
{ {
struct symt symt; struct symt symt;
struct symt* pointsto; struct symt* pointsto;
unsigned long size; ULONG_PTR size;
}; };
struct symt_typedef struct symt_typedef
@ -387,7 +387,7 @@ struct module
struct wine_rb_tree sources_offsets_tree; struct wine_rb_tree sources_offsets_tree;
}; };
typedef BOOL (*enum_modules_cb)(const WCHAR*, unsigned long addr, void* user); typedef BOOL (*enum_modules_cb)(const WCHAR*, ULONG_PTR addr, void* user);
struct loader_ops struct loader_ops
{ {
@ -411,7 +411,7 @@ struct process
DWORD64 reg_user; DWORD64 reg_user;
struct module* lmodules; struct module* lmodules;
unsigned long dbg_hdr_addr; ULONG_PTR dbg_hdr_addr;
IMAGEHLP_STACK_FRAME ctx_frame; IMAGEHLP_STACK_FRAME ctx_frame;
@ -423,13 +423,13 @@ struct process
struct line_info struct line_info
{ {
unsigned long is_first : 1, ULONG_PTR is_first : 1,
is_last : 1, is_last : 1,
is_source_file : 1, is_source_file : 1,
line_number; line_number;
union union
{ {
unsigned long pc_offset; /* if is_source_file isn't set */ ULONG_PTR pc_offset; /* if is_source_file isn't set */
unsigned source_file; /* if is_source_file is set */ unsigned source_file; /* if is_source_file is set */
} u; } u;
}; };
@ -606,7 +606,7 @@ extern DWORD calc_crc32(HANDLE handle) DECLSPEC_HIDDEN;
/* elf_module.c */ /* elf_module.c */
extern BOOL elf_read_wine_loader_dbg_info(struct process* pcs, ULONG_PTR addr) DECLSPEC_HIDDEN; extern BOOL elf_read_wine_loader_dbg_info(struct process* pcs, ULONG_PTR addr) DECLSPEC_HIDDEN;
struct elf_thunk_area; struct elf_thunk_area;
extern int elf_is_in_thunk_area(unsigned long addr, const struct elf_thunk_area* thunks) DECLSPEC_HIDDEN; extern int elf_is_in_thunk_area(ULONG_PTR addr, const struct elf_thunk_area* thunks) DECLSPEC_HIDDEN;
/* macho_module.c */ /* macho_module.c */
extern BOOL macho_read_wine_loader_dbg_info(struct process* pcs, ULONG_PTR addr) DECLSPEC_HIDDEN; extern BOOL macho_read_wine_loader_dbg_info(struct process* pcs, ULONG_PTR addr) DECLSPEC_HIDDEN;
@ -637,7 +637,7 @@ extern struct module*
module_new(struct process* pcs, const WCHAR* name, module_new(struct process* pcs, const WCHAR* name,
enum module_type type, BOOL virtual, enum module_type type, BOOL virtual,
DWORD64 addr, DWORD64 size, DWORD64 addr, DWORD64 size,
unsigned long stamp, unsigned long checksum) DECLSPEC_HIDDEN; ULONG_PTR stamp, ULONG_PTR checksum) DECLSPEC_HIDDEN;
extern struct module* extern struct module*
module_get_containee(const struct process* pcs, module_get_containee(const struct process* pcs,
const struct module* inner) DECLSPEC_HIDDEN; const struct module* inner) DECLSPEC_HIDDEN;
@ -689,18 +689,18 @@ extern const char* source_get(const struct module* module, unsigned idx) DECLSP
extern int source_rb_compare(const void *key, const struct wine_rb_entry *entry) DECLSPEC_HIDDEN; extern int source_rb_compare(const void *key, const struct wine_rb_entry *entry) DECLSPEC_HIDDEN;
/* stabs.c */ /* stabs.c */
typedef void (*stabs_def_cb)(struct module* module, unsigned long load_offset, typedef void (*stabs_def_cb)(struct module* module, ULONG_PTR load_offset,
const char* name, unsigned long offset, const char* name, ULONG_PTR offset,
BOOL is_public, BOOL is_global, unsigned char other, BOOL is_public, BOOL is_global, unsigned char other,
struct symt_compiland* compiland, void* user); struct symt_compiland* compiland, void* user);
extern BOOL stabs_parse(struct module* module, unsigned long load_offset, extern BOOL stabs_parse(struct module* module, ULONG_PTR load_offset,
const char* stabs, int stablen, const char* stabs, int stablen,
const char* strs, int strtablen, const char* strs, int strtablen,
stabs_def_cb callback, void* user) DECLSPEC_HIDDEN; stabs_def_cb callback, void* user) DECLSPEC_HIDDEN;
/* dwarf.c */ /* dwarf.c */
struct image_file_map; struct image_file_map;
extern BOOL dwarf2_parse(struct module* module, unsigned long load_offset, extern BOOL dwarf2_parse(struct module* module, ULONG_PTR load_offset,
const struct elf_thunk_area* thunks, const struct elf_thunk_area* thunks,
struct image_file_map* fmap) DECLSPEC_HIDDEN; struct image_file_map* fmap) DECLSPEC_HIDDEN;
extern BOOL dwarf2_virtual_unwind(struct cpu_stack_walk *csw, DWORD_PTR ip, extern BOOL dwarf2_virtual_unwind(struct cpu_stack_walk *csw, DWORD_PTR ip,
@ -721,33 +721,33 @@ extern void copy_symbolW(SYMBOL_INFOW* siw, const SYMBOL_INFO* si) DECLS
extern struct symt_ht* extern struct symt_ht*
symt_find_nearest(struct module* module, DWORD_PTR addr) DECLSPEC_HIDDEN; symt_find_nearest(struct module* module, DWORD_PTR addr) DECLSPEC_HIDDEN;
extern struct symt_compiland* extern struct symt_compiland*
symt_new_compiland(struct module* module, unsigned long address, symt_new_compiland(struct module* module, ULONG_PTR address,
unsigned src_idx) DECLSPEC_HIDDEN; unsigned src_idx) DECLSPEC_HIDDEN;
extern struct symt_public* extern struct symt_public*
symt_new_public(struct module* module, symt_new_public(struct module* module,
struct symt_compiland* parent, struct symt_compiland* parent,
const char* typename, const char* typename,
BOOL is_function, BOOL is_function,
unsigned long address, ULONG_PTR address,
unsigned size) DECLSPEC_HIDDEN; unsigned size) DECLSPEC_HIDDEN;
extern struct symt_data* extern struct symt_data*
symt_new_global_variable(struct module* module, symt_new_global_variable(struct module* module,
struct symt_compiland* parent, struct symt_compiland* parent,
const char* name, unsigned is_static, const char* name, unsigned is_static,
struct location loc, unsigned long size, struct location loc, ULONG_PTR size,
struct symt* type) DECLSPEC_HIDDEN; struct symt* type) DECLSPEC_HIDDEN;
extern struct symt_function* extern struct symt_function*
symt_new_function(struct module* module, symt_new_function(struct module* module,
struct symt_compiland* parent, struct symt_compiland* parent,
const char* name, const char* name,
unsigned long addr, unsigned long size, ULONG_PTR addr, ULONG_PTR size,
struct symt* type) DECLSPEC_HIDDEN; struct symt* type) DECLSPEC_HIDDEN;
extern BOOL symt_normalize_function(struct module* module, extern BOOL symt_normalize_function(struct module* module,
const struct symt_function* func) DECLSPEC_HIDDEN; const struct symt_function* func) DECLSPEC_HIDDEN;
extern void symt_add_func_line(struct module* module, extern void symt_add_func_line(struct module* module,
struct symt_function* func, struct symt_function* func,
unsigned source_idx, int line_num, unsigned source_idx, int line_num,
unsigned long offset) DECLSPEC_HIDDEN; ULONG_PTR offset) DECLSPEC_HIDDEN;
extern struct symt_data* extern struct symt_data*
symt_add_func_local(struct module* module, symt_add_func_local(struct module* module,
struct symt_function* func, struct symt_function* func,
@ -777,7 +777,7 @@ extern struct symt_thunk*
symt_new_thunk(struct module* module, symt_new_thunk(struct module* module,
struct symt_compiland* parent, struct symt_compiland* parent,
const char* name, THUNK_ORDINAL ord, const char* name, THUNK_ORDINAL ord,
unsigned long addr, unsigned long size) DECLSPEC_HIDDEN; ULONG_PTR addr, ULONG_PTR size) DECLSPEC_HIDDEN;
extern struct symt_data* extern struct symt_data*
symt_new_constant(struct module* module, symt_new_constant(struct module* module,
struct symt_compiland* parent, struct symt_compiland* parent,
@ -786,7 +786,7 @@ extern struct symt_data*
extern struct symt_hierarchy_point* extern struct symt_hierarchy_point*
symt_new_label(struct module* module, symt_new_label(struct module* module,
struct symt_compiland* compiland, struct symt_compiland* compiland,
const char* name, unsigned long address) DECLSPEC_HIDDEN; const char* name, ULONG_PTR address) DECLSPEC_HIDDEN;
extern struct symt* symt_index2ptr(struct module* module, DWORD id) DECLSPEC_HIDDEN; extern struct symt* symt_index2ptr(struct module* module, DWORD id) DECLSPEC_HIDDEN;
extern DWORD symt_ptr2index(struct module* module, const struct symt* sym) DECLSPEC_HIDDEN; extern DWORD symt_ptr2index(struct module* module, const struct symt* sym) DECLSPEC_HIDDEN;
@ -826,7 +826,7 @@ extern BOOL symt_add_function_signature_parameter(struct module* module,
extern struct symt_pointer* extern struct symt_pointer*
symt_new_pointer(struct module* module, symt_new_pointer(struct module* module,
struct symt* ref_type, struct symt* ref_type,
unsigned long size) DECLSPEC_HIDDEN; ULONG_PTR size) DECLSPEC_HIDDEN;
extern struct symt_typedef* extern struct symt_typedef*
symt_new_typedef(struct module* module, struct symt* ref, symt_new_typedef(struct module* module, struct symt* ref,
const char* name) DECLSPEC_HIDDEN; const char* name) DECLSPEC_HIDDEN;

100
dlls/dbghelp/dwarf.c
View File

@ -117,15 +117,15 @@ static void dump(const void* ptr, unsigned len)
typedef struct dwarf2_abbrev_entry_attr_s typedef struct dwarf2_abbrev_entry_attr_s
{ {
unsigned long attribute; ULONG_PTR attribute;
unsigned long form; ULONG_PTR form;
struct dwarf2_abbrev_entry_attr_s* next; struct dwarf2_abbrev_entry_attr_s* next;
} dwarf2_abbrev_entry_attr_t; } dwarf2_abbrev_entry_attr_t;
typedef struct dwarf2_abbrev_entry_s typedef struct dwarf2_abbrev_entry_s
{ {
unsigned long entry_code; ULONG_PTR entry_code;
unsigned long tag; ULONG_PTR tag;
unsigned char have_child; unsigned char have_child;
unsigned num_attr; unsigned num_attr;
dwarf2_abbrev_entry_attr_t* attrs; dwarf2_abbrev_entry_attr_t* attrs;
@ -139,13 +139,13 @@ struct dwarf2_block
struct attribute struct attribute
{ {
unsigned long form; ULONG_PTR form;
enum {attr_direct, attr_abstract_origin, attr_specification} gotten_from; enum {attr_direct, attr_abstract_origin, attr_specification} gotten_from;
union union
{ {
unsigned long uvalue; ULONG_PTR uvalue;
ULONGLONG lluvalue; ULONGLONG lluvalue;
long svalue; LONG_PTR svalue;
const char* string; const char* string;
struct dwarf2_block block; struct dwarf2_block block;
} u; } u;
@ -194,8 +194,8 @@ typedef struct dwarf2_parse_context_s
const struct elf_thunk_area*thunks; const struct elf_thunk_area*thunks;
struct sparse_array abbrev_table; struct sparse_array abbrev_table;
struct sparse_array debug_info_table; struct sparse_array debug_info_table;
unsigned long load_offset; ULONG_PTR load_offset;
unsigned long ref_offset; ULONG_PTR ref_offset;
struct symt* symt_cache[sc_num]; /* void, int1, int2, int4 */ struct symt* symt_cache[sc_num]; /* void, int1, int2, int4 */
char* cpp_name; char* cpp_name;
} dwarf2_parse_context_t; } dwarf2_parse_context_t;
@ -239,14 +239,14 @@ static unsigned short dwarf2_parse_u2(dwarf2_traverse_context_t* ctx)
return uvalue; return uvalue;
} }
static unsigned long dwarf2_get_u4(const unsigned char* ptr) static ULONG_PTR dwarf2_get_u4(const unsigned char* ptr)
{ {
return *(const UINT32*)ptr; return *(const UINT32*)ptr;
} }
static unsigned long dwarf2_parse_u4(dwarf2_traverse_context_t* ctx) static ULONG_PTR dwarf2_parse_u4(dwarf2_traverse_context_t* ctx)
{ {
unsigned long uvalue = dwarf2_get_u4(ctx->data); ULONG_PTR uvalue = dwarf2_get_u4(ctx->data);
ctx->data += 4; ctx->data += 4;
return uvalue; return uvalue;
} }
@ -263,9 +263,9 @@ static DWORD64 dwarf2_parse_u8(dwarf2_traverse_context_t* ctx)
return uvalue; return uvalue;
} }
static unsigned long dwarf2_get_leb128_as_unsigned(const unsigned char* ptr, const unsigned char** end) static ULONG_PTR dwarf2_get_leb128_as_unsigned(const unsigned char* ptr, const unsigned char** end)
{ {
unsigned long ret = 0; ULONG_PTR ret = 0;
unsigned char byte; unsigned char byte;
unsigned shift = 0; unsigned shift = 0;
@ -280,9 +280,9 @@ static unsigned long dwarf2_get_leb128_as_unsigned(const unsigned char* ptr, con
return ret; return ret;
} }
static unsigned long dwarf2_leb128_as_unsigned(dwarf2_traverse_context_t* ctx) static ULONG_PTR dwarf2_leb128_as_unsigned(dwarf2_traverse_context_t* ctx)
{ {
unsigned long ret; ULONG_PTR ret;
assert(ctx); assert(ctx);
@ -291,9 +291,9 @@ static unsigned long dwarf2_leb128_as_unsigned(dwarf2_traverse_context_t* ctx)
return ret; return ret;
} }
static long dwarf2_get_leb128_as_signed(const unsigned char* ptr, const unsigned char** end) static LONG_PTR dwarf2_get_leb128_as_signed(const unsigned char* ptr, const unsigned char** end)
{ {
long ret = 0; LONG_PTR ret = 0;
unsigned char byte; unsigned char byte;
unsigned shift = 0; unsigned shift = 0;
const unsigned size = sizeof(int) * 8; const unsigned size = sizeof(int) * 8;
@ -316,9 +316,9 @@ static long dwarf2_get_leb128_as_signed(const unsigned char* ptr, const unsigned
return ret; return ret;
} }
static long dwarf2_leb128_as_signed(dwarf2_traverse_context_t* ctx) static LONG_PTR dwarf2_leb128_as_signed(dwarf2_traverse_context_t* ctx)
{ {
long ret = 0; LONG_PTR ret = 0;
assert(ctx); assert(ctx);
@ -340,9 +340,9 @@ static unsigned dwarf2_leb128_length(const dwarf2_traverse_context_t* ctx)
* We assume that in all cases word size from Dwarf matches the size of * We assume that in all cases word size from Dwarf matches the size of
* addresses in platform where the exec is compiled. * addresses in platform where the exec is compiled.
*/ */
static unsigned long dwarf2_get_addr(const unsigned char* ptr, unsigned word_size) static ULONG_PTR dwarf2_get_addr(const unsigned char* ptr, unsigned word_size)
{ {
unsigned long ret; ULONG_PTR ret;
switch (word_size) switch (word_size)
{ {
@ -359,9 +359,9 @@ static unsigned long dwarf2_get_addr(const unsigned char* ptr, unsigned word_siz
return ret; return ret;
} }
static unsigned long dwarf2_parse_addr(dwarf2_traverse_context_t* ctx) static ULONG_PTR dwarf2_parse_addr(dwarf2_traverse_context_t* ctx)
{ {
unsigned long ret = dwarf2_get_addr(ctx->data, ctx->word_size); ULONG_PTR ret = dwarf2_get_addr(ctx->data, ctx->word_size);
ctx->data += ctx->word_size; ctx->data += ctx->word_size;
return ret; return ret;
} }
@ -385,7 +385,7 @@ static const char* dwarf2_debug_di(const dwarf2_debug_info_t* di)
static dwarf2_abbrev_entry_t* static dwarf2_abbrev_entry_t*
dwarf2_abbrev_table_find_entry(const struct sparse_array* abbrev_table, dwarf2_abbrev_table_find_entry(const struct sparse_array* abbrev_table,
unsigned long entry_code) ULONG_PTR entry_code)
{ {
assert( NULL != abbrev_table ); assert( NULL != abbrev_table );
return sparse_array_find(abbrev_table, entry_code); return sparse_array_find(abbrev_table, entry_code);
@ -395,12 +395,12 @@ static void dwarf2_parse_abbrev_set(dwarf2_traverse_context_t* abbrev_ctx,
struct sparse_array* abbrev_table, struct sparse_array* abbrev_table,
struct pool* pool) struct pool* pool)
{ {
unsigned long entry_code; ULONG_PTR entry_code;
dwarf2_abbrev_entry_t* abbrev_entry; dwarf2_abbrev_entry_t* abbrev_entry;
dwarf2_abbrev_entry_attr_t* new = NULL; dwarf2_abbrev_entry_attr_t* new = NULL;
dwarf2_abbrev_entry_attr_t* last = NULL; dwarf2_abbrev_entry_attr_t* last = NULL;
unsigned long attribute; ULONG_PTR attribute;
unsigned long form; ULONG_PTR form;
assert( NULL != abbrev_ctx ); assert( NULL != abbrev_ctx );
@ -573,7 +573,7 @@ static void dwarf2_fill_attr(const dwarf2_parse_context_t* ctx,
case DW_FORM_strp: case DW_FORM_strp:
{ {
unsigned long offset = dwarf2_get_u4(data); ULONG_PTR offset = dwarf2_get_u4(data);
attr->u.string = (const char*)ctx->sections[section_string].address + offset; attr->u.string = (const char*)ctx->sections[section_string].address + offset;
} }
TRACE("strp<%s>\n", debugstr_a(attr->u.string)); TRACE("strp<%s>\n", debugstr_a(attr->u.string));
@ -888,7 +888,7 @@ compute_location(dwarf2_traverse_context_t* ctx, struct location* loc,
static BOOL dwarf2_compute_location_attr(dwarf2_parse_context_t* ctx, static BOOL dwarf2_compute_location_attr(dwarf2_parse_context_t* ctx,
const dwarf2_debug_info_t* di, const dwarf2_debug_info_t* di,
unsigned long dw, ULONG_PTR dw,
struct location* loc, struct location* loc,
const struct location* frame) const struct location* frame)
{ {
@ -941,7 +941,7 @@ static BOOL dwarf2_compute_location_attr(dwarf2_parse_context_t* ctx,
sizeof(unsigned) + xloc.u.block.size); sizeof(unsigned) + xloc.u.block.size);
*ptr = xloc.u.block.size; *ptr = xloc.u.block.size;
memcpy(ptr + 1, xloc.u.block.ptr, xloc.u.block.size); memcpy(ptr + 1, xloc.u.block.ptr, xloc.u.block.size);
loc->offset = (unsigned long)ptr; loc->offset = (ULONG_PTR)ptr;
compute_location(&lctx, loc, NULL, frame); compute_location(&lctx, loc, NULL, frame);
} }
} }
@ -1029,14 +1029,14 @@ static const char* dwarf2_get_cpp_name(dwarf2_parse_context_t* ctx, dwarf2_debug
* in all cases, range is relative to beginning of compilation unit * in all cases, range is relative to beginning of compilation unit
*/ */
static BOOL dwarf2_read_range(dwarf2_parse_context_t* ctx, const dwarf2_debug_info_t* di, static BOOL dwarf2_read_range(dwarf2_parse_context_t* ctx, const dwarf2_debug_info_t* di,
unsigned long* plow, unsigned long* phigh) ULONG_PTR* plow, ULONG_PTR* phigh)
{ {
struct attribute range; struct attribute range;
if (dwarf2_find_attribute(ctx, di, DW_AT_ranges, &range)) if (dwarf2_find_attribute(ctx, di, DW_AT_ranges, &range))
{ {
dwarf2_traverse_context_t traverse; dwarf2_traverse_context_t traverse;
unsigned long low, high; ULONG_PTR low, high;
traverse.data = ctx->sections[section_ranges].address + range.u.uvalue; traverse.data = ctx->sections[section_ranges].address + range.u.uvalue;
traverse.end_data = ctx->sections[section_ranges].address + traverse.end_data = ctx->sections[section_ranges].address +
@ -1084,8 +1084,8 @@ static BOOL dwarf2_read_one_debug_info(dwarf2_parse_context_t* ctx,
dwarf2_debug_info_t** pdi) dwarf2_debug_info_t** pdi)
{ {
const dwarf2_abbrev_entry_t*abbrev; const dwarf2_abbrev_entry_t*abbrev;
unsigned long entry_code; ULONG_PTR entry_code;
unsigned long offset; ULONG_PTR offset;
dwarf2_debug_info_t* di; dwarf2_debug_info_t* di;
dwarf2_debug_info_t* child; dwarf2_debug_info_t* child;
dwarf2_debug_info_t** where; dwarf2_debug_info_t** where;
@ -1428,7 +1428,7 @@ static void dwarf2_parse_udt_member(dwarf2_parse_context_t* ctx,
{ {
DWORD64 size; DWORD64 size;
nbytes.u.uvalue = symt_get_info(ctx->module, elt_type, TI_GET_LENGTH, &size) ? nbytes.u.uvalue = symt_get_info(ctx->module, elt_type, TI_GET_LENGTH, &size) ?
(unsigned long)size : 0; (ULONG_PTR)size : 0;
} }
bit_offset.u.uvalue = nbytes.u.uvalue * 8 - bit_offset.u.uvalue - bit_size.u.uvalue; bit_offset.u.uvalue = nbytes.u.uvalue * 8 - bit_offset.u.uvalue - bit_size.u.uvalue;
} }
@ -1760,7 +1760,7 @@ static void dwarf2_parse_inlined_subroutine(dwarf2_subprogram_t* subpgm,
dwarf2_debug_info_t* di) dwarf2_debug_info_t* di)
{ {
struct symt_block* block; struct symt_block* block;
unsigned long low_pc, high_pc; ULONG_PTR low_pc, high_pc;
struct vector* children; struct vector* children;
dwarf2_debug_info_t*child; dwarf2_debug_info_t*child;
unsigned int i; unsigned int i;
@ -1814,7 +1814,7 @@ static void dwarf2_parse_subprogram_block(dwarf2_subprogram_t* subpgm,
dwarf2_debug_info_t* di) dwarf2_debug_info_t* di)
{ {
struct symt_block* block; struct symt_block* block;
unsigned long low_pc, high_pc; ULONG_PTR low_pc, high_pc;
struct vector* children; struct vector* children;
dwarf2_debug_info_t*child; dwarf2_debug_info_t*child;
unsigned int i; unsigned int i;
@ -1895,7 +1895,7 @@ static struct symt* dwarf2_parse_subprogram(dwarf2_parse_context_t* ctx,
dwarf2_debug_info_t* di) dwarf2_debug_info_t* di)
{ {
struct attribute name; struct attribute name;
unsigned long low_pc, high_pc; ULONG_PTR low_pc, high_pc;
struct attribute is_decl; struct attribute is_decl;
struct attribute inline_flags; struct attribute inline_flags;
struct symt* ret_type; struct symt* ret_type;
@ -2163,7 +2163,7 @@ static void dwarf2_load_one_entry(dwarf2_parse_context_t* ctx,
} }
} }
static void dwarf2_set_line_number(struct module* module, unsigned long address, static void dwarf2_set_line_number(struct module* module, ULONG_PTR address,
const struct vector* v, unsigned file, unsigned line) const struct vector* v, unsigned file, unsigned line)
{ {
struct symt_function* func; struct symt_function* func;
@ -2183,10 +2183,10 @@ static void dwarf2_set_line_number(struct module* module, unsigned long address,
static BOOL dwarf2_parse_line_numbers(const dwarf2_section_t* sections, static BOOL dwarf2_parse_line_numbers(const dwarf2_section_t* sections,
dwarf2_parse_context_t* ctx, dwarf2_parse_context_t* ctx,
const char* compile_dir, const char* compile_dir,
unsigned long offset) ULONG_PTR offset)
{ {
dwarf2_traverse_context_t traverse; dwarf2_traverse_context_t traverse;
unsigned long length; ULONG_PTR length;
unsigned insn_size, default_stmt; unsigned insn_size, default_stmt;
unsigned line_range, opcode_base; unsigned line_range, opcode_base;
int line_base; int line_base;
@ -2276,7 +2276,7 @@ static BOOL dwarf2_parse_line_numbers(const dwarf2_section_t* sections,
while (traverse.data < traverse.end_data) while (traverse.data < traverse.end_data)
{ {
unsigned long address = 0; ULONG_PTR address = 0;
unsigned file = 1; unsigned file = 1;
unsigned line = 1; unsigned line = 1;
unsigned is_stmt = default_stmt; unsigned is_stmt = default_stmt;
@ -2374,16 +2374,16 @@ static BOOL dwarf2_parse_compilation_unit(const dwarf2_section_t* sections,
struct module* module, struct module* module,
const struct elf_thunk_area* thunks, const struct elf_thunk_area* thunks,
dwarf2_traverse_context_t* mod_ctx, dwarf2_traverse_context_t* mod_ctx,
unsigned long load_offset) ULONG_PTR load_offset)
{ {
dwarf2_parse_context_t ctx; dwarf2_parse_context_t ctx;
dwarf2_traverse_context_t abbrev_ctx; dwarf2_traverse_context_t abbrev_ctx;
dwarf2_debug_info_t* di; dwarf2_debug_info_t* di;
dwarf2_traverse_context_t cu_ctx; dwarf2_traverse_context_t cu_ctx;
const unsigned char* comp_unit_start = mod_ctx->data; const unsigned char* comp_unit_start = mod_ctx->data;
unsigned long cu_length; ULONG_PTR cu_length;
unsigned short cu_version; unsigned short cu_version;
unsigned long cu_abbrev_offset; ULONG_PTR cu_abbrev_offset;
BOOL ret = FALSE; BOOL ret = FALSE;
cu_length = dwarf2_parse_u4(mod_ctx); cu_length = dwarf2_parse_u4(mod_ctx);
@ -2470,7 +2470,7 @@ static BOOL dwarf2_parse_compilation_unit(const dwarf2_section_t* sections,
} }
static BOOL dwarf2_lookup_loclist(const struct module_format* modfmt, const BYTE* start, static BOOL dwarf2_lookup_loclist(const struct module_format* modfmt, const BYTE* start,
unsigned long ip, dwarf2_traverse_context_t* lctx) ULONG_PTR ip, dwarf2_traverse_context_t* lctx)
{ {
DWORD_PTR beg, end; DWORD_PTR beg, end;
const BYTE* ptr = start; const BYTE* ptr = start;
@ -2704,7 +2704,7 @@ static BOOL parse_cie_details(dwarf2_traverse_context_t* ctx, struct frame_info*
return TRUE; return TRUE;
} }
static BOOL dwarf2_get_cie(unsigned long addr, struct module* module, DWORD_PTR delta, static BOOL dwarf2_get_cie(ULONG_PTR addr, struct module* module, DWORD_PTR delta,
dwarf2_traverse_context_t* fde_ctx, dwarf2_traverse_context_t* cie_ctx, dwarf2_traverse_context_t* fde_ctx, dwarf2_traverse_context_t* cie_ctx,
struct frame_info* info, BOOL in_eh_frame) struct frame_info* info, BOOL in_eh_frame)
{ {
@ -2712,7 +2712,7 @@ static BOOL dwarf2_get_cie(unsigned long addr, struct module* module, DWORD_PTR
const unsigned char* cie_ptr; const unsigned char* cie_ptr;
const unsigned char* last_cie_ptr = (const unsigned char*)~0; const unsigned char* last_cie_ptr = (const unsigned char*)~0;
unsigned len, id; unsigned len, id;
unsigned long start, range; ULONG_PTR start, range;
unsigned cie_id; unsigned cie_id;
const BYTE* start_data = fde_ctx->data; const BYTE* start_data = fde_ctx->data;
@ -3505,7 +3505,7 @@ static void dwarf2_module_remove(struct process* pcs, struct module_format* modf
HeapFree(GetProcessHeap(), 0, modfmt); HeapFree(GetProcessHeap(), 0, modfmt);
} }
BOOL dwarf2_parse(struct module* module, unsigned long load_offset, BOOL dwarf2_parse(struct module* module, ULONG_PTR load_offset,
const struct elf_thunk_area* thunks, const struct elf_thunk_area* thunks,
struct image_file_map* fmap) struct image_file_map* fmap)
{ {

50
dlls/dbghelp/elf_module.c
View File

@ -116,13 +116,13 @@ struct elf_thunk_area
{ {
const char* symname; const char* symname;
THUNK_ORDINAL ordinal; THUNK_ORDINAL ordinal;
unsigned long rva_start; ULONG_PTR rva_start;
unsigned long rva_end; ULONG_PTR rva_end;
}; };
struct elf_module_info struct elf_module_info
{ {
unsigned long elf_addr; ULONG_PTR elf_addr;
unsigned short elf_mark : 1, unsigned short elf_mark : 1,
elf_loader : 1; elf_loader : 1;
struct image_file_map file_map; struct image_file_map file_map;
@ -355,7 +355,7 @@ static BOOL elf_map_file_read(struct image_file_map* fmap, struct elf_map_file_d
return ReadFile(fmap->u.elf.handle, buf, len, &bytes_read, NULL); return ReadFile(fmap->u.elf.handle, buf, len, &bytes_read, NULL);
case from_process: case from_process:
return ReadProcessMemory(emfd->u.process.handle, return ReadProcessMemory(emfd->u.process.handle,
(void*)((unsigned long)emfd->u.process.load_addr + (unsigned long)off), (void*)((ULONG_PTR)emfd->u.process.load_addr + (ULONG_PTR)off),
buf, len, &dw) && dw == len; buf, len, &dw) && dw == len;
default: default:
assert(0); assert(0);
@ -559,7 +559,7 @@ static void elf_module_remove(struct process* pcs, struct module_format* modfmt)
* Check whether an address lies within one of the thunk area we * Check whether an address lies within one of the thunk area we
* know of. * know of.
*/ */
int elf_is_in_thunk_area(unsigned long addr, int elf_is_in_thunk_area(ULONG_PTR addr,
const struct elf_thunk_area* thunks) const struct elf_thunk_area* thunks)
{ {
unsigned i; unsigned i;
@ -1085,8 +1085,8 @@ static BOOL elf_fetch_file_info(struct process* process, const WCHAR* name, ULON
} }
static BOOL elf_load_file_from_fmap(struct process* pcs, const WCHAR* filename, static BOOL elf_load_file_from_fmap(struct process* pcs, const WCHAR* filename,
struct image_file_map* fmap, unsigned long load_offset, struct image_file_map* fmap, ULONG_PTR load_offset,
unsigned long dyn_addr, struct elf_info* elf_info) ULONG_PTR dyn_addr, struct elf_info* elf_info)
{ {
BOOL ret = FALSE; BOOL ret = FALSE;
@ -1097,7 +1097,7 @@ static BOOL elf_load_file_from_fmap(struct process* pcs, const WCHAR* filename,
if (elf_find_section_type(fmap, ".dynamic", SHT_DYNAMIC, &ism)) if (elf_find_section_type(fmap, ".dynamic", SHT_DYNAMIC, &ism))
{ {
char* ptr = (char*)(ULONG_PTR)fmap->u.elf.sect[ism.sidx].shdr.sh_addr; char* ptr = (char*)(ULONG_PTR)fmap->u.elf.sect[ism.sidx].shdr.sh_addr;
unsigned long len; ULONG_PTR len;
if (load_offset) ptr += load_offset - fmap->u.elf.elf_start; if (load_offset) ptr += load_offset - fmap->u.elf.elf_start;
@ -1154,14 +1154,14 @@ static BOOL elf_load_file_from_fmap(struct process* pcs, const WCHAR* filename,
struct elf_module_info *elf_module_info; struct elf_module_info *elf_module_info;
struct module_format* modfmt; struct module_format* modfmt;
struct image_section_map ism; struct image_section_map ism;
unsigned long modbase = load_offset; ULONG_PTR modbase = load_offset;
if (elf_find_section_type(fmap, ".dynamic", SHT_DYNAMIC, &ism)) if (elf_find_section_type(fmap, ".dynamic", SHT_DYNAMIC, &ism))
{ {
unsigned long rva_dyn = elf_get_map_rva(&ism); ULONG_PTR rva_dyn = elf_get_map_rva(&ism);
TRACE("For module %s, got ELF (start=%lx dyn=%lx), link_map (start=%lx dyn=%lx)\n", TRACE("For module %s, got ELF (start=%lx dyn=%lx), link_map (start=%lx dyn=%lx)\n",
debugstr_w(filename), (unsigned long)fmap->u.elf.elf_start, rva_dyn, debugstr_w(filename), (ULONG_PTR)fmap->u.elf.elf_start, rva_dyn,
load_offset, dyn_addr); load_offset, dyn_addr);
if (dyn_addr && load_offset + rva_dyn != dyn_addr) if (dyn_addr && load_offset + rva_dyn != dyn_addr)
{ {
@ -1231,7 +1231,7 @@ static BOOL elf_load_file_from_fmap(struct process* pcs, const WCHAR* filename,
* 1 on success * 1 on success
*/ */
static BOOL elf_load_file(struct process* pcs, const WCHAR* filename, static BOOL elf_load_file(struct process* pcs, const WCHAR* filename,
unsigned long load_offset, unsigned long dyn_addr, ULONG_PTR load_offset, ULONG_PTR dyn_addr,
struct elf_info* elf_info) struct elf_info* elf_info)
{ {
BOOL ret = FALSE; BOOL ret = FALSE;
@ -1279,7 +1279,7 @@ static BOOL elf_load_file_cb(void *param, HANDLE handle, const WCHAR *filename)
* *
* locate some a value from the debuggee auxiliary vector * locate some a value from the debuggee auxiliary vector
*/ */
static BOOL elf_search_auxv(const struct process* pcs, unsigned type, unsigned long* val) static BOOL elf_search_auxv(const struct process* pcs, unsigned type, ULONG_PTR* val)
{ {
char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME]; char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
SYMBOL_INFO*si = (SYMBOL_INFO*)buffer; SYMBOL_INFO*si = (SYMBOL_INFO*)buffer;
@ -1350,7 +1350,7 @@ static BOOL elf_search_auxv(const struct process* pcs, unsigned type, unsigned l
* lookup a file in standard ELF locations, and if found, load it * lookup a file in standard ELF locations, and if found, load it
*/ */
static BOOL elf_search_and_load_file(struct process* pcs, const WCHAR* filename, static BOOL elf_search_and_load_file(struct process* pcs, const WCHAR* filename,
unsigned long load_offset, unsigned long dyn_addr, ULONG_PTR load_offset, ULONG_PTR dyn_addr,
struct elf_info* elf_info) struct elf_info* elf_info)
{ {
BOOL ret = FALSE; BOOL ret = FALSE;
@ -1384,8 +1384,8 @@ static BOOL elf_search_and_load_file(struct process* pcs, const WCHAR* filename,
return ret; return ret;
} }
typedef BOOL (*enum_elf_modules_cb)(const WCHAR*, unsigned long load_addr, typedef BOOL (*enum_elf_modules_cb)(const WCHAR*, ULONG_PTR load_addr,
unsigned long dyn_addr, BOOL is_system, void* user); ULONG_PTR dyn_addr, BOOL is_system, void* user);
/****************************************************************** /******************************************************************
* elf_enum_modules_internal * elf_enum_modules_internal
@ -1427,7 +1427,7 @@ static BOOL elf_enum_modules_internal(const struct process* pcs,
bufstr[sizeof(bufstr) - 1] = '\0'; bufstr[sizeof(bufstr) - 1] = '\0';
MultiByteToWideChar(CP_UNIXCP, 0, bufstr, -1, bufstrW, ARRAY_SIZE(bufstrW)); MultiByteToWideChar(CP_UNIXCP, 0, bufstr, -1, bufstrW, ARRAY_SIZE(bufstrW));
if (main_name && !bufstrW[0]) strcpyW(bufstrW, main_name); if (main_name && !bufstrW[0]) strcpyW(bufstrW, main_name);
if (!cb(bufstrW, (unsigned long)lm.l_addr, (unsigned long)lm.l_ld, FALSE, user)) if (!cb(bufstrW, (ULONG_PTR)lm.l_addr, (ULONG_PTR)lm.l_ld, FALSE, user))
break; break;
} }
} }
@ -1461,7 +1461,7 @@ static BOOL elf_enum_modules_internal(const struct process* pcs,
bufstr[sizeof(bufstr) - 1] = '\0'; bufstr[sizeof(bufstr) - 1] = '\0';
MultiByteToWideChar(CP_UNIXCP, 0, bufstr, -1, bufstrW, ARRAY_SIZE(bufstrW)); MultiByteToWideChar(CP_UNIXCP, 0, bufstr, -1, bufstrW, ARRAY_SIZE(bufstrW));
if (main_name && !bufstrW[0]) strcpyW(bufstrW, main_name); if (main_name && !bufstrW[0]) strcpyW(bufstrW, main_name);
if (!cb(bufstrW, (unsigned long)lm.l_addr, (unsigned long)lm.l_ld, FALSE, user)) if (!cb(bufstrW, (ULONG_PTR)lm.l_addr, (ULONG_PTR)lm.l_ld, FALSE, user))
break; break;
} }
} }
@ -1470,7 +1470,7 @@ static BOOL elf_enum_modules_internal(const struct process* pcs,
#ifdef AT_SYSINFO_EHDR #ifdef AT_SYSINFO_EHDR
if (!lm_addr) if (!lm_addr)
{ {
unsigned long ehdr_addr; ULONG_PTR ehdr_addr;
if (elf_search_auxv(pcs, AT_SYSINFO_EHDR, &ehdr_addr)) if (elf_search_auxv(pcs, AT_SYSINFO_EHDR, &ehdr_addr))
{ {
@ -1488,8 +1488,8 @@ struct elf_enum_user
void* user; void* user;
}; };
static BOOL elf_enum_modules_translate(const WCHAR* name, unsigned long load_addr, static BOOL elf_enum_modules_translate(const WCHAR* name, ULONG_PTR load_addr,
unsigned long dyn_addr, BOOL is_system, void* user) ULONG_PTR dyn_addr, BOOL is_system, void* user)
{ {
struct elf_enum_user* eeu = user; struct elf_enum_user* eeu = user;
return eeu->cb(name, load_addr, eeu->user); return eeu->cb(name, load_addr, eeu->user);
@ -1531,8 +1531,8 @@ struct elf_load
* Callback for elf_load_module, used to walk the list of loaded * Callback for elf_load_module, used to walk the list of loaded
* modules. * modules.
*/ */
static BOOL elf_load_cb(const WCHAR* name, unsigned long load_addr, static BOOL elf_load_cb(const WCHAR* name, ULONG_PTR load_addr,
unsigned long dyn_addr, BOOL is_system, void* user) ULONG_PTR dyn_addr, BOOL is_system, void* user)
{ {
struct elf_load* el = user; struct elf_load* el = user;
BOOL ret = TRUE; BOOL ret = TRUE;
@ -1583,7 +1583,7 @@ static BOOL elf_load_cb(const WCHAR* name, unsigned long load_addr,
* Also, find module real name and load address from * Also, find module real name and load address from
* the real loaded modules list in pcs address space * the real loaded modules list in pcs address space
*/ */
static struct module* elf_load_module(struct process* pcs, const WCHAR* name, unsigned long addr) static struct module* elf_load_module(struct process* pcs, const WCHAR* name, ULONG_PTR addr)
{ {
struct elf_load el; struct elf_load el;
@ -1707,7 +1707,7 @@ BOOL elf_read_wine_loader_dbg_info(struct process* pcs, ULONG_PTR addr)
return FALSE; return FALSE;
} }
int elf_is_in_thunk_area(unsigned long addr, int elf_is_in_thunk_area(ULONG_PTR addr,
const struct elf_thunk_area* thunks) const struct elf_thunk_area* thunks)
{ {
return -1; return -1;

2
dlls/dbghelp/image_private.h
View File

@ -130,7 +130,7 @@ struct image_file_map
struct image_section_map struct image_section_map
{ {
struct image_file_map* fmap; struct image_file_map* fmap;
long sidx; LONG_PTR sidx;
}; };
BOOL image_check_alternate(struct image_file_map* fmap, const struct module* module) DECLSPEC_HIDDEN; BOOL image_check_alternate(struct image_file_map* fmap, const struct module* module) DECLSPEC_HIDDEN;

70
dlls/dbghelp/macho_module.c
View File

@ -118,7 +118,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_macho);
struct macho_module_info struct macho_module_info
{ {
struct image_file_map file_map; struct image_file_map file_map;
unsigned long load_addr; ULONG_PTR load_addr;
unsigned short in_use : 1, unsigned short in_use : 1,
is_loader : 1; is_loader : 1;
}; };
@ -157,12 +157,12 @@ static char* format_uuid(const uint8_t uuid[16], char out[UUID_STRING_LEN])
* that encompasses it. For a fat binary, the architecture will * that encompasses it. For a fat binary, the architecture will
* itself be offset within the file, so take that into account. * itself be offset within the file, so take that into account.
*/ */
static void macho_calc_range(const struct macho_file_map* fmap, unsigned long offset, static void macho_calc_range(const struct macho_file_map* fmap, ULONG_PTR offset,
unsigned long len, unsigned long* out_aligned_offset, ULONG_PTR len, ULONG_PTR* out_aligned_offset,
unsigned long* out_aligned_end, unsigned long* out_misalign) ULONG_PTR* out_aligned_end, ULONG_PTR* out_misalign)
{ {
unsigned long pagemask; ULONG_PTR pagemask;
unsigned long file_offset, misalign; ULONG_PTR file_offset, misalign;
pagemask = sysinfo.dwAllocationGranularity - 1; pagemask = sysinfo.dwAllocationGranularity - 1;
file_offset = fmap->arch_offset + offset; file_offset = fmap->arch_offset + offset;
@ -178,10 +178,10 @@ static void macho_calc_range(const struct macho_file_map* fmap, unsigned long of
* *
* Maps a range (offset, length in bytes) from a Mach-O file into memory * Maps a range (offset, length in bytes) from a Mach-O file into memory
*/ */
static const char* macho_map_range(const struct macho_file_map* fmap, unsigned long offset, unsigned long len, static const char* macho_map_range(const struct macho_file_map* fmap, ULONG_PTR offset, ULONG_PTR len,
const char** base) const char** base)
{ {
unsigned long misalign, aligned_offset, aligned_map_end; ULONG_PTR misalign, aligned_offset, aligned_map_end;
const void* aligned_ptr; const void* aligned_ptr;
HANDLE mapping; HANDLE mapping;
@ -215,13 +215,13 @@ static const char* macho_map_range(const struct macho_file_map* fmap, unsigned l
* Unmaps a range (offset, length in bytes) of a Mach-O file from memory * Unmaps a range (offset, length in bytes) of a Mach-O file from memory
*/ */
static void macho_unmap_range(const char** base, const void** mapped, const struct macho_file_map* fmap, static void macho_unmap_range(const char** base, const void** mapped, const struct macho_file_map* fmap,
unsigned long offset, unsigned long len) ULONG_PTR offset, ULONG_PTR len)
{ {
TRACE("(%p, %p, %p/%p, 0x%08lx, 0x%08lx)\n", base, mapped, fmap, fmap->handle, offset, len); TRACE("(%p, %p, %p/%p, 0x%08lx, 0x%08lx)\n", base, mapped, fmap, fmap->handle, offset, len);
if ((mapped && *mapped != IMAGE_NO_MAP) || (base && *base != IMAGE_NO_MAP)) if ((mapped && *mapped != IMAGE_NO_MAP) || (base && *base != IMAGE_NO_MAP))
{ {
unsigned long misalign, aligned_offset, aligned_map_end; ULONG_PTR misalign, aligned_offset, aligned_map_end;
void* aligned_ptr; void* aligned_ptr;
macho_calc_range(fmap, offset, len, &aligned_offset, &aligned_map_end, &misalign); macho_calc_range(fmap, offset, len, &aligned_offset, &aligned_map_end, &misalign);
@ -247,12 +247,12 @@ static void macho_unmap_range(const char** base, const void** mapped, const stru
* the munmap doesn't fragment the mapping. * the munmap doesn't fragment the mapping.
*/ */
static BOOL macho_map_ranges(const struct macho_file_map* fmap, static BOOL macho_map_ranges(const struct macho_file_map* fmap,
unsigned long offset1, unsigned long len1, ULONG_PTR offset1, ULONG_PTR len1,
unsigned long offset2, unsigned long len2, ULONG_PTR offset2, ULONG_PTR len2,
const void** mapped1, const void** mapped2) const void** mapped1, const void** mapped2)
{ {
unsigned long aligned_offset1, aligned_map_end1; ULONG_PTR aligned_offset1, aligned_map_end1;
unsigned long aligned_offset2, aligned_map_end2; ULONG_PTR aligned_offset2, aligned_map_end2;
TRACE("(%p/%p, 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx, %p, %p)\n", fmap, fmap->handle, TRACE("(%p/%p, 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx, %p, %p)\n", fmap, fmap->handle,
offset1, len1, offset2, len2, mapped1, mapped2); offset1, len1, offset2, len2, mapped1, mapped2);
@ -299,12 +299,12 @@ static BOOL macho_map_ranges(const struct macho_file_map* fmap,
* macho_map_ranges. * macho_map_ranges.
*/ */
static void macho_unmap_ranges(const struct macho_file_map* fmap, static void macho_unmap_ranges(const struct macho_file_map* fmap,
unsigned long offset1, unsigned long len1, ULONG_PTR offset1, ULONG_PTR len1,
unsigned long offset2, unsigned long len2, ULONG_PTR offset2, ULONG_PTR len2,
const void** mapped1, const void** mapped2) const void** mapped1, const void** mapped2)
{ {
unsigned long aligned_offset1, aligned_map_end1; ULONG_PTR aligned_offset1, aligned_map_end1;
unsigned long aligned_offset2, aligned_map_end2; ULONG_PTR aligned_offset2, aligned_map_end2;
TRACE("(%p/%p, 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx, %p/%p, %p/%p)\n", fmap, fmap->handle, TRACE("(%p/%p, 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx, %p/%p, %p/%p)\n", fmap, fmap->handle,
offset1, len1, offset2, len2, mapped1, *mapped1, mapped2, *mapped2); offset1, len1, offset2, len2, mapped1, *mapped1, mapped2, *mapped2);
@ -566,7 +566,7 @@ static int macho_load_section_info(struct image_file_map* ifm, const struct load
struct section_info* info = user; struct section_info* info = user;
BOOL ignore; BOOL ignore;
int i; int i;
unsigned long tmp, page_mask = sysinfo.dwPageSize - 1; ULONG_PTR tmp, page_mask = sysinfo.dwPageSize - 1;
uint64_t vmaddr, vmsize; uint64_t vmaddr, vmsize;
char segname[16]; char segname[16];
uint32_t nsects; uint32_t nsects;
@ -592,9 +592,9 @@ static int macho_load_section_info(struct image_file_map* ifm, const struct load
} }
TRACE("(%p/%p, %p, %p) before: 0x%08lx - 0x%08lx\n", fmap, fmap->handle, lc, user, TRACE("(%p/%p, %p, %p) before: 0x%08lx - 0x%08lx\n", fmap, fmap->handle, lc, user,
(unsigned long)fmap->segs_start, (unsigned long)fmap->segs_size); (ULONG_PTR)fmap->segs_start, (ULONG_PTR)fmap->segs_size);
TRACE("Segment command vm: 0x%08lx - 0x%08lx\n", (unsigned long)vmaddr, TRACE("Segment command vm: 0x%08lx - 0x%08lx\n", (ULONG_PTR)vmaddr,
(unsigned long)(vmaddr + vmsize)); (ULONG_PTR)(vmaddr + vmsize));
/* Images in the dyld shared cache have their segments mapped non-contiguously. /* Images in the dyld shared cache have their segments mapped non-contiguously.
We don't know how to properly locate any of the segments other than __TEXT, We don't know how to properly locate any of the segments other than __TEXT,
@ -617,7 +617,7 @@ static int macho_load_section_info(struct image_file_map* ifm, const struct load
tmp = (vmaddr + vmsize + page_mask) & ~page_mask; tmp = (vmaddr + vmsize + page_mask) & ~page_mask;
if (fmap->segs_size < tmp) fmap->segs_size = tmp; if (fmap->segs_size < tmp) fmap->segs_size = tmp;
TRACE("after: 0x%08lx - 0x%08lx\n", (unsigned long)fmap->segs_start, (unsigned long)fmap->segs_size); TRACE("after: 0x%08lx - 0x%08lx\n", (ULONG_PTR)fmap->segs_start, (ULONG_PTR)fmap->segs_size);
} }
for (i = 0; i < nsects; i++) for (i = 0; i < nsects; i++)
@ -787,8 +787,8 @@ static BOOL macho_map_file(struct process *pcs, const WCHAR *filenameW,
} }
fmap->segs_size -= fmap->segs_start; fmap->segs_size -= fmap->segs_start;
TRACE("segs_start: 0x%08lx, segs_size: 0x%08lx\n", (unsigned long)fmap->segs_start, TRACE("segs_start: 0x%08lx, segs_size: 0x%08lx\n", (ULONG_PTR)fmap->segs_start,
(unsigned long)fmap->segs_size); (ULONG_PTR)fmap->segs_size);
if (macho_enum_load_commands(ifm, LC_UUID, find_uuid, NULL) < 0) if (macho_enum_load_commands(ifm, LC_UUID, find_uuid, NULL) < 0)
goto done; goto done;
@ -873,7 +873,7 @@ struct symtab_elt
{ {
struct hash_table_elt ht_elt; struct hash_table_elt ht_elt;
struct symt_compiland* compiland; struct symt_compiland* compiland;
unsigned long addr; ULONG_PTR addr;
unsigned char is_code:1, unsigned char is_code:1,
is_public:1, is_public:1,
is_global:1, is_global:1,
@ -893,8 +893,8 @@ struct macho_debug_info
* *
* Callback for stabs_parse. Collect symbol definitions. * Callback for stabs_parse. Collect symbol definitions.
*/ */
static void macho_stabs_def_cb(struct module* module, unsigned long load_offset, static void macho_stabs_def_cb(struct module* module, ULONG_PTR load_offset,
const char* name, unsigned long offset, const char* name, ULONG_PTR offset,
BOOL is_public, BOOL is_global, unsigned char sectidx, BOOL is_public, BOOL is_global, unsigned char sectidx,
struct symt_compiland* compiland, void* user) struct symt_compiland* compiland, void* user)
{ {
@ -1253,7 +1253,7 @@ found:
* The image header has to be loaded from the process's memory * The image header has to be loaded from the process's memory
* because the relevant flag is only set in memory, not in the file. * because the relevant flag is only set in memory, not in the file.
*/ */
static BOOL image_uses_split_segs(struct process* process, unsigned long load_addr) static BOOL image_uses_split_segs(struct process* process, ULONG_PTR load_addr)
{ {
BOOL split_segs = FALSE; BOOL split_segs = FALSE;
@ -1412,7 +1412,7 @@ static ULONG_PTR get_dyld_image_info_address(struct process* pcs)
* TRUE on success * TRUE on success
*/ */
static BOOL macho_load_file(struct process* pcs, const WCHAR* filename, static BOOL macho_load_file(struct process* pcs, const WCHAR* filename,
unsigned long load_addr, struct macho_info* macho_info) ULONG_PTR load_addr, struct macho_info* macho_info)
{ {
BOOL ret = TRUE; BOOL ret = TRUE;
BOOL split_segs; BOOL split_segs;
@ -1500,7 +1500,7 @@ static BOOL macho_load_file_cb(void *param, HANDLE handle, const WCHAR *filename
* Lookup a file in standard Mach-O locations, and if found, load it * Lookup a file in standard Mach-O locations, and if found, load it
*/ */
static BOOL macho_search_and_load_file(struct process* pcs, const WCHAR* filename, static BOOL macho_search_and_load_file(struct process* pcs, const WCHAR* filename,
unsigned long load_addr, ULONG_PTR load_addr,
struct macho_info* macho_info) struct macho_info* macho_info)
{ {
BOOL ret = FALSE; BOOL ret = FALSE;
@ -1564,7 +1564,7 @@ static BOOL macho_enum_modules_internal(const struct process* pcs,
{ {
union wine_all_image_infos image_infos; union wine_all_image_infos image_infos;
union wine_image_info* info_array = NULL; union wine_image_info* info_array = NULL;
unsigned long len; ULONG_PTR len;
int i; int i;
char bufstr[256]; char bufstr[256];
WCHAR bufstrW[MAX_PATH]; WCHAR bufstrW[MAX_PATH];
@ -1637,7 +1637,7 @@ struct macho_sync
struct macho_info macho_info; struct macho_info macho_info;
}; };
static BOOL macho_enum_sync_cb(const WCHAR* name, unsigned long addr, void* user) static BOOL macho_enum_sync_cb(const WCHAR* name, ULONG_PTR addr, void* user)
{ {
struct macho_sync* ms = user; struct macho_sync* ms = user;
@ -1721,7 +1721,7 @@ struct macho_load
* Callback for macho_load_module, used to walk the list of loaded * Callback for macho_load_module, used to walk the list of loaded
* modules. * modules.
*/ */
static BOOL macho_load_cb(const WCHAR* name, unsigned long addr, void* user) static BOOL macho_load_cb(const WCHAR* name, ULONG_PTR addr, void* user)
{ {
struct macho_load* ml = user; struct macho_load* ml = user;
const WCHAR* p; const WCHAR* p;
@ -1747,7 +1747,7 @@ static BOOL macho_load_cb(const WCHAR* name, unsigned long addr, void* user)
* Also, find module real name and load address from * Also, find module real name and load address from
* the real loaded modules list in pcs address space. * the real loaded modules list in pcs address space.
*/ */
static struct module* macho_load_module(struct process* pcs, const WCHAR* name, unsigned long addr) static struct module* macho_load_module(struct process* pcs, const WCHAR* name, ULONG_PTR addr)
{ {
struct macho_load ml; struct macho_load ml;

2
dlls/dbghelp/minidump.c
View File

@ -255,7 +255,7 @@ static BOOL WINAPI fetch_pe_module_info_cb(PCWSTR name, DWORD64 base, ULONG size
* *
* Callback for accumulating in dump_context an host modules set * Callback for accumulating in dump_context an host modules set
*/ */
static BOOL fetch_host_module_info_cb(const WCHAR* name, unsigned long base, static BOOL fetch_host_module_info_cb(const WCHAR* name, ULONG_PTR base,
void* user) void* user)
{ {
struct dump_context* dc = user; struct dump_context* dc = user;

4
dlls/dbghelp/module.c
View File

@ -187,7 +187,7 @@ static const char* get_module_type(enum module_type type, BOOL virtual)
struct module* module_new(struct process* pcs, const WCHAR* name, struct module* module_new(struct process* pcs, const WCHAR* name,
enum module_type type, BOOL virtual, enum module_type type, BOOL virtual,
DWORD64 mod_addr, DWORD64 size, DWORD64 mod_addr, DWORD64 size,
unsigned long stamp, unsigned long checksum) ULONG_PTR stamp, ULONG_PTR checksum)
{ {
struct module* module; struct module* module;
unsigned i; unsigned i;
@ -1354,7 +1354,7 @@ static BOOL native_synchronize_module_list(struct process* pcs)
return FALSE; return FALSE;
} }
static struct module* native_load_module(struct process* pcs, const WCHAR* name, unsigned long addr) static struct module* native_load_module(struct process* pcs, const WCHAR* name, ULONG_PTR addr)
{ {
return NULL; return NULL;
} }

6
dlls/dbghelp/msc.c
View File

@ -1393,7 +1393,7 @@ static BOOL codeview_parse_type_table(struct codeview_type_parse* ctp)
/*======================================================================== /*========================================================================
* Process CodeView line number information. * Process CodeView line number information.
*/ */
static unsigned long codeview_get_address(const struct msc_debug_info* msc_dbg, static ULONG_PTR codeview_get_address(const struct msc_debug_info* msc_dbg,
unsigned seg, unsigned offset); unsigned seg, unsigned offset);
static void codeview_snarf_linetab(const struct msc_debug_info* msc_dbg, const BYTE* linetab, static void codeview_snarf_linetab(const struct msc_debug_info* msc_dbg, const BYTE* linetab,
@ -1408,7 +1408,7 @@ static void codeview_snarf_linetab(const struct msc_debug_info* msc_dbg, const B
const unsigned short* linenos; const unsigned short* linenos;
const struct startend* start; const struct startend* start;
unsigned source; unsigned source;
unsigned long addr, func_addr0; ULONG_PTR addr, func_addr0;
struct symt_function* func; struct symt_function* func;
const struct codeview_linetab_block* ltb; const struct codeview_linetab_block* ltb;
@ -1555,7 +1555,7 @@ static unsigned int codeview_map_offset(const struct msc_debug_info* msc_dbg,
return 0; return 0;
} }
static unsigned long codeview_get_address(const struct msc_debug_info* msc_dbg, static ULONG_PTR codeview_get_address(const struct msc_debug_info* msc_dbg,
unsigned seg, unsigned offset) unsigned seg, unsigned offset)
{ {
int nsect = msc_dbg->nsect; int nsect = msc_dbg->nsect;

54
dlls/dbghelp/stabs.c
View File

@ -153,7 +153,7 @@ static void stab_strcpy(char* dest, int sz, const char* source)
typedef struct typedef struct
{ {
char* name; char* name;
unsigned long value; ULONG_PTR value;
struct symt** vector; struct symt** vector;
int nrofentries; int nrofentries;
} include_def; } include_def;
@ -169,7 +169,7 @@ static struct symt** cu_vector = NULL;
static int cu_nrofentries = 0; static int cu_nrofentries = 0;
static struct symt_basic* stabs_basic[36]; static struct symt_basic* stabs_basic[36];
static int stabs_new_include(const char* file, unsigned long val) static int stabs_new_include(const char* file, ULONG_PTR val)
{ {
if (num_include_def == num_alloc_include_def) if (num_include_def == num_alloc_include_def)
{ {
@ -194,7 +194,7 @@ static int stabs_new_include(const char* file, unsigned long val)
return num_include_def++; return num_include_def++;
} }
static int stabs_find_include(const char* file, unsigned long val) static int stabs_find_include(const char* file, ULONG_PTR val)
{ {
int i; int i;
@ -248,7 +248,7 @@ static void stabs_free_includes(void)
cu_nrofentries = 0; cu_nrofentries = 0;
} }
static struct symt** stabs_find_ref(long filenr, long subnr) static struct symt** stabs_find_ref(LONG_PTR filenr, LONG_PTR subnr)
{ {
struct symt** ret; struct symt** ret;
@ -294,7 +294,7 @@ static struct symt** stabs_find_ref(long filenr, long subnr)
static struct symt** stabs_read_type_enum(const char** x) static struct symt** stabs_read_type_enum(const char** x)
{ {
long filenr, subnr; LONG_PTR filenr, subnr;
const char* iter; const char* iter;
char* end; char* end;
@ -418,7 +418,7 @@ static int stabs_pts_read_id(struct ParseTypedefData* ptd)
return -1; return -1;
} }
static int stabs_pts_read_number(struct ParseTypedefData* ptd, long* v) static int stabs_pts_read_number(struct ParseTypedefData* ptd, LONG_PTR* v)
{ {
char* last; char* last;
@ -429,7 +429,7 @@ static int stabs_pts_read_number(struct ParseTypedefData* ptd, long* v)
} }
static int stabs_pts_read_type_reference(struct ParseTypedefData* ptd, static int stabs_pts_read_type_reference(struct ParseTypedefData* ptd,
long* filenr, long* subnr) LONG_PTR* filenr, LONG_PTR* subnr)
{ {
if (*ptd->ptr == '(') if (*ptd->ptr == '(')
{ {
@ -604,7 +604,7 @@ static inline int stabs_pts_read_method_info(struct ParseTypedefData* ptd)
ptd->ptr++; ptd->ptr++;
if (mthd == '*') if (mthd == '*')
{ {
long int ofs; LONG_PTR ofs;
PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &ofs) == -1); PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &ofs) == -1);
PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
@ -620,7 +620,7 @@ static inline int stabs_pts_read_method_info(struct ParseTypedefData* ptd)
static inline int stabs_pts_read_aggregate(struct ParseTypedefData* ptd, static inline int stabs_pts_read_aggregate(struct ParseTypedefData* ptd,
struct symt_udt* sdt) struct symt_udt* sdt)
{ {
long sz, ofs; LONG_PTR sz, ofs;
struct symt* adt; struct symt* adt;
struct symt* dt = NULL; struct symt* dt = NULL;
int idx; int idx;
@ -631,7 +631,7 @@ static inline int stabs_pts_read_aggregate(struct ParseTypedefData* ptd,
doadd = symt_set_udt_size(ptd->module, sdt, sz); doadd = symt_set_udt_size(ptd->module, sdt, sz);
if (*ptd->ptr == '!') /* C++ inheritance */ if (*ptd->ptr == '!') /* C++ inheritance */
{ {
long num_classes; LONG_PTR num_classes;
ptd->ptr++; ptd->ptr++;
PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &num_classes) == -1); PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &num_classes) == -1);
@ -678,7 +678,7 @@ static inline int stabs_pts_read_aggregate(struct ParseTypedefData* ptd,
if (ptd->ptr[0] == '$' && ptd->ptr[1] == 'v') if (ptd->ptr[0] == '$' && ptd->ptr[1] == 'v')
{ {
long x; LONG_PTR x;
if (ptd->ptr[2] == 'f') if (ptd->ptr[2] == 'f')
{ {
@ -762,7 +762,7 @@ static inline int stabs_pts_read_aggregate(struct ParseTypedefData* ptd,
static inline int stabs_pts_read_enum(struct ParseTypedefData* ptd, static inline int stabs_pts_read_enum(struct ParseTypedefData* ptd,
struct symt_enum* edt) struct symt_enum* edt)
{ {
long value; LONG_PTR value;
int idx; int idx;
while (*ptd->ptr != ';') while (*ptd->ptr != ';')
@ -781,7 +781,7 @@ static inline int stabs_pts_read_enum(struct ParseTypedefData* ptd,
static inline int stabs_pts_read_array(struct ParseTypedefData* ptd, static inline int stabs_pts_read_array(struct ParseTypedefData* ptd,
struct symt** adt) struct symt** adt)
{ {
long lo, hi; LONG_PTR lo, hi;
struct symt* range_dt; struct symt* range_dt;
struct symt* base_dt; struct symt* base_dt;
@ -806,10 +806,10 @@ static int stabs_pts_read_type_def(struct ParseTypedefData* ptd, const char* typ
struct symt** ret_dt) struct symt** ret_dt)
{ {
int idx; int idx;
long sz = -1; LONG_PTR sz = -1;
struct symt* new_dt = NULL; /* newly created data type */ struct symt* new_dt = NULL; /* newly created data type */
struct symt* ref_dt; /* referenced data type (pointer...) */ struct symt* ref_dt; /* referenced data type (pointer...) */
long filenr1, subnr1, tmp; LONG_PTR filenr1, subnr1, tmp;
/* things are a bit complicated because of the way the typedefs are stored inside /* things are a bit complicated because of the way the typedefs are stored inside
* the file, because addresses can change when realloc is done, so we must call * the file, because addresses can change when realloc is done, so we must call
@ -970,8 +970,8 @@ static int stabs_pts_read_type_def(struct ParseTypedefData* ptd, const char* typ
break; break;
case 'R': case 'R':
{ {
long type, len, unk; LONG_PTR type, len, unk;
int basic; int basic;
PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &type) == -1); PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &type) == -1);
PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); /* ';' */ PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); /* ';' */
@ -1122,8 +1122,8 @@ struct pending_line
{ {
int source_idx; int source_idx;
int line_num; int line_num;
unsigned long offset; ULONG_PTR offset;
unsigned long load_offset; ULONG_PTR load_offset;
}; };
struct pending_object struct pending_object
@ -1175,8 +1175,8 @@ static inline void pending_add_var(struct pending_list* pending, const char* nam
} }
static inline void pending_add_line(struct pending_list* pending, int source_idx, static inline void pending_add_line(struct pending_list* pending, int source_idx,
int line_num, unsigned long offset, int line_num, ULONG_PTR offset,
unsigned long load_offset) ULONG_PTR load_offset)
{ {
pending_make_room(pending); pending_make_room(pending);
pending->objs[pending->num].tag = PENDING_LINE; pending->objs[pending->num].tag = PENDING_LINE;
@ -1225,7 +1225,7 @@ static void pending_flush(struct pending_list* pending, struct module* module,
* function (assuming that current function ends where next function starts) * function (assuming that current function ends where next function starts)
*/ */
static void stabs_finalize_function(struct module* module, struct symt_function* func, static void stabs_finalize_function(struct module* module, struct symt_function* func,
unsigned long size) ULONG_PTR size)
{ {
IMAGEHLP_LINE64 il; IMAGEHLP_LINE64 il;
struct location loc; struct location loc;
@ -1261,7 +1261,7 @@ static inline void stabbuf_append(char **buf, unsigned *buf_size, const char *st
strcpy(*buf+buf_len, str); strcpy(*buf+buf_len, str);
} }
BOOL stabs_parse(struct module* module, unsigned long load_offset, BOOL stabs_parse(struct module* module, ULONG_PTR load_offset,
const char* pv_stab_ptr, int stablen, const char* pv_stab_ptr, int stablen,
const char* strs, int strtablen, const char* strs, int strtablen,
stabs_def_cb callback, void* user) stabs_def_cb callback, void* user)
@ -1478,7 +1478,7 @@ BOOL stabs_parse(struct module* module, unsigned long load_offset,
case 35: case 35:
case 36: loc.reg = CV_REG_MM0 + n_value - 29; break; case 36: loc.reg = CV_REG_MM0 + n_value - 29; break;
default: default:
FIXME("Unknown register value (%lu)\n", (unsigned long)n_value); FIXME("Unknown register value (%lu)\n", (ULONG_PTR)n_value);
loc.reg = CV_REG_NONE; loc.reg = CV_REG_NONE;
break; break;
} }
@ -1512,7 +1512,7 @@ BOOL stabs_parse(struct module* module, unsigned long load_offset,
assert(source_idx >= 0); assert(source_idx >= 0);
if (curr_func != NULL) if (curr_func != NULL)
{ {
unsigned long offset = n_value; ULONG_PTR offset = n_value;
if (module->type == DMT_MACHO) if (module->type == DMT_MACHO)
offset -= curr_func->address - load_offset; offset -= curr_func->address - load_offset;
symt_add_func_line(module, curr_func, source_idx, symt_add_func_line(module, curr_func, source_idx,
@ -1628,7 +1628,7 @@ BOOL stabs_parse(struct module* module, unsigned long load_offset,
case N_EXCL: case N_EXCL:
if (stabs_add_include(stabs_find_include(ptr, n_value)) < 0) if (stabs_add_include(stabs_find_include(ptr, n_value)) < 0)
{ {
ERR("Excluded header not found (%s,%ld)\n", ptr, (unsigned long)n_value); ERR("Excluded header not found (%s,%ld)\n", ptr, (ULONG_PTR)n_value);
module_reset_debug_info(module); module_reset_debug_info(module);
ret = FALSE; ret = FALSE;
goto done; goto done;
@ -1675,7 +1675,7 @@ BOOL stabs_parse(struct module* module, unsigned long load_offset,
} }
stabbuff[0] = '\0'; stabbuff[0] = '\0';
TRACE("0x%02x %lx %s\n", TRACE("0x%02x %lx %s\n",
stab_ptr->n_type, (unsigned long)n_value, debugstr_a(strs + stab_ptr->n_strx)); stab_ptr->n_type, (ULONG_PTR)n_value, debugstr_a(strs + stab_ptr->n_strx));
} }
module->module.SymType = SymDia; module->module.SymType = SymDia;
module->module.CVSig = 'S' | ('T' << 8) | ('A' << 16) | ('B' << 24); module->module.CVSig = 'S' | ('T' << 8) | ('A' << 16) | ('B' << 24);

8
dlls/dbghelp/storage.c
View File

@ -205,7 +205,7 @@ void* vector_add(struct vector* v, struct pool* pool)
*/ */
struct key2index struct key2index
{ {
unsigned long key; ULONG_PTR key;
unsigned index; unsigned index;
}; };
@ -221,7 +221,7 @@ void sparse_array_init(struct sparse_array* sa, unsigned elt_sz, unsigned bucket
* Returns the first index which key is >= at passed key * Returns the first index which key is >= at passed key
*/ */
static struct key2index* sparse_array_lookup(const struct sparse_array* sa, static struct key2index* sparse_array_lookup(const struct sparse_array* sa,
unsigned long key, unsigned* idx) ULONG_PTR key, unsigned* idx)
{ {
struct key2index* pk2i; struct key2index* pk2i;
unsigned low, high; unsigned low, high;
@ -267,7 +267,7 @@ static struct key2index* sparse_array_lookup(const struct sparse_array* sa,
return pk2i; return pk2i;
} }
void* sparse_array_find(const struct sparse_array* sa, unsigned long key) void* sparse_array_find(const struct sparse_array* sa, ULONG_PTR key)
{ {
unsigned idx; unsigned idx;
struct key2index* pk2i; struct key2index* pk2i;
@ -277,7 +277,7 @@ void* sparse_array_find(const struct sparse_array* sa, unsigned long key)
return NULL; return NULL;
} }
void* sparse_array_add(struct sparse_array* sa, unsigned long key, void* sparse_array_add(struct sparse_array* sa, ULONG_PTR key,
struct pool* pool) struct pool* pool)
{ {
unsigned idx, i; unsigned idx, i;

18
dlls/dbghelp/symbol.c
View File

@ -183,7 +183,7 @@ static WCHAR* file_regex(const char* srcfile)
} }
struct symt_compiland* symt_new_compiland(struct module* module, struct symt_compiland* symt_new_compiland(struct module* module,
unsigned long address, unsigned src_idx) ULONG_PTR address, unsigned src_idx)
{ {
struct symt_compiland* sym; struct symt_compiland* sym;
@ -203,7 +203,7 @@ struct symt_public* symt_new_public(struct module* module,
struct symt_compiland* compiland, struct symt_compiland* compiland,
const char* name, const char* name,
BOOL is_function, BOOL is_function,
unsigned long address, unsigned size) ULONG_PTR address, unsigned size)
{ {
struct symt_public* sym; struct symt_public* sym;
struct symt** p; struct symt** p;
@ -234,7 +234,7 @@ struct symt_public* symt_new_public(struct module* module,
struct symt_data* symt_new_global_variable(struct module* module, struct symt_data* symt_new_global_variable(struct module* module,
struct symt_compiland* compiland, struct symt_compiland* compiland,
const char* name, unsigned is_static, const char* name, unsigned is_static,
struct location loc, unsigned long size, struct location loc, ULONG_PTR size,
struct symt* type) struct symt* type)
{ {
struct symt_data* sym; struct symt_data* sym;
@ -271,7 +271,7 @@ struct symt_data* symt_new_global_variable(struct module* module,
struct symt_function* symt_new_function(struct module* module, struct symt_function* symt_new_function(struct module* module,
struct symt_compiland* compiland, struct symt_compiland* compiland,
const char* name, const char* name,
unsigned long addr, unsigned long size, ULONG_PTR addr, ULONG_PTR size,
struct symt* sig_type) struct symt* sig_type)
{ {
struct symt_function* sym; struct symt_function* sym;
@ -302,7 +302,7 @@ struct symt_function* symt_new_function(struct module* module,
} }
void symt_add_func_line(struct module* module, struct symt_function* func, void symt_add_func_line(struct module* module, struct symt_function* func,
unsigned source_idx, int line_num, unsigned long offset) unsigned source_idx, int line_num, ULONG_PTR offset)
{ {
struct line_info* dli; struct line_info* dli;
BOOL last_matches = FALSE; BOOL last_matches = FALSE;
@ -474,7 +474,7 @@ BOOL symt_normalize_function(struct module* module, const struct symt_function*
struct symt_thunk* symt_new_thunk(struct module* module, struct symt_thunk* symt_new_thunk(struct module* module,
struct symt_compiland* compiland, struct symt_compiland* compiland,
const char* name, THUNK_ORDINAL ord, const char* name, THUNK_ORDINAL ord,
unsigned long addr, unsigned long size) ULONG_PTR addr, ULONG_PTR size)
{ {
struct symt_thunk* sym; struct symt_thunk* sym;
@ -531,7 +531,7 @@ struct symt_data* symt_new_constant(struct module* module,
struct symt_hierarchy_point* symt_new_label(struct module* module, struct symt_hierarchy_point* symt_new_label(struct module* module,
struct symt_compiland* compiland, struct symt_compiland* compiland,
const char* name, unsigned long address) const char* name, ULONG_PTR address)
{ {
struct symt_hierarchy_point* sym; struct symt_hierarchy_point* sym;
@ -656,8 +656,8 @@ static void symt_fill_sym_info(struct module_pair* pair,
switch (data->u.value.n1.n2.vt) switch (data->u.value.n1.n2.vt)
{ {
case VT_I4: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.lVal; break; case VT_I4: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.lVal; break;
case VT_I2: sym_info->Value = (ULONG)(long)data->u.value.n1.n2.n3.iVal; break; case VT_I2: sym_info->Value = (ULONG)(LONG_PTR)data->u.value.n1.n2.n3.iVal; break;
case VT_I1: sym_info->Value = (ULONG)(long)data->u.value.n1.n2.n3.cVal; break; case VT_I1: sym_info->Value = (ULONG)(LONG_PTR)data->u.value.n1.n2.n3.cVal; break;
case VT_UI4: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.ulVal; break; case VT_UI4: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.ulVal; break;
case VT_UI2: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.uiVal; break; case VT_UI2: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.uiVal; break;
case VT_UI1: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.bVal; break; case VT_UI1: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.bVal; break;

2
dlls/dbghelp/type.c
View File

@ -410,7 +410,7 @@ BOOL symt_add_function_signature_parameter(struct module* module,
return TRUE; return TRUE;
} }
struct symt_pointer* symt_new_pointer(struct module* module, struct symt* ref_type, unsigned long size) struct symt_pointer* symt_new_pointer(struct module* module, struct symt* ref_type, ULONG_PTR size)
{ {
struct symt_pointer* sym; struct symt_pointer* sym;