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

SymGetType(...,TI_GET_LENGTH,...) requires a 64 bit parameter, not a

Browse Source 
32 bit one.
This commit is contained in:
Eric Pouech 2005-11-17 11:51:53 +00:00 committed by Alexandre Julliard
parent 3d086ca2b7
commit 6b7bebfbf9
11 changed files with 91 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
dlls/dbghelp/dbghelp.c
View File

@ -37,7 +37,6 @@ WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
* but those values are not directly usable from a debugger (that's why, I * but those values are not directly usable from a debugger (that's why, I
* assume, that we have also to define constants for enum values, as * assume, that we have also to define constants for enum values, as
* Codeview does BTW. * Codeview does BTW.
* + SymGetType(TI_GET_LENGTH) takes a ULONG64 (yurk, ugly)
* - SymGetLine{Next|Prev} don't work as expected (they don't seem to work across * - SymGetLine{Next|Prev} don't work as expected (they don't seem to work across
* functions, and even across function blocks...). Basically, for *Next* to work * functions, and even across function blocks...). Basically, for *Next* to work
* it requires an address after the prolog of the func (the base address of the * it requires an address after the prolog of the func (the base address of the

8
dlls/dbghelp/elf_module.c
View File

@ -570,8 +570,8 @@ static int elf_new_wine_thunks(struct module* module, struct hash_table* ht_symt
} }
else if (strcmp(ste->ht_elt.name, module->addr_sorttab[idx]->hash_elt.name)) else if (strcmp(ste->ht_elt.name, module->addr_sorttab[idx]->hash_elt.name))
{ {
ULONG64 xaddr = 0; ULONG64 xaddr = 0, xsize = 0;
DWORD xsize = 0, kind = -1; DWORD kind = -1;
symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_ADDRESS, &xaddr); symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_ADDRESS, &xaddr);
symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_LENGTH, &xsize); symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_LENGTH, &xsize);
@ -584,11 +584,11 @@ static int elf_new_wine_thunks(struct module* module, struct hash_table* ht_symt
*/ */
if ((xsize || ste->symp->st_size) && if ((xsize || ste->symp->st_size) &&
(kind == (ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL) ? DataIsFileStatic : DataIsGlobal)) (kind == (ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL) ? DataIsFileStatic : DataIsGlobal))
FIXME("Duplicate in %s: %s<%08lx-%08x> %s<%s-%08lx>\n", FIXME("Duplicate in %s: %s<%08lx-%08x> %s<%s-%s>\n",
module->module.ModuleName, module->module.ModuleName,
ste->ht_elt.name, addr, ste->symp->st_size, ste->ht_elt.name, addr, ste->symp->st_size,
module->addr_sorttab[idx]->hash_elt.name, module->addr_sorttab[idx]->hash_elt.name,
wine_dbgstr_longlong(xaddr), xsize); wine_dbgstr_longlong(xaddr), wine_dbgstr_longlong(xsize));
} }
} }
} }

16
dlls/dbghelp/msc.c
View File

@ -403,9 +403,9 @@ static int codeview_add_type_array(struct module* module,
if (elem) if (elem)
{ {
DWORD elem_size; DWORD64 elem_size;
symt_get_info(elem, TI_GET_LENGTH, &elem_size); symt_get_info(elem, TI_GET_LENGTH, &elem_size);
if (elem_size) arr_max = arr_len / elem_size; if (elem_size) arr_max = arr_len / (DWORD)elem_size;
} }
symt = &symt_new_array(module, 0, arr_max, elem)->symt; symt = &symt_new_array(module, 0, arr_max, elem)->symt;
return codeview_add_type(typeno, symt); return codeview_add_type(typeno, symt);
@ -567,11 +567,11 @@ static int codeview_add_type_struct_field_list(struct module* module,
if (!subtype || subtype->tag != SymTagCVBitField) if (!subtype || subtype->tag != SymTagCVBitField)
{ {
DWORD elem_size = 0; DWORD64 elem_size = 0;
if (subtype) symt_get_info(subtype, TI_GET_LENGTH, &elem_size); if (subtype) symt_get_info(subtype, TI_GET_LENGTH, &elem_size);
symt_add_udt_element(module, symt, terminate_string(p_name), symt_add_udt_element(module, symt, terminate_string(p_name),
codeview_get_type(type->member_v1.type, TRUE), codeview_get_type(type->member_v1.type, TRUE),
value << 3, elem_size << 3); value << 3, (DWORD)elem_size << 3);
} }
else else
{ {
@ -591,10 +591,10 @@ static int codeview_add_type_struct_field_list(struct module* module,
if (!subtype || subtype->tag != SymTagCVBitField) if (!subtype || subtype->tag != SymTagCVBitField)
{ {
DWORD elem_size = 0; DWORD64 elem_size = 0;
if (subtype) symt_get_info(subtype, TI_GET_LENGTH, &elem_size); if (subtype) symt_get_info(subtype, TI_GET_LENGTH, &elem_size);
symt_add_udt_element(module, symt, terminate_string(p_name), symt_add_udt_element(module, symt, terminate_string(p_name),
subtype, value << 3, elem_size << 3); subtype, value << 3, (DWORD)elem_size << 3);
} }
else else
{ {
@ -614,10 +614,10 @@ static int codeview_add_type_struct_field_list(struct module* module,
if (!subtype || subtype->tag != SymTagCVBitField) if (!subtype || subtype->tag != SymTagCVBitField)
{ {
DWORD elem_size = 0; DWORD64 elem_size = 0;
if (subtype) symt_get_info(subtype, TI_GET_LENGTH, &elem_size); if (subtype) symt_get_info(subtype, TI_GET_LENGTH, &elem_size);
symt_add_udt_element(module, symt, c_name, symt_add_udt_element(module, symt, c_name,
subtype, value << 3, elem_size << 3); subtype, value << 3, (DWORD)elem_size << 3);
} }
else else
{ {

4
dlls/dbghelp/stabs.c
View File

@ -627,7 +627,7 @@ static inline int stabs_pts_read_aggregate(struct ParseTypedefData* ptd,
{ {
char tmp[256]; char tmp[256];
WCHAR* name; WCHAR* name;
DWORD size; DWORD64 size;
symt_get_info(adt, TI_GET_SYMNAME, &name); symt_get_info(adt, TI_GET_SYMNAME, &name);
strcpy(tmp, "__inherited_class_"); strcpy(tmp, "__inherited_class_");
@ -642,7 +642,7 @@ static inline int stabs_pts_read_aggregate(struct ParseTypedefData* ptd,
* be much of a problem * be much of a problem
*/ */
symt_get_info(adt, TI_GET_LENGTH, &size); symt_get_info(adt, TI_GET_LENGTH, &size);
symt_add_udt_element(ptd->module, sdt, tmp, adt, ofs, size * 8); symt_add_udt_element(ptd->module, sdt, tmp, adt, ofs, (DWORD)size * 8);
} }
PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
} }

14
dlls/dbghelp/symbol.c
View File

@ -179,7 +179,7 @@ struct symt_data* symt_new_global_variable(struct module* module,
{ {
struct symt_data* sym; struct symt_data* sym;
struct symt** p; struct symt** p;
DWORD tsz; DWORD64 tsz;
TRACE_(dbghelp_symt)("Adding global symbol %s:%s @%lx %p\n", TRACE_(dbghelp_symt)("Adding global symbol %s:%s @%lx %p\n",
module->module.ModuleName, name, addr, type); module->module.ModuleName, name, addr, type);
@ -196,8 +196,9 @@ struct symt_data* symt_new_global_variable(struct module* module,
if (type && size && symt_get_info(type, TI_GET_LENGTH, &tsz)) if (type && size && symt_get_info(type, TI_GET_LENGTH, &tsz))
{ {
if (tsz != size) if (tsz != size)
FIXME("Size mismatch for %s.%s between type (%lu) and src (%lu)\n", FIXME("Size mismatch for %s.%s between type (%s) and src (%lu)\n",
module->module.ModuleName, name, tsz, size); module->module.ModuleName, name,
wine_dbgstr_longlong(tsz), size);
} }
if (compiland) if (compiland)
{ {
@ -440,10 +441,12 @@ static void symt_fill_sym_info(const struct module* module,
const struct symt* sym, SYMBOL_INFO* sym_info) const struct symt* sym, SYMBOL_INFO* sym_info)
{ {
const char* name; const char* name;
DWORD64 size;
sym_info->TypeIndex = (DWORD)sym; sym_info->TypeIndex = (DWORD)sym;
sym_info->info = 0; /* TBD */ sym_info->info = 0; /* TBD */
symt_get_info(sym, TI_GET_LENGTH, &sym_info->Size); symt_get_info(sym, TI_GET_LENGTH, &size);
sym_info->Size = (DWORD)size;
sym_info->ModBase = module->module.BaseOfImage; sym_info->ModBase = module->module.BaseOfImage;
sym_info->Flags = 0; sym_info->Flags = 0;
switch (sym->tag) switch (sym->tag)
@ -601,8 +604,7 @@ static BOOL resort_symbols(struct module* module)
int symt_find_nearest(struct module* module, DWORD addr) int symt_find_nearest(struct module* module, DWORD addr)
{ {
int mid, high, low; int mid, high, low;
ULONG64 ref_addr; ULONG64 ref_addr, ref_size;
DWORD ref_size;
if (!module->sortlist_valid || !module->addr_sorttab) if (!module->sortlist_valid || !module->addr_sorttab)
{ {

24
dlls/dbghelp/type.c
View File

@ -370,7 +370,8 @@ BOOL WINAPI SymEnumTypes(HANDLE hProcess, ULONG64 BaseOfDll,
const char* tmp; const char* tmp;
struct symt* type; struct symt* type;
void* pos = NULL; void* pos = NULL;
DWORD64 size;
TRACE("(%p %s %p %p)\n", TRACE("(%p %s %p %p)\n",
hProcess, wine_dbgstr_longlong(BaseOfDll), EnumSymbolsCallback, hProcess, wine_dbgstr_longlong(BaseOfDll), EnumSymbolsCallback,
UserContext); UserContext);
@ -387,7 +388,8 @@ BOOL WINAPI SymEnumTypes(HANDLE hProcess, ULONG64 BaseOfDll,
type = *(struct symt**)pos; type = *(struct symt**)pos;
sym_info->TypeIndex = (DWORD)type; sym_info->TypeIndex = (DWORD)type;
sym_info->info = 0; /* FIXME */ sym_info->info = 0; /* FIXME */
symt_get_info(type, TI_GET_LENGTH, &sym_info->Size); symt_get_info(type, TI_GET_LENGTH, &size);
sym_info->Size = size;
sym_info->ModBase = module->module.BaseOfImage; sym_info->ModBase = module->module.BaseOfImage;
sym_info->Flags = 0; /* FIXME */ sym_info->Flags = 0; /* FIXME */
sym_info->Value = 0; /* FIXME */ sym_info->Value = 0; /* FIXME */
@ -559,40 +561,40 @@ BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req,
switch (type->tag) switch (type->tag)
{ {
case SymTagBaseType: case SymTagBaseType:
X(DWORD) = ((const struct symt_basic*)type)->size; X(DWORD64) = ((const struct symt_basic*)type)->size;
break; break;
case SymTagFunction: case SymTagFunction:
X(DWORD) = ((const struct symt_function*)type)->size; X(DWORD64) = ((const struct symt_function*)type)->size;
break; break;
case SymTagPointerType: case SymTagPointerType:
X(DWORD) = sizeof(void*); X(DWORD64) = sizeof(void*);
break; break;
case SymTagUDT: case SymTagUDT:
X(DWORD) = ((const struct symt_udt*)type)->size; X(DWORD64) = ((const struct symt_udt*)type)->size;
break; break;
case SymTagEnum: case SymTagEnum:
X(DWORD) = sizeof(int); /* FIXME: should be size of base-type of enum !!! */ X(DWORD64) = sizeof(int); /* FIXME: should be size of base-type of enum !!! */
break; break;
case SymTagData: case SymTagData:
if (((const struct symt_data*)type)->kind != DataIsMember || if (((const struct symt_data*)type)->kind != DataIsMember ||
!((const struct symt_data*)type)->u.s.length) !((const struct symt_data*)type)->u.s.length)
return FALSE; return FALSE;
X(DWORD) = ((const struct symt_data*)type)->u.s.length; X(DWORD64) = ((const struct symt_data*)type)->u.s.length;
break; break;
case SymTagArrayType: case SymTagArrayType:
if (!symt_get_info(((const struct symt_array*)type)->basetype, if (!symt_get_info(((const struct symt_array*)type)->basetype,
TI_GET_LENGTH, pInfo)) TI_GET_LENGTH, pInfo))
return FALSE; return FALSE;
X(DWORD) *= ((const struct symt_array*)type)->end - X(DWORD64) *= ((const struct symt_array*)type)->end -
((const struct symt_array*)type)->start + 1; ((const struct symt_array*)type)->start + 1;
break; break;
case SymTagPublicSymbol: case SymTagPublicSymbol:
X(DWORD) = ((const struct symt_public*)type)->size; X(DWORD64) = ((const struct symt_public*)type)->size;
break; break;
case SymTagTypedef: case SymTagTypedef:
return symt_get_info(((const struct symt_typedef*)type)->type, TI_GET_LENGTH, pInfo); return symt_get_info(((const struct symt_typedef*)type)->type, TI_GET_LENGTH, pInfo);
case SymTagThunk: case SymTagThunk:
X(DWORD) = ((const struct symt_thunk*)type)->size; X(DWORD64) = ((const struct symt_thunk*)type)->size;
break; break;
default: default:
FIXME("Unsupported sym-tag %s for get-length\n", FIXME("Unsupported sym-tag %s for get-length\n",

7
programs/winedbg/break.c
View File

@ -357,7 +357,7 @@ void break_check_delayed_bp(void)
static void break_add_watch(const struct dbg_lvalue* lvalue, BOOL is_write) static void break_add_watch(const struct dbg_lvalue* lvalue, BOOL is_write)
{ {
int num; int num;
DWORD l = 4; DWORD64 l = 4;
num = init_xpoint((is_write) ? be_xpoint_watch_write : be_xpoint_watch_read, num = init_xpoint((is_write) ? be_xpoint_watch_write : be_xpoint_watch_read,
&lvalue->addr); &lvalue->addr);
@ -371,13 +371,14 @@ static void break_add_watch(const struct dbg_lvalue* lvalue, BOOL is_write)
{ {
case 4: case 2: case 1: break; case 4: case 2: case 1: break;
default: default:
dbg_printf("Unsupported length (%lu) for watch-points, defaulting to 4\n", l); dbg_printf("Unsupported length (%s) for watch-points, defaulting to 4\n",
wine_dbgstr_longlong(l));
break; break;
} }
} }
else dbg_printf("Cannot get watch size, defaulting to 4\n"); else dbg_printf("Cannot get watch size, defaulting to 4\n");
} }
dbg_curr_process->bp[num].w.len = l - 1; dbg_curr_process->bp[num].w.len = (DWORD)l - 1;
if (!get_watched_value(num, &dbg_curr_process->bp[num].w.oldval)) if (!get_watched_value(num, &dbg_curr_process->bp[num].w.oldval))
{ {

10
programs/winedbg/expr.c
View File

@ -279,7 +279,7 @@ struct dbg_lvalue expr_eval(struct expr* exp)
struct dbg_lvalue exp1; struct dbg_lvalue exp1;
struct dbg_lvalue exp2; struct dbg_lvalue exp2;
unsigned int cexp[5]; unsigned int cexp[5];
DWORD scale1, scale2, scale3; DWORD64 scale1, scale2, scale3;
struct dbg_type type1, type2; struct dbg_type type1, type2;
DWORD tag; DWORD tag;
const struct dbg_internal_var* div; const struct dbg_internal_var* div;
@ -509,8 +509,8 @@ struct dbg_lvalue expr_eval(struct expr* exp)
types_get_info(&type2, TI_GET_LENGTH, &scale1); types_get_info(&type2, TI_GET_LENGTH, &scale1);
rtn.type = exp2.type; rtn.type = exp2.type;
} }
exp->un.binop.result = (types_extract_as_integer(&exp1) * scale1 + exp->un.binop.result = types_extract_as_integer(&exp1) * (DWORD)scale1 +
scale2 * types_extract_as_integer(&exp2)); (DWORD)scale2 * types_extract_as_integer(&exp2);
break; break;
case EXP_OP_SUB: case EXP_OP_SUB:
if (!types_get_info(&exp1.type, TI_GET_SYMTAG, &tag) || if (!types_get_info(&exp1.type, TI_GET_SYMTAG, &tag) ||
@ -541,8 +541,8 @@ struct dbg_lvalue expr_eval(struct expr* exp)
types_get_info(&type2, TI_GET_LENGTH, &scale1); types_get_info(&type2, TI_GET_LENGTH, &scale1);
rtn.type = exp2.type; rtn.type = exp2.type;
} }
exp->un.binop.result = (types_extract_as_integer(&exp1) * scale1 - exp->un.binop.result = (types_extract_as_integer(&exp1) * (DWORD)scale1 -
types_extract_as_integer(&exp2) * scale2) / scale3; types_extract_as_integer(&exp2) * (DWORD)scale2) / (DWORD)scale3;
break; break;
case EXP_OP_SEG: case EXP_OP_SEG:
rtn.type.id = dbg_itype_none; rtn.type.id = dbg_itype_none;

13
programs/winedbg/memory.c
View File

@ -119,9 +119,9 @@ BOOL memory_read_value(const struct dbg_lvalue* lvalue, DWORD size, void* result
BOOL memory_write_value(const struct dbg_lvalue* lvalue, DWORD size, void* value) BOOL memory_write_value(const struct dbg_lvalue* lvalue, DWORD size, void* value)
{ {
BOOL ret = TRUE; BOOL ret = TRUE;
DWORD os; DWORD64 os;
os = ~size; os = ~(DWORD64)size;
types_get_info(&lvalue->type, TI_GET_LENGTH, &os); types_get_info(&lvalue->type, TI_GET_LENGTH, &os);
assert(size == os); assert(size == os);
@ -287,6 +287,7 @@ static void print_typed_basic(const struct dbg_lvalue* lvalue)
long long int val_int; long long int val_int;
void* val_ptr; void* val_ptr;
long double val_real; long double val_real;
DWORD64 size64;
DWORD tag, size, count, bt; DWORD tag, size, count, bt;
struct dbg_type rtype; struct dbg_type rtype;
@ -297,13 +298,13 @@ static void print_typed_basic(const struct dbg_lvalue* lvalue)
switch (tag) switch (tag)
{ {
case SymTagBaseType: case SymTagBaseType:
if (!types_get_info(&lvalue->type, TI_GET_LENGTH, &size) || if (!types_get_info(&lvalue->type, TI_GET_LENGTH, &size64) ||
!types_get_info(&lvalue->type, TI_GET_BASETYPE, &bt)) !types_get_info(&lvalue->type, TI_GET_BASETYPE, &bt))
{ {
WINE_ERR("Couldn't get information\n"); WINE_ERR("Couldn't get information\n");
RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL); RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
} }
size = (DWORD)size64;
switch (bt) switch (bt)
{ {
case btInt: case btInt:
@ -343,14 +344,14 @@ static void print_typed_basic(const struct dbg_lvalue* lvalue)
rtype.module = lvalue->type.module; rtype.module = lvalue->type.module;
if (types_get_info(&rtype, TI_GET_SYMTAG, &tag) && tag == SymTagBaseType && if (types_get_info(&rtype, TI_GET_SYMTAG, &tag) && tag == SymTagBaseType &&
types_get_info(&rtype, TI_GET_BASETYPE, &bt) && bt == btChar && types_get_info(&rtype, TI_GET_BASETYPE, &bt) && bt == btChar &&
types_get_info(&rtype, TI_GET_LENGTH, &size)) types_get_info(&rtype, TI_GET_LENGTH, &size64))
{ {
char buffer[1024]; char buffer[1024];
if (!val_ptr) dbg_printf("0x0"); if (!val_ptr) dbg_printf("0x0");
else if (memory_get_string(dbg_curr_process, val_ptr, else if (memory_get_string(dbg_curr_process, val_ptr,
lvalue->cookie == DLV_TARGET, lvalue->cookie == DLV_TARGET,
size == 2, buffer, sizeof(buffer))) size64 == 2, buffer, sizeof(buffer)))
dbg_printf("\"%s\"", buffer); dbg_printf("\"%s\"", buffer);
else else
dbg_printf("*** invalid address %p ***", val_ptr); dbg_printf("*** invalid address %p ***", val_ptr);

4
programs/winedbg/symbol.c
View File

@ -444,8 +444,8 @@ void symbol_read_symtable(const char* filename, unsigned long offset)
enum dbg_line_status symbol_get_function_line_status(const ADDRESS* addr) enum dbg_line_status symbol_get_function_line_status(const ADDRESS* addr)
{ {
IMAGEHLP_LINE il; IMAGEHLP_LINE il;
DWORD disp, size; DWORD disp;
ULONG64 disp64, start; ULONG64 disp64, start, size;
DWORD lin = (DWORD)memory_to_linear_addr(addr); DWORD lin = (DWORD)memory_to_linear_addr(addr);
char buffer[sizeof(SYMBOL_INFO) + 256]; char buffer[sizeof(SYMBOL_INFO) + 256];
SYMBOL_INFO* sym = (SYMBOL_INFO*)buffer; SYMBOL_INFO* sym = (SYMBOL_INFO*)buffer;

71
programs/winedbg/types.c
View File

@ -39,6 +39,7 @@ long int types_extract_as_integer(const struct dbg_lvalue* lvalue)
{ {
long int rtn = 0; long int rtn = 0;
DWORD tag, size, bt; DWORD tag, size, bt;
DWORD64 size64;
if (lvalue->type.id == dbg_itype_none || if (lvalue->type.id == dbg_itype_none ||
!types_get_info(&lvalue->type, TI_GET_SYMTAG, &tag)) !types_get_info(&lvalue->type, TI_GET_SYMTAG, &tag))
@ -47,17 +48,18 @@ long int types_extract_as_integer(const struct dbg_lvalue* lvalue)
switch (tag) switch (tag)
{ {
case SymTagBaseType: case SymTagBaseType:
if (!types_get_info(&lvalue->type, TI_GET_LENGTH, &size) || if (!types_get_info(&lvalue->type, TI_GET_LENGTH, &size64) ||
!types_get_info(&lvalue->type, TI_GET_BASETYPE, &bt)) !types_get_info(&lvalue->type, TI_GET_BASETYPE, &bt))
{ {
WINE_ERR("Couldn't get information\n"); WINE_ERR("Couldn't get information\n");
RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL); RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
} }
if (size > sizeof(rtn)) if (size64 > sizeof(rtn))
{ {
WINE_ERR("Size too large (%lu)\n", size); WINE_ERR("Size too large (%s)\n", wine_dbgstr_longlong(size64));
return 0; return 0;
} }
size = (DWORD)size64;
/* FIXME: we have an ugly & non portable thing here !!! */ /* FIXME: we have an ugly & non portable thing here !!! */
if (!memory_read_value(lvalue, size, &rtn)) return 0; if (!memory_read_value(lvalue, size, &rtn)) return 0;
@ -144,8 +146,10 @@ BOOL types_deref(const struct dbg_lvalue* lvalue, struct dbg_lvalue* result)
static BOOL types_get_udt_element_lvalue(struct dbg_lvalue* lvalue, static BOOL types_get_udt_element_lvalue(struct dbg_lvalue* lvalue,
const struct dbg_type* type, long int* tmpbuf) const struct dbg_type* type, long int* tmpbuf)
{ {
DWORD offset, length, bitoffset; DWORD offset, bitoffset;
DWORD bt; DWORD bt;
DWORD64 length;
unsigned mask; unsigned mask;
types_get_info(type, TI_GET_TYPE, &lvalue->type.id); types_get_info(type, TI_GET_TYPE, &lvalue->type.id);
@ -166,7 +170,7 @@ static BOOL types_get_udt_element_lvalue(struct dbg_lvalue* lvalue,
* it in a temporary buffer so that we get it all right. * it in a temporary buffer so that we get it all right.
*/ */
if (!memory_read_value(lvalue, sizeof(*tmpbuf), tmpbuf)) return FALSE; if (!memory_read_value(lvalue, sizeof(*tmpbuf), tmpbuf)) return FALSE;
mask = 0xffffffff << length; mask = 0xffffffff << (DWORD)length;
*tmpbuf >>= bitoffset & 7; *tmpbuf >>= bitoffset & 7;
*tmpbuf &= ~mask; *tmpbuf &= ~mask;
@ -179,7 +183,7 @@ static BOOL types_get_udt_element_lvalue(struct dbg_lvalue* lvalue,
* we need to sign extend the number. * we need to sign extend the number.
*/ */
if (types_get_info(&lvalue->type, TI_GET_BASETYPE, &bt) && if (types_get_info(&lvalue->type, TI_GET_BASETYPE, &bt) &&
bt == btInt && (*tmpbuf & (1 << (length - 1)))) bt == btInt && (*tmpbuf & (1 << ((DWORD)length - 1))))
{ {
*tmpbuf |= mask; *tmpbuf |= mask;
} }
@ -247,7 +251,8 @@ BOOL types_udt_find_element(struct dbg_lvalue* lvalue, const char* name, long in
BOOL types_array_index(const struct dbg_lvalue* lvalue, int index, BOOL types_array_index(const struct dbg_lvalue* lvalue, int index,
struct dbg_lvalue* result) struct dbg_lvalue* result)
{ {
DWORD tag, length, count; DWORD tag, count;
DWORD64 length;
if (!types_get_info(&lvalue->type, TI_GET_SYMTAG, &tag)) if (!types_get_info(&lvalue->type, TI_GET_SYMTAG, &tag))
return FALSE; return FALSE;
@ -266,7 +271,7 @@ BOOL types_array_index(const struct dbg_lvalue* lvalue, int index,
types_get_info(&lvalue->type, TI_GET_TYPE, &result->type.id); types_get_info(&lvalue->type, TI_GET_TYPE, &result->type.id);
types_get_info(&result->type, TI_GET_LENGTH, &length); types_get_info(&result->type, TI_GET_LENGTH, &length);
memory_read_value(lvalue, sizeof(result->addr.Offset), &result->addr.Offset); memory_read_value(lvalue, sizeof(result->addr.Offset), &result->addr.Offset);
result->addr.Offset += index * length; result->addr.Offset += index * (DWORD)length;
break; break;
default: default:
assert(FALSE); assert(FALSE);
@ -370,7 +375,7 @@ void print_value(const struct dbg_lvalue* lvalue, char format, int level)
int i; int i;
DWORD tag; DWORD tag;
DWORD count; DWORD count;
DWORD size; DWORD64 size;
if (lvalue->type.id == dbg_itype_none) if (lvalue->type.id == dbg_itype_none)
{ {
@ -655,72 +660,72 @@ BOOL types_get_info(const struct dbg_type* type, IMAGEHLP_SYMBOL_TYPE_INFO ti, v
case dbg_itype_unsigned_int: case dbg_itype_unsigned_int:
switch (ti) switch (ti)
{ {
case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break; case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
case TI_GET_LENGTH: X(DWORD) = 4; break; case TI_GET_LENGTH: X(DWORD64) = 4; break;
case TI_GET_BASETYPE: X(DWORD) = btUInt; break; case TI_GET_BASETYPE: X(DWORD) = btUInt; break;
default: WINE_FIXME("unsupported %u for u-int\n", ti); return FALSE; default: WINE_FIXME("unsupported %u for u-int\n", ti); return FALSE;
} }
break; break;
case dbg_itype_signed_int: case dbg_itype_signed_int:
switch (ti) switch (ti)
{ {
case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break; case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
case TI_GET_LENGTH: X(DWORD) = 4; break; case TI_GET_LENGTH: X(DWORD64) = 4; break;
case TI_GET_BASETYPE: X(DWORD) = btInt; break; case TI_GET_BASETYPE: X(DWORD) = btInt; break;
default: WINE_FIXME("unsupported %u for s-int\n", ti); return FALSE; default: WINE_FIXME("unsupported %u for s-int\n", ti); return FALSE;
} }
break; break;
case dbg_itype_unsigned_short_int: case dbg_itype_unsigned_short_int:
switch (ti) switch (ti)
{ {
case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break; case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
case TI_GET_LENGTH: X(DWORD) = 2; break; case TI_GET_LENGTH: X(DWORD64) = 2; break;
case TI_GET_BASETYPE: X(DWORD) = btUInt; break; case TI_GET_BASETYPE: X(DWORD) = btUInt; break;
default: WINE_FIXME("unsupported %u for u-short int\n", ti); return FALSE; default: WINE_FIXME("unsupported %u for u-short int\n", ti); return FALSE;
} }
break; break;
case dbg_itype_signed_short_int: case dbg_itype_signed_short_int:
switch (ti) switch (ti)
{ {
case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break; case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
case TI_GET_LENGTH: X(DWORD) = 2; break; case TI_GET_LENGTH: X(DWORD64) = 2; break;
case TI_GET_BASETYPE: X(DWORD) = btInt; break; case TI_GET_BASETYPE: X(DWORD) = btInt; break;
default: WINE_FIXME("unsupported %u for s-short int\n", ti); return FALSE; default: WINE_FIXME("unsupported %u for s-short int\n", ti); return FALSE;
} }
break; break;
case dbg_itype_unsigned_char_int: case dbg_itype_unsigned_char_int:
switch (ti) switch (ti)
{ {
case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break; case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
case TI_GET_LENGTH: X(DWORD) = 1; break; case TI_GET_LENGTH: X(DWORD64) = 1; break;
case TI_GET_BASETYPE: X(DWORD) = btUInt; break; case TI_GET_BASETYPE: X(DWORD) = btUInt; break;
default: WINE_FIXME("unsupported %u for u-char int\n", ti); return FALSE; default: WINE_FIXME("unsupported %u for u-char int\n", ti); return FALSE;
} }
break; break;
case dbg_itype_signed_char_int: case dbg_itype_signed_char_int:
switch (ti) switch (ti)
{ {
case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break; case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
case TI_GET_LENGTH: X(DWORD) = 1; break; case TI_GET_LENGTH: X(DWORD64) = 1; break;
case TI_GET_BASETYPE: X(DWORD) = btInt; break; case TI_GET_BASETYPE: X(DWORD) = btInt; break;
default: WINE_FIXME("unsupported %u for s-char int\n", ti); return FALSE; default: WINE_FIXME("unsupported %u for s-char int\n", ti); return FALSE;
} }
break; break;
case dbg_itype_char: case dbg_itype_char:
switch (ti) switch (ti)
{ {
case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break; case TI_GET_SYMTAG: X(DWORD) = SymTagBaseType; break;
case TI_GET_LENGTH: X(DWORD) = 1; break; case TI_GET_LENGTH: X(DWORD64) = 1; break;
case TI_GET_BASETYPE: X(DWORD) = btChar; break; case TI_GET_BASETYPE: X(DWORD) = btChar; break;
default: WINE_FIXME("unsupported %u for char int\n", ti); return FALSE; default: WINE_FIXME("unsupported %u for char int\n", ti); return FALSE;
} }
break; break;
case dbg_itype_astring: case dbg_itype_astring:
switch (ti) switch (ti)
{ {
case TI_GET_SYMTAG: X(DWORD) = SymTagPointerType; break; case TI_GET_SYMTAG: X(DWORD) = SymTagPointerType; break;
case TI_GET_LENGTH: X(DWORD) = 4; break; case TI_GET_LENGTH: X(DWORD64) = 4; break;
case TI_GET_TYPE: X(DWORD) = dbg_itype_char; break; case TI_GET_TYPE: X(DWORD) = dbg_itype_char; break;
default: WINE_FIXME("unsupported %u for a string\n", ti); return FALSE; default: WINE_FIXME("unsupported %u for a string\n", ti); return FALSE;
} }
break; break;