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

dbghelp: Compiland and source files are not the same thing. 

- in MSC debug info parsing, clearly separate a source file
  information from a compiland (including in linetab structure)
- in ELF debug info parsing, now storing compiland directly
  in symtab_elt while browsing the symtab section (we still
  create twice the compilands, once in stabs/dwarf parsing, 
  a second time in symtab parsing)
This commit is contained in:
Eric Pouech 2006-03-18 13:32:31 +01:00 committed by Alexandre Julliard
parent a1a54e7bf7
commit c0e0de6c4e
3 changed files with 62 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
dlls/dbghelp/elf_module.c
View File

@ -118,7 +118,7 @@ struct symtab_elt
{ {
struct hash_table_elt ht_elt; struct hash_table_elt ht_elt;
const Elf32_Sym* symp; const Elf32_Sym* symp;
const char* filename; struct symt_compiland* compiland;
unsigned used; unsigned used;
}; };
@ -251,14 +251,14 @@ static void elf_unmap_file(struct elf_file_map* fmap)
* *
* creating an internal hash table to ease use ELF symtab information lookup * creating an internal hash table to ease use ELF symtab information lookup
*/ */
static void elf_hash_symtab(const struct module* module, struct pool* pool, static void elf_hash_symtab(struct module* module, struct pool* pool,
struct hash_table* ht_symtab, struct elf_file_map* fmap, struct hash_table* ht_symtab, struct elf_file_map* fmap,
int symtab_idx, struct thunk_area* thunks) int symtab_idx, struct thunk_area* thunks)
{ {
int i, j, nsym; int i, j, nsym;
const char* strp; const char* strp;
const char* symname; const char* symname;
const char* filename = NULL; struct symt_compiland* compiland = NULL;
const char* ptr; const char* ptr;
const Elf32_Sym* symp; const Elf32_Sym* symp;
struct symtab_elt* ste; struct symtab_elt* ste;
@ -289,7 +289,7 @@ static void elf_hash_symtab(const struct module* module, struct pool* pool,
if (ELF32_ST_TYPE(symp->st_info) == STT_FILE) if (ELF32_ST_TYPE(symp->st_info) == STT_FILE)
{ {
filename = symname; compiland = symname ? symt_new_compiland(module, symname) : NULL;
continue; continue;
} }
for (j = 0; thunks[j].symname; j++) for (j = 0; thunks[j].symname; j++)
@ -331,7 +331,7 @@ static void elf_hash_symtab(const struct module* module, struct pool* pool,
} }
} }
ste->symp = symp; ste->symp = symp;
ste->filename = filename; ste->compiland = compiland;
ste->used = 0; ste->used = 0;
hash_table_add(ht_symtab, &ste->ht_elt); hash_table_add(ht_symtab, &ste->ht_elt);
} }
@ -377,22 +377,24 @@ static const Elf32_Sym* elf_lookup_symtab(const struct module* module,
if (ste->used || strcmp(ste->ht_elt.name, name)) continue; if (ste->used || strcmp(ste->ht_elt.name, name)) continue;
weak_result = ste; weak_result = ste;
if ((ste->filename && !compiland_name) || (!ste->filename && compiland_name)) if ((ste->compiland && !compiland_name) || (!ste->compiland && compiland_name))
continue; continue;
if (ste->filename && compiland_name) if (ste->compiland && compiland_name)
{ {
if (strcmp(ste->filename, compiland_name)) const char* filename = source_get(module, ste->compiland->source);
if (strcmp(filename, compiland_name))
{ {
base = strrchr(ste->filename, '/'); base = strrchr(filename, '/');
if (!base++) base = ste->filename; if (!base++) base = filename;
if (strcmp(base, compiland_basename)) continue; if (strcmp(base, compiland_basename)) continue;
} }
} }
if (result) if (result)
{ {
FIXME("Already found symbol %s (%s) in symtab %s @%08x and %s @%08x\n", FIXME("Already found symbol %s (%s) in symtab %s @%08x and %s @%08x\n",
name, compiland_name, result->filename, result->symp->st_value, name, compiland_name,
ste->filename, ste->symp->st_value); source_get(module, result->compiland->source), result->symp->st_value,
source_get(module, ste->compiland->source), ste->symp->st_value);
} }
else else
{ {
@ -496,8 +498,6 @@ static int elf_new_wine_thunks(struct module* module, struct hash_table* ht_symt
unsigned num_areas, struct thunk_area* thunks) unsigned num_areas, struct thunk_area* thunks)
{ {
int j; int j;
struct symt_compiland* compiland = NULL;
const char* compiland_name = NULL;
struct hash_table_iter hti; struct hash_table_iter hti;
struct symtab_elt* ste; struct symtab_elt* ste;
DWORD addr; DWORD addr;
@ -508,16 +508,6 @@ static int elf_new_wine_thunks(struct module* module, struct hash_table* ht_symt
{ {
if (ste->used) continue; if (ste->used) continue;
/* FIXME: this is not a good idea anyway... we are creating several
* compiland objects for a same compilation unit
* We try to cache the last compiland used, but it's not enough
* (we should here only create compilands if they are not yet
* defined)
*/
if (!compiland_name || compiland_name != ste->filename)
compiland = symt_new_compiland(module,
compiland_name = ste->filename);
addr = module->elf_info->elf_addr + ste->symp->st_value; addr = module->elf_info->elf_addr + ste->symp->st_value;
for (j = 0; j < num_areas; j++) for (j = 0; j < num_areas; j++)
@ -528,7 +518,7 @@ static int elf_new_wine_thunks(struct module* module, struct hash_table* ht_symt
} }
if (j < num_areas) /* thunk found */ if (j < num_areas) /* thunk found */
{ {
symt_new_thunk(module, compiland, ste->ht_elt.name, thunks[j].ordinal, symt_new_thunk(module, ste->compiland, ste->ht_elt.name, thunks[j].ordinal,
addr, ste->symp->st_size); addr, ste->symp->st_size);
} }
else else
@ -548,11 +538,11 @@ static int elf_new_wine_thunks(struct module* module, struct hash_table* ht_symt
switch (ELF32_ST_TYPE(ste->symp->st_info)) switch (ELF32_ST_TYPE(ste->symp->st_info))
{ {
case STT_FUNC: case STT_FUNC:
symt_new_function(module, compiland, ste->ht_elt.name, symt_new_function(module, ste->compiland, ste->ht_elt.name,
addr, ste->symp->st_size, NULL); addr, ste->symp->st_size, NULL);
break; break;
case STT_OBJECT: case STT_OBJECT:
symt_new_global_variable(module, compiland, ste->ht_elt.name, symt_new_global_variable(module, ste->compiland, ste->ht_elt.name,
ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL, ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL,
addr, ste->symp->st_size, NULL); addr, ste->symp->st_size, NULL);
break; break;
@ -605,8 +595,6 @@ static int elf_new_wine_thunks(struct module* module, struct hash_table* ht_symt
*/ */
static int elf_new_public_symbols(struct module* module, struct hash_table* symtab) static int elf_new_public_symbols(struct module* module, struct hash_table* symtab)
{ {
struct symt_compiland* compiland = NULL;
const char* compiland_name = NULL;
struct hash_table_iter hti; struct hash_table_iter hti;
struct symtab_elt* ste; struct symtab_elt* ste;
@ -617,17 +605,7 @@ static int elf_new_public_symbols(struct module* module, struct hash_table* symt
hash_table_iter_init(symtab, &hti, NULL); hash_table_iter_init(symtab, &hti, NULL);
while ((ste = hash_table_iter_up(&hti))) while ((ste = hash_table_iter_up(&hti)))
{ {
/* FIXME: this is not a good idea anyway... we are creating several symt_new_public(module, ste->compiland, ste->ht_elt.name,
* compiland objects for a same compilation unit
* We try to cache the last compiland used, but it's not enough
* (we should here only create compilands if they are not yet
* defined)
*/
if (!compiland_name || compiland_name != ste->filename)
compiland = symt_new_compiland(module,
compiland_name = ste->filename);
symt_new_public(module, compiland, ste->ht_elt.name,
module->elf_info->elf_addr + ste->symp->st_value, module->elf_info->elf_addr + ste->symp->st_value,
ste->symp->st_size, TRUE /* FIXME */, ste->symp->st_size, TRUE /* FIXME */,
ELF32_ST_TYPE(ste->symp->st_info) == STT_FUNC); ELF32_ST_TYPE(ste->symp->st_info) == STT_FUNC);

74
dlls/dbghelp/msc.c
View File

@ -987,7 +987,7 @@ static struct codeview_linetab* codeview_snarf_linetab(struct module* module,
union any_size pnt2; union any_size pnt2;
const struct startend* start; const struct startend* start;
int this_seg; int this_seg;
struct symt_compiland* compiland; unsigned source;
/* /*
* Now get the important bits. * Now get the important bits.
@ -1048,17 +1048,17 @@ static struct codeview_linetab* codeview_snarf_linetab(struct module* module,
p_fn = (const struct p_string*)(start + file_segcount); p_fn = (const struct p_string*)(start + file_segcount);
memset(filename, 0, sizeof(filename)); memset(filename, 0, sizeof(filename));
memcpy(filename, p_fn->name, p_fn->namelen); memcpy(filename, p_fn->name, p_fn->namelen);
compiland = symt_new_compiland(module, filename); source = source_new(module, filename);
} }
else else
compiland = symt_new_compiland(module, (const char*)(start + file_segcount)); source = source_new(module, (const char*)(start + file_segcount));
for (k = 0; k < file_segcount; k++, this_seg++) for (k = 0; k < file_segcount; k++, this_seg++)
{ {
pnt2.uc = linetab + lt_ptr[k]; pnt2.uc = linetab + lt_ptr[k];
lt_hdr[this_seg].start = start[k].start; lt_hdr[this_seg].start = start[k].start;
lt_hdr[this_seg].end = start[k].end; lt_hdr[this_seg].end = start[k].end;
lt_hdr[this_seg].compiland = compiland; lt_hdr[this_seg].source = source;
lt_hdr[this_seg].segno = *pnt2.s++; lt_hdr[this_seg].segno = *pnt2.s++;
lt_hdr[this_seg].nline = *pnt2.s++; lt_hdr[this_seg].nline = *pnt2.s++;
lt_hdr[this_seg].offtab = pnt2.ui; lt_hdr[this_seg].offtab = pnt2.ui;
@ -1134,7 +1134,7 @@ static void codeview_add_func_linenum(struct module* module,
{ {
if (linetab->offtab[i] >= offset && linetab->offtab[i] < offset + size) if (linetab->offtab[i] >= offset && linetab->offtab[i] < offset + size)
{ {
symt_add_func_line(module, func, linetab->compiland->source, symt_add_func_line(module, func, linetab->source,
linetab->linetab[i], linetab->offtab[i] - offset); linetab->linetab[i], linetab->offtab[i] - offset);
} }
} }
@ -1150,6 +1150,7 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root
struct symt_block* block = NULL; struct symt_block* block = NULL;
struct symt* symt; struct symt* symt;
const char* name; const char* name;
struct symt_compiland* compiland = NULL;
/* /*
* Loop over the different types of records and whenever we * Loop over the different types of records and whenever we
@ -1170,9 +1171,7 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root
*/ */
case S_GDATA_V1: case S_GDATA_V1:
case S_LDATA_V1: case S_LDATA_V1:
flt = codeview_get_linetab(linetab, sym->data_v1.segment, sym->data_v1.offset); symt_new_global_variable(msc_dbg->module, compiland,
symt_new_global_variable(msc_dbg->module,
flt ? flt->compiland : NULL,
terminate_string(&sym->data_v1.p_name), sym->generic.id == S_LDATA_V1, terminate_string(&sym->data_v1.p_name), sym->generic.id == S_LDATA_V1,
codeview_get_address(msc_dbg, sym->data_v1.segment, sym->data_v1.offset), codeview_get_address(msc_dbg, sym->data_v1.segment, sym->data_v1.offset),
0, 0,
@ -1180,10 +1179,9 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root
break; break;
case S_GDATA_V2: case S_GDATA_V2:
case S_LDATA_V2: case S_LDATA_V2:
flt = codeview_get_linetab(linetab, sym->data_v2.segment, sym->data_v2.offset);
name = terminate_string(&sym->data_v2.p_name); name = terminate_string(&sym->data_v2.p_name);
if (name) if (name)
symt_new_global_variable(msc_dbg->module, flt ? flt->compiland : NULL, symt_new_global_variable(msc_dbg->module, compiland,
name, sym->generic.id == S_LDATA_V2, name, sym->generic.id == S_LDATA_V2,
codeview_get_address(msc_dbg, sym->data_v2.segment, sym->data_v2.offset), codeview_get_address(msc_dbg, sym->data_v2.segment, sym->data_v2.offset),
0, 0,
@ -1191,9 +1189,8 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root
break; break;
case S_GDATA_V3: case S_GDATA_V3:
case S_LDATA_V3: case S_LDATA_V3:
flt = codeview_get_linetab(linetab, sym->data_v3.segment, sym->data_v3.offset);
if (*sym->data_v3.name) if (*sym->data_v3.name)
symt_new_global_variable(msc_dbg->module, flt ? flt->compiland : NULL, symt_new_global_variable(msc_dbg->module, compiland,
sym->data_v3.name, sym->data_v3.name,
sym->generic.id == S_LDATA_V3, sym->generic.id == S_LDATA_V3,
codeview_get_address(msc_dbg, sym->data_v3.segment, sym->data_v3.offset), codeview_get_address(msc_dbg, sym->data_v3.segment, sym->data_v3.offset),
@ -1204,8 +1201,7 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root
case S_PUB_V1: /* FIXME is this really a 'data_v1' structure ?? */ case S_PUB_V1: /* FIXME is this really a 'data_v1' structure ?? */
if (!(dbghelp_options & SYMOPT_NO_PUBLICS)) if (!(dbghelp_options & SYMOPT_NO_PUBLICS))
{ {
flt = codeview_get_linetab(linetab, sym->data_v1.segment, sym->data_v1.offset); symt_new_public(msc_dbg->module, compiland,
symt_new_public(msc_dbg->module, flt ? flt->compiland : NULL,
terminate_string(&sym->data_v1.p_name), terminate_string(&sym->data_v1.p_name),
codeview_get_address(msc_dbg, sym->data_v1.segment, sym->data_v1.offset), codeview_get_address(msc_dbg, sym->data_v1.segment, sym->data_v1.offset),
1, TRUE /* FIXME */, TRUE /* FIXME */); 1, TRUE /* FIXME */, TRUE /* FIXME */);
@ -1214,8 +1210,7 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root
case S_PUB_V2: /* FIXME is this really a 'data_v2' structure ?? */ case S_PUB_V2: /* FIXME is this really a 'data_v2' structure ?? */
if (!(dbghelp_options & SYMOPT_NO_PUBLICS)) if (!(dbghelp_options & SYMOPT_NO_PUBLICS))
{ {
flt = codeview_get_linetab(linetab, sym->data_v2.segment, sym->data_v2.offset); symt_new_public(msc_dbg->module, compiland,
symt_new_public(msc_dbg->module, flt ? flt->compiland : NULL,
terminate_string(&sym->data_v2.p_name), terminate_string(&sym->data_v2.p_name),
codeview_get_address(msc_dbg, sym->data_v2.segment, sym->data_v2.offset), codeview_get_address(msc_dbg, sym->data_v2.segment, sym->data_v2.offset),
1, TRUE /* FIXME */, TRUE /* FIXME */); 1, TRUE /* FIXME */, TRUE /* FIXME */);
@ -1228,15 +1223,13 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root
* a PLT slot in the normal jargon that everyone else uses. * a PLT slot in the normal jargon that everyone else uses.
*/ */
case S_THUNK_V1: case S_THUNK_V1:
flt = codeview_get_linetab(linetab, sym->thunk_v1.segment, sym->thunk_v1.offset); symt_new_thunk(msc_dbg->module, compiland,
symt_new_thunk(msc_dbg->module, flt ? flt->compiland : NULL,
terminate_string(&sym->thunk_v1.p_name), sym->thunk_v1.thtype, terminate_string(&sym->thunk_v1.p_name), sym->thunk_v1.thtype,
codeview_get_address(msc_dbg, sym->thunk_v1.segment, sym->thunk_v1.offset), codeview_get_address(msc_dbg, sym->thunk_v1.segment, sym->thunk_v1.offset),
sym->thunk_v1.thunk_len); sym->thunk_v1.thunk_len);
break; break;
case S_THUNK_V3: case S_THUNK_V3:
flt = codeview_get_linetab(linetab, sym->thunk_v3.segment, sym->thunk_v3.offset); symt_new_thunk(msc_dbg->module, compiland,
symt_new_thunk(msc_dbg->module, flt ? flt->compiland : NULL,
sym->thunk_v3.name, sym->thunk_v3.thtype, sym->thunk_v3.name, sym->thunk_v3.thtype,
codeview_get_address(msc_dbg, sym->thunk_v3.segment, sym->thunk_v3.offset), codeview_get_address(msc_dbg, sym->thunk_v3.segment, sym->thunk_v3.offset),
sym->thunk_v3.thunk_len); sym->thunk_v3.thunk_len);
@ -1249,8 +1242,7 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root
case S_LPROC_V1: case S_LPROC_V1:
flt = codeview_get_linetab(linetab, sym->proc_v1.segment, sym->proc_v1.offset); flt = codeview_get_linetab(linetab, sym->proc_v1.segment, sym->proc_v1.offset);
if (curr_func) FIXME("nested function\n"); if (curr_func) FIXME("nested function\n");
curr_func = symt_new_function(msc_dbg->module, curr_func = symt_new_function(msc_dbg->module, compiland,
flt ? flt->compiland : NULL,
terminate_string(&sym->proc_v1.p_name), terminate_string(&sym->proc_v1.p_name),
codeview_get_address(msc_dbg, sym->proc_v1.segment, sym->proc_v1.offset), codeview_get_address(msc_dbg, sym->proc_v1.segment, sym->proc_v1.offset),
sym->proc_v1.proc_len, sym->proc_v1.proc_len,
@ -1264,8 +1256,7 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root
case S_LPROC_V2: case S_LPROC_V2:
flt = codeview_get_linetab(linetab, sym->proc_v2.segment, sym->proc_v2.offset); flt = codeview_get_linetab(linetab, sym->proc_v2.segment, sym->proc_v2.offset);
if (curr_func) FIXME("nested function\n"); if (curr_func) FIXME("nested function\n");
curr_func = symt_new_function(msc_dbg->module, curr_func = symt_new_function(msc_dbg->module, compiland,
flt ? flt->compiland : NULL,
terminate_string(&sym->proc_v2.p_name), terminate_string(&sym->proc_v2.p_name),
codeview_get_address(msc_dbg, sym->proc_v2.segment, sym->proc_v2.offset), codeview_get_address(msc_dbg, sym->proc_v2.segment, sym->proc_v2.offset),
sym->proc_v2.proc_len, sym->proc_v2.proc_len,
@ -1279,8 +1270,7 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root
case S_LPROC_V3: case S_LPROC_V3:
flt = codeview_get_linetab(linetab, sym->proc_v3.segment, sym->proc_v3.offset); flt = codeview_get_linetab(linetab, sym->proc_v3.segment, sym->proc_v3.offset);
if (curr_func) FIXME("nested function\n"); if (curr_func) FIXME("nested function\n");
curr_func = symt_new_function(msc_dbg->module, curr_func = symt_new_function(msc_dbg->module, compiland,
flt ? flt->compiland : NULL,
sym->proc_v3.name, sym->proc_v3.name,
codeview_get_address(msc_dbg, sym->proc_v3.segment, sym->proc_v3.offset), codeview_get_address(msc_dbg, sym->proc_v3.segment, sym->proc_v3.offset),
sym->proc_v3.proc_len, sym->proc_v3.proc_len,
@ -1343,19 +1333,16 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root
} }
break; break;
/* FIXME: we should use this as a compiland, instead of guessing it on the fly */ case S_COMPILE_V1:
case S_COMPILAND_V1: TRACE("S-Compile-V1 %x %s\n",
TRACE("S-Compiland-V1e %x %s\n", sym->compile_v1.unknown, terminate_string(&sym->compile_v1.p_name));
sym->compiland_v1.unknown,
terminate_string(&sym->compiland_v1.p_name));
break; break;
case S_COMPILAND_V2: case S_COMPILE_V2:
TRACE("S-Compiland-V2 %s\n", TRACE("S-Compile-V2 %s\n", terminate_string(&sym->compile_v2.p_name));
terminate_string(&sym->compiland_v2.p_name));
if (TRACE_ON(dbghelp_msc)) if (TRACE_ON(dbghelp_msc))
{ {
const char* ptr1 = sym->compiland_v2.p_name.name + sym->compiland_v2.p_name.namelen; const char* ptr1 = sym->compile_v2.p_name.name + sym->compile_v2.p_name.namelen;
const char* ptr2; const char* ptr2;
while (*ptr1) while (*ptr1)
{ {
@ -1365,11 +1352,11 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root
} }
} }
break; break;
case S_COMPILAND_V3: case S_COMPILE_V3:
TRACE("S-Compiland-V3 %s\n", sym->compiland_v3.name); TRACE("S-Compile-V3 %s\n", sym->compile_v3.name);
if (TRACE_ON(dbghelp_msc)) if (TRACE_ON(dbghelp_msc))
{ {
const char* ptr1 = sym->compiland_v3.name + strlen(sym->compiland_v3.name); const char* ptr1 = sym->compile_v3.name + strlen(sym->compile_v3.name);
const char* ptr2; const char* ptr2;
while (*ptr1) while (*ptr1)
{ {
@ -1381,7 +1368,8 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root
break; break;
case S_OBJNAME_V1: case S_OBJNAME_V1:
TRACE("S-ObjName %.*s\n", ((const BYTE*)sym)[8], (const BYTE*)sym + 9); TRACE("S-ObjName %s\n", terminate_string(&sym->objname_v1.p_name));
compiland = symt_new_compiland(msc_dbg->module, terminate_string(&sym->objname_v1.p_name));
break; break;
case S_LABEL_V1: case S_LABEL_V1:
@ -1512,9 +1500,7 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root
case S_PUB_DATA_V3: case S_PUB_DATA_V3:
if (!(dbghelp_options & SYMOPT_NO_PUBLICS)) if (!(dbghelp_options & SYMOPT_NO_PUBLICS))
{ {
flt = codeview_get_linetab(linetab, sym->data_v3.segment, sym->data_v3.offset); symt_new_public(msc_dbg->module, compiland,
symt_new_public(msc_dbg->module,
flt ? flt->compiland : NULL,
sym->data_v3.name, sym->data_v3.name,
codeview_get_address(msc_dbg, sym->data_v3.segment, sym->data_v3.offset), codeview_get_address(msc_dbg, sym->data_v3.segment, sym->data_v3.offset),
1, FALSE /* FIXME */, FALSE); 1, FALSE /* FIXME */, FALSE);
@ -1524,9 +1510,7 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root
case S_PUB_FUNC2_V3: /* using a data_v3 isn't what we'd expect */ case S_PUB_FUNC2_V3: /* using a data_v3 isn't what we'd expect */
if (!(dbghelp_options & SYMOPT_NO_PUBLICS)) if (!(dbghelp_options & SYMOPT_NO_PUBLICS))
{ {
flt = codeview_get_linetab(linetab, sym->data_v3.segment, sym->data_v3.offset); symt_new_public(msc_dbg->module, compiland,
symt_new_public(msc_dbg->module,
flt ? flt->compiland : NULL,
sym->data_v3.name, sym->data_v3.name,
codeview_get_address(msc_dbg, sym->data_v3.segment, sym->data_v3.offset), codeview_get_address(msc_dbg, sym->data_v3.segment, sym->data_v3.offset),
1, TRUE /* FIXME */, TRUE); 1, TRUE /* FIXME */, TRUE);

22
dlls/dbghelp/mscvpdb.h
View File

@ -1080,13 +1080,21 @@ union codeview_symbol
char name[1]; char name[1];
} udt_v3; } udt_v3;
struct
{
short int len;
short int id;
char signature[4];
struct p_string p_name;
} objname_v1;
struct struct
{ {
short int len; short int len;
short int id; short int id;
unsigned int unknown; unsigned int unknown;
struct p_string p_name; struct p_string p_name;
} compiland_v1; } compile_v1;
struct struct
{ {
@ -1095,7 +1103,7 @@ union codeview_symbol
unsigned unknown1[4]; unsigned unknown1[4];
unsigned short unknown2; unsigned short unknown2;
struct p_string p_name; struct p_string p_name;
} compiland_v2; } compile_v2;
struct struct
{ {
@ -1103,10 +1111,10 @@ union codeview_symbol
short int id; short int id;
unsigned int unknown; unsigned int unknown;
char name[1]; char name[1];
} compiland_v3; } compile_v3;
}; };
#define S_COMPILAND_V1 0x0001 #define S_COMPILE_V1 0x0001
#define S_REGISTER_V1 0x0002 #define S_REGISTER_V1 0x0002
#define S_CONSTANT_V1 0x0003 #define S_CONSTANT_V1 0x0003
#define S_UDT_V1 0x0004 #define S_UDT_V1 0x0004
@ -1160,9 +1168,9 @@ union codeview_symbol
#if 0 #if 0
#define S_XXXXXXXXX_32 0x1012 /* seems linked to a function, content unknown */ #define S_XXXXXXXXX_32 0x1012 /* seems linked to a function, content unknown */
#endif #endif
#define S_COMPILAND_V2 0x1013 #define S_COMPILE_V2 0x1013
#define S_COMPILAND_V3 0x1101 #define S_COMPILE_V3 0x1101
#define S_THUNK_V3 0x1102 #define S_THUNK_V3 0x1102
#define S_BLOCK_V3 0x1103 #define S_BLOCK_V3 0x1103
#define S_LABEL_V3 0x1105 #define S_LABEL_V3 0x1105
@ -1203,7 +1211,7 @@ struct codeview_linetab
unsigned int segno; unsigned int segno;
unsigned int start; unsigned int start;
unsigned int end; unsigned int end;
struct symt_compiland* compiland; unsigned int source;
const unsigned short* linetab; const unsigned short* linetab;
const unsigned int* offtab; const unsigned int* offtab;
}; };