Lines Matching refs:di
115 /* Find 'di' in the debugInfo_list and move it one step closer the the
120 static void move_DebugInfo_one_step_forward ( DebugInfo* di )
123 if (di == debugInfo_list)
125 vg_assert(di != NULL);
130 if (di0 == NULL || di0 == di) break;
135 vg_assert(di0 == di);
138 /* di0 points to di, di1 to its predecessor, and di2 to di1's
174 DebugInfo* di;
178 di = ML_(dinfo_zalloc)("di.debuginfo.aDI.1", sizeof(DebugInfo));
179 di->handle = handle_counter++;
180 di->fsm.filename = ML_(dinfo_strdup)("di.debuginfo.aDI.2", filename);
181 di->fsm.maps = VG_(newXA)(
182 ML_(dinfo_zalloc), "di.debuginfo.aDI.3",
190 di->trace_symtab = VG_(clo_trace_symtab);
191 di->trace_cfi = VG_(clo_trace_cfi);
192 di->ddump_syms = VG_(clo_debug_dump_syms);
193 di->ddump_line = VG_(clo_debug_dump_line);
194 di->ddump_frames = VG_(clo_debug_dump_frames);
197 return di;
202 static void free_DebugInfo ( DebugInfo* di )
209 vg_assert(di != NULL);
210 if (di->fsm.maps) VG_(deleteXA)(di->fsm.maps);
211 if (di->fsm.filename) ML_(dinfo_free)(di->fsm.filename);
212 if (di->soname) ML_(dinfo_free)(di->soname);
213 if (di->loctab) ML_(dinfo_free)(di->loctab);
214 if (di->cfsi) ML_(dinfo_free)(di->cfsi);
215 if (di->cfsi_exprs) VG_(deleteXA)(di->cfsi_exprs);
216 if (di->fpo) ML_(dinfo_free)(di->fpo);
218 if (di->symtab) {
221 n = di->symtab_used;
223 DiSym* sym = &di->symtab[i];
228 ML_(dinfo_free)(di->symtab);
231 for (chunk = di->strchunks; chunk != NULL; chunk = next) {
239 if (di->admin_tyents) {
240 n = VG_(sizeXA)(di->admin_tyents);
242 ent = (TyEnt*)VG_(indexXA)(di->admin_tyents, i);
246 VG_(deleteXA)(di->admin_tyents);
247 di->admin_tyents = NULL;
250 if (di->admin_gexprs) {
251 n = VG_(sizeXA)(di->admin_gexprs);
253 gexpr = *(GExpr**)VG_(indexXA)(di->admin_gexprs, i);
256 VG_(deleteXA)(di->admin_gexprs);
257 di->admin_gexprs = NULL;
264 if (di->varinfo) {
265 for (i = 0; i < VG_(sizeXA)(di->varinfo); i++) {
266 OSet* scope = *(OSet**)VG_(indexXA)(di->varinfo, i);
288 VG_(deleteXA)(di->varinfo);
291 ML_(dinfo_free)(di);
299 static void discard_DebugInfo ( DebugInfo* di )
307 if (curr == di) {
313 di->text_avma,
314 di->text_avma + di->text_size,
439 DebugInfo* di;
444 for (di = debugInfo_list; di; di = di->next) {
445 di->mark = do_DebugInfos_overlap( di, diRef );
446 if (di == diRef) {
447 vg_assert(di->mark);
448 di->mark = False;
460 DebugInfo* di;
462 for (di = debugInfo_list; di; di = di->next) {
463 vg_assert(di->fsm.filename);
464 if (0==VG_(strcmp)(di->fsm.filename, filename))
467 if (!di) {
468 di = alloc_DebugInfo(filename);
469 vg_assert(di);
470 di->next = debugInfo_list;
471 debugInfo_list = di;
473 return di;
477 /* Debuginfo reading for 'di' has just been successfully completed.
481 static void check_CFSI_related_invariants ( DebugInfo* di )
487 vg_assert(di);
491 vg_assert(di->fsm.have_rx_map);
492 vg_assert(di->fsm.have_rw_map);
493 for (i = 0; i < VG_(sizeXA)(di->fsm.maps); i++) {
494 struct _DebugInfoMapping* map = VG_(indexXA)(di->fsm.maps, i);
510 if (di2 == di)
523 if (di->cfsi) {
524 vg_assert(di->cfsi_minavma <= di->cfsi_maxavma); /* duh! */
527 if (di->cfsi_minavma >= map->avma &&
528 di->cfsi_maxavma < map->avma + map->size)
535 vg_assert(di->cfsi == NULL);
540 if (di->cfsi)
544 if (di->cfsi) {
545 vg_assert(di->cfsi_used > 0);
546 vg_assert(di->cfsi_size > 0);
547 for (i = 0; i < di->cfsi_used; i++) {
548 DiCfSI* cfsi = &di->cfsi[i];
550 vg_assert(cfsi->base >= di->cfsi_minavma);
551 vg_assert(cfsi->base + cfsi->len - 1 <= di->cfsi_maxavma);
553 DiCfSI* cfsip = &di->cfsi[i-1];
558 vg_assert(di->cfsi_used == 0);
559 vg_assert(di->cfsi_size == 0);
608 static ULong di_notify_ACHIEVE_ACCEPT_STATE ( struct _DebugInfo* di )
613 vg_assert(di->fsm.filename);
617 TRACE_SYMTAB("------ name = %s\n", di->fsm.filename);
624 discard_DebugInfos_which_overlap_with( di );
628 ok = ML_(read_elf_debug_info)( di );
630 ok = ML_(read_macho_debug_info)( di );
642 ML_(canonicaliseTables)( di );
645 VG_(redir_notify_new_DebugInfo)( di );
647 di->have_dinfo = True;
648 tl_assert(di->handle > 0);
649 di_handle = di->handle;
653 check_CFSI_related_invariants(di);
661 vg_assert(di->have_dinfo == False);
665 TRACE_SYMTAB("------ name = %s\n", di->fsm.filename);
697 DebugInfo* di;
891 di = find_or_create_DebugInfo_for( filename );
892 vg_assert(di);
902 VG_(addToXA)(di->fsm.maps, &map);
905 di->fsm.have_rx_map |= is_rx_map;
906 di->fsm.have_rw_map |= is_rw_map;
907 di->fsm.have_ro_map |= is_ro_map;
910 if (di->fsm.have_rx_map && di->fsm.have_rw_map && !di->have_dinfo) {
914 return di_notify_ACHIEVE_ACCEPT_STATE ( di );
975 DebugInfo* di;
978 for (di = debugInfo_list; di; di = di->next) {
979 vg_assert(di->fsm.filename);
980 if (di->have_dinfo)
982 if (!di->fsm.have_ro_map)
984 if (di->fsm.have_rx_map)
986 if (!di->fsm.have_rw_map)
989 for (i = 0; i < VG_(sizeXA)(di->fsm.maps); i++) {
990 map = (struct _DebugInfoMapping*)VG_(indexXA)(di->fsm.maps, i);
1000 if (di == NULL)
1005 vg_assert(di->fsm.have_ro_map);
1008 di->fsm.have_rx_map = True;
1009 di->fsm.have_ro_map = False;
1011 for (i = 0; i < VG_(sizeXA)(di->fsm.maps); i++) {
1012 map = (struct _DebugInfoMapping*)VG_(indexXA)(di->fsm.maps, i);
1014 di->fsm.have_ro_map = True;
1020 if (di->fsm.have_rx_map && di->fsm.have_rw_map && !di->have_dinfo) {
1022 = di_notify_ACHIEVE_ACCEPT_STATE( di );
1109 HChar* mashed = ML_(dinfo_zalloc)("di.debuginfo.dnpdi.1", mashedSzB);
1121 HChar* mashed = ML_(dinfo_zalloc)("di.debuginfo.dnpdi.2", mashedSzB);
1143 pdbname = ML_(dinfo_zalloc)("di.debuginfo.lpd1", sz_exename+5);
1233 { DebugInfo* di = find_or_create_DebugInfo_for(exename);
1235 /* this di must be new, since we just nuked any old stuff in the range */
1236 vg_assert(di && !di->fsm.have_rx_map && !di->fsm.have_rw_map);
1237 vg_assert(!di->have_dinfo);
1239 /* don't set up any of the di-> fields; let
1241 ML_(read_pdb_debug_info)( di, avma_obj, bias_obj,
1245 vg_assert(di->have_dinfo); // fails if PDB read failed
1252 di->symtab_used, di->loctab_used, di->fpo_size);
1271 DebugInfo *di, *di2;
1272 di = debugInfo_list;
1273 while (di) {
1274 di2 = di->next;
1275 VG_(printf)("XXX rm %p\n", di);
1276 free_DebugInfo( di );
1277 di = di2;
1282 struct _DebugInfoMapping* ML_(find_rx_mapping) ( struct _DebugInfo* di,
1289 if ( di->last_rx_map
1290 && lo >= di->last_rx_map->avma
1291 && hi < di->last_rx_map->avma + di->last_rx_map->size)
1292 return di->last_rx_map;
1294 for (i = 0; i < VG_(sizeXA)(di->fsm.maps); i++) {
1295 struct _DebugInfoMapping* map = VG_(indexXA)(di->fsm.maps, i);
1298 di->last_rx_map = map;
1324 DebugInfo* di;
1327 for (di = debugInfo_list; di != NULL; di = di->next) {
1333 inRange = di->fsm.have_rx_map
1334 && (ML_(find_rx_mapping)(di, ptr, ptr) != NULL);
1336 inRange = (di->data_present
1337 && di->data_size > 0
1338 && di->data_avma <= ptr
1339 && ptr < di->data_avma + di->data_size)
1341 (di->sdata_present
1342 && di->sdata_size > 0
1343 && di->sdata_avma <= ptr
1344 && ptr < di->sdata_avma + di->sdata_size)
1346 (di->bss_present
1347 && di->bss_size > 0
1348 && di->bss_avma <= ptr
1349 && ptr < di->bss_avma + di->bss_size)
1351 (di->sbss_present
1352 && di->sbss_size > 0
1353 && di->sbss_avma <= ptr
1354 && ptr < di->sbss_avma + di->sbss_size)
1356 (di->rodata_present
1357 && di->rodata_size > 0
1358 && di->rodata_avma <= ptr
1359 && ptr < di->rodata_avma + di->rodata_size);
1365 di, ptr, match_anywhere_in_sym, findText );
1368 *pdi = di;
1384 DebugInfo* di;
1385 for (di = debugInfo_list; di != NULL; di = di->next) {
1386 if (di->text_present
1387 && di->text_size > 0
1388 && di->text_avma <= ptr
1389 && ptr < di->text_avma + di->text_size) {
1390 lno = ML_(search_one_loctab) ( di, ptr );
1393 *pdi = di;
1416 DebugInfo* di;
1420 search_all_symtabs ( a, &di, &sno, match_anywhere_in_sym, findText );
1421 if (di == NULL)
1424 vg_assert(di->symtab[sno].pri_name);
1426 di->symtab[sno].pri_name, buf, nbuf );
1438 offset = a - di->symtab[sno].addr;
1631 DebugInfo* di;
1637 for (di = debugInfo_list; di != NULL; di = di->next) {
1638 if (di->text_present
1639 && di->text_size > 0
1640 && di->text_avma <= a
1641 && a < di->text_avma + di->text_size) {
1642 VG_(strncpy_safely)(buf, di->fsm.filename, nbuf);
1665 DebugInfo* di;
1667 for (di = debugInfo_list; di != NULL; di = di->next) {
1668 if (di->text_present
1669 && di->text_size > 0
1670 && di->text_avma <= a
1671 && a < di->text_avma + di->text_size) {
1673 move_DebugInfo_one_step_forward( di );
1674 return di;
2139 DebugInfo* di;
2148 for (di = debugInfo_list; di != NULL; di = di->next) {
2154 if (di->cfsi_used == 0)
2156 if (ip < di->cfsi_minavma || ip > di->cfsi_maxavma)
2160 j = ML_(search_one_cfitab)( di, ip );
2161 vg_assert(j >= -1 && j < (Word)di->cfsi_used);
2178 /* ensure that di is 4-aligned (at least), so it can't possibly
2180 vg_assert(di && VG_IS_4_ALIGNED(di));
2181 vg_assert(i >= 0 && i < di->cfsi_used);
2182 *diP = di;
2193 /* Move di one step closer to the start of the list. */
2194 move_DebugInfo_one_step_forward( di );
2211 Each cache entry binds an ip value to a (di, ix) pair. Possible
2214 di is non-null, ix >= 0 ==> cache slot in use, "di->cfsi[ix]"
2215 di is (DebugInfo*)1 ==> cache slot in use, no associated di
2216 di is NULL ==> cache slot not in use
2232 struct { Addr ip; DebugInfo* di; Word ix; }
2252 if (LIKELY(ce->ip == ip) && LIKELY(ce->di != NULL)) {
2258 find_DiCfSI( &ce->di, &ce->ix, ip );
2261 if (UNLIKELY(ce->di == (DebugInfo*)1)) {
2274 DebugInfo* di, DiCfSI* cfsi )
2338 ML_(ppCfiExpr)(di->cfsi_exprs, cfsi->cfa_off);
2345 cfa = evalCfiExpr(di->cfsi_exprs, cfsi->cfa_off, &eec, &ok );
2362 DebugInfo* di;
2370 di = ce->di;
2371 cfsi = &di->cfsi[ ce->ix ];
2381 min_accessible, max_accessible, di, cfsi);
2389 min_accessible, max_accessible, di, cfsi);
2412 DebugInfo* di;
2436 di = ce->di;
2437 cfsi = &di->cfsi[ ce->ix ];
2441 ML_(ppDiCfSI)(di->cfsi_exprs, cfsi);
2448 min_accessible, max_accessible, di, cfsi);
2475 ML_(ppCfiExpr)(di->cfsi_exprs,_off); \
2480 _prev = evalCfiExpr(di->cfsi_exprs, _off, &eec, &ok ); \
2533 DebugInfo* di;
2543 for (di = debugInfo_list; di != NULL; di = di->next) {
2548 if (di->fpo == NULL)
2550 if (*ipP < di->fpo_minavma || *ipP > di->fpo_maxavma)
2553 i = ML_(search_one_fpotab)( di, *ipP );
2559 *ipP, di->fpo_size, i);
2560 for (j = 0; j < di->fpo_size; j++)
2562 j, di->fpo[j].ulOffStart, di->fpo[j].cbProcSize);
2564 vg_assert(i >= 0 && i < di->fpo_size);
2565 fpo = &di->fpo[i];
2587 //move_DebugInfo_one_step_forward( di );
2677 const DebugInfo* di )
2714 res = ML_(evaluate_GX)( var->gexpr, var->fbGX, regs, di );
3041 DebugInfo* di;
3051 for (di = debugInfo_list; di; di = di->next) {
3054 if (!di->text_present || di->text_size == 0)
3057 if (di->text_avma <= ip && ip < di->text_avma + di->text_size)
3064 if (!di)
3077 move_DebugInfo_one_step_forward( di );
3082 if (!di->varinfo)
3095 for (i = VG_(sizeXA)(di->varinfo) - 1; i >= 1; i--) {
3100 = *(OSet**)VG_(indexXA)( di->varinfo, i );
3135 if (data_address_is_in_var( &offset, di->admin_tyents,
3137 data_addr, di )) {
3140 di->admin_tyents,
3180 DebugInfo* di;
3191 for (di = debugInfo_list; di != NULL; di = di->next) {
3200 if (!di->text_present || di->text_size == 0)
3203 if (!di->varinfo)
3206 if (VG_(sizeXA)( di->varinfo ) == 0)
3208 global_scope = *(OSet**)VG_(indexXA)( di->varinfo, 0 );
3243 if (data_address_is_in_var( &offset, di->admin_tyents, var,
3245 data_addr, di )) {
3248 di->admin_tyents,
3377 Addr ip, const DebugInfo* di, DiVariable* var,
3422 res_sp_6k = ML_(evaluate_GX)( var->gexpr, var->fbGX, ®s, di );
3427 res_sp_7k = ML_(evaluate_GX)( var->gexpr, var->fbGX, ®s, di );
3432 res_fp_6k = ML_(evaluate_GX)( var->gexpr, var->fbGX, ®s, di );
3437 res_fp_7k = ML_(evaluate_GX)( var->gexpr, var->fbGX, ®s, di );
3459 res = ML_(evaluate_GX)( var->gexpr, var->fbGX, ®s, di );
3478 res = ML_(evaluate_GX)( var->gexpr, var->fbGX, ®s, di );
3510 DebugInfo* di;
3513 XArray* res = VG_(newXA)( ML_(dinfo_zalloc), "di.debuginfo.dgsbai.1",
3523 for (di = debugInfo_list; di; di = di->next) {
3526 if (!di->text_present || di->text_size == 0)
3529 if (di->text_avma <= ip && ip < di->text_avma + di->text_size)
3536 if (!di)
3549 move_DebugInfo_one_step_forward( di );
3554 if (!di->varinfo)
3564 for (i = VG_(sizeXA)(di->varinfo) - 1; i >= 1; i--) {
3569 = *(OSet**)VG_(indexXA)( di->varinfo, i );
3603 analyse_deps( res, di->admin_tyents, ip,
3604 di, var, arrays_only );
3625 DebugInfo* di;
3632 for (di = debugInfo_list; di; di = di->next) {
3633 if (di->handle == di_handle)
3640 tl_assert(di != NULL);
3643 gvars = VG_(newXA)( ML_(dinfo_zalloc), "di.debuginfo.dggbfd.1",
3648 if (!di->varinfo)
3654 nScopes = VG_(sizeXA)( di->varinfo );
3660 = *(OSet**)VG_(indexXA)( di->varinfo, scopeIx );
3687 res = ML_(evaluate_trivial_GX)( var->gexpr, di );
3700 mul = ML_(sizeOfType)(di->admin_tyents, var->typeR);
3713 ty = ML_(TyEnts__index_by_cuOff)( di->admin_tyents, NULL,
3725 tl_assert(di->soname);
3734 VG_(strncpy)(&gb.soname[0], di->soname, sizeof(gb.soname)-1);
3754 const DebugInfo* VG_(next_DebugInfo)(const DebugInfo* di)
3756 if (di == NULL)
3758 return di->next;
3761 Addr VG_(DebugInfo_get_text_avma)(const DebugInfo* di)
3763 return di->text_present ? di->text_avma : 0;
3766 SizeT VG_(DebugInfo_get_text_size)(const DebugInfo* di)
3768 return di->text_present ? di->text_size : 0;
3771 Addr VG_(DebugInfo_get_plt_avma)(const DebugInfo* di)
3773 return di->plt_present ? di->plt_avma : 0;
3776 SizeT VG_(DebugInfo_get_plt_size)(const DebugInfo* di)
3778 return di->plt_present ? di->plt_size : 0;
3781 Addr VG_(DebugInfo_get_gotplt_avma)(const DebugInfo* di)
3783 return di->gotplt_present ? di->gotplt_avma : 0;
3786 SizeT VG_(DebugInfo_get_gotplt_size)(const DebugInfo* di)
3788 return di->gotplt_present ? di->gotplt_size : 0;
3791 const UChar* VG_(DebugInfo_get_soname)(const DebugInfo* di)
3793 return di->soname;
3796 const UChar* VG_(DebugInfo_get_filename)(const DebugInfo* di)
3798 return di->fsm.filename;
3801 PtrdiffT VG_(DebugInfo_get_text_bias)(const DebugInfo* di)
3803 return di->text_present ? di->text_bias : 0;
3861 DebugInfo* di;
3864 for (di = debugInfo_list; di != NULL; di = di->next) {
3868 "addr=%#lx di=%p %s got=%#lx,%ld plt=%#lx,%ld "
3870 a, di, di->fsm.filename,
3871 di->got_avma, di->got_size,
3872 di->plt_avma, di->plt_size,
3873 di->data_avma, di->data_size,
3874 di->bss_avma, di->bss_size);
3876 if (di->text_present
3877 && di->text_size > 0
3878 && a >= di->text_avma && a < di->text_avma + di->text_size) {
3882 if (di->data_present
3883 && di->data_size > 0
3884 && a >= di->data_avma && a < di->data_avma + di->data_size) {
3888 if (di->sdata_present
3889 && di->sdata_size > 0
3890 && a >= di->sdata_avma && a < di->sdata_avma + di->sdata_size) {
3894 if (di->bss_present
3895 && di->bss_size > 0
3896 && a >= di->bss_avma && a < di->bss_avma + di->bss_size) {
3900 if (di->sbss_present
3901 && di->sbss_size > 0
3902 && a >= di->sbss_avma && a < di->sbss_avma + di->sbss_size) {
3906 if (di->plt_present
3907 && di->plt_size > 0
3908 && a >= di->plt_avma && a < di->plt_avma + di->plt_size) {
3912 if (di->got_present
3913 && di->got_size > 0
3914 && a >= di->got_avma && a < di->got_avma + di->got_size) {
3918 if (di->gotplt_present
3919 && di->gotplt_size > 0
3920 && a >= di->gotplt_avma && a < di->gotplt_avma + di->gotplt_size) {
3924 if (di->opd_present
3925 && di->opd_size > 0
3926 && a >= di->opd_avma && a < di->opd_avma + di->opd_size) {
3933 vg_assert( (di == NULL && res == Vg_SectUnknown)
3934 || (di != NULL && res != Vg_SectUnknown) );
3940 if (di && di->fsm.filename) {
3942 Int fnlen = VG_(strlen)(di->fsm.filename);
3950 name[j] = di->fsm.filename[i];
3951 if (di->fsm.filename[i] == 0) break;
