STATIC void findRtnFromRow( sio_data *curr_sio, int row )
/*******************************************************/
{
file_info *curr_file;
rtn_info *curr_rtn;
cue_handle *ch;
sym_handle *sh;
int index;
mod_handle mh;
address addr;
index = 0;
ch = alloca( DIPHandleSize( HK_CUE ) );
curr_file = curr_sio->curr_file;
mh = curr_sio->curr_mod->mh;
if( LineCue( mh, curr_sio->curr_file->fid, row, 0, ch ) == SR_NONE ) {
if( LineCue( mh, curr_sio->curr_file->fid, 0, 0, ch ) == SR_NONE ) return;
}
sh = alloca( DIPHandleSize( HK_SYM ) );
addr = CueAddr( ch );
if( AddrSym( mh, addr, sh ) == SR_NONE ) return;
while( index < curr_file->rtn_count ) {
curr_rtn = curr_file->routine[index];
if( curr_rtn->sh != NULL
&& SymCmp( curr_rtn->sh, sh ) == 0 ) {
curr_sio->curr_rtn = curr_rtn;
break;
}
index++;
}
}
/*
* doFindSymbol
*/
BOOL doFindSymbol( ADDRESS *addr, syminfo *si, int getsrcinfo ) {
sym_handle *symhdl;
cue_handle *cue;
search_result sr;
location_list ll;
address dipaddr;
BOOL ret;
si->segnum = -1;
si->name[0] = 0;
if( !StatShowSymbols || curProcess == NULL ) {
return( FALSE );
}
symhdl = MemAlloc( DIPHandleSize( HK_SYM ) );
dipaddr.sect_id = 0;
dipaddr.indirect = FALSE;
dipaddr.mach.offset = addr->offset;
dipaddr.mach.segment = addr->seg;
sr = AddrSym( NO_MOD, dipaddr, symhdl );
switch( sr ) {
case SR_CLOSEST:
SymLocation( symhdl, NULL, &ll );
si->symoff = addr->offset - ll.e[0].u.addr.mach.offset;
break;
case SR_EXACT:
si->symoff = 0;
break;
case SR_NONE:
ret = FALSE;
break;
}
if( sr != SR_NONE ) {
SymName( symhdl, NULL, SN_OBJECT, si->name, MAX_SYM_NAME );
// SymName( symhdl, NULL, SN_SOURCE, si->name, MAX_SYM_NAME );
if( getsrcinfo ) {
cue = MemAlloc( DIPHandleSize( HK_CUE ) );
if( AddrCue( NO_MOD, dipaddr, cue ) == SR_NONE ) {
MemFree( cue );
ret = FALSE;
} else {
CueFile( cue, si->filename, MAX_FILE_NAME );
si->linenum = CueLine( cue );
MemFree( cue );
ret = TRUE;
}
}
}
MemFree( symhdl );
return( ret );
}
STATIC void resolveImageSamples( void )
/*************************************/
{
image_info *curr_image;
massgd_sample_addr **massgd_data;
mod_info *curr_mod;
file_info *curr_file;
rtn_info *curr_rtn;
address *addr;
sample_index_t tick_index;
mod_handle mh;
sym_handle *sh;
long int count;
int count2;
int count3;
int count4;
int index;
int index2;
sh = alloca( DIPHandleSize( HK_SYM ) );
massgd_data = CurrSIOData->massaged_sample;
tick_index = 1;
index = 0;
index2 = 0;
for( count = 0; count < CurrSIOData->number_massaged; ++count, ++index2 ) {
if( index2 > MAX_MASSGD_BUCKET_INDEX ) {
++index;
index2 = 0;
}
addr = massgd_data[index][index2].raw;
if( AddrMod( *addr, &mh ) == SR_NONE ) {
curr_image = AddrImage( addr );
if( curr_image == NULL ) {
curr_image = CurrSIOData->images[0];
}
curr_mod = curr_image->module[0];
curr_rtn = curr_mod->mod_file[0]->routine[0];
} else {
curr_image = *(image_info **)ImageExtra( mh );
curr_mod = findCurrMod( curr_image, mh );
if( AddrSym( mh, *addr, sh ) == SR_NONE ) {
curr_rtn = curr_mod->mod_file[0]->routine[0];
} else {
curr_rtn = findCurrRtn( curr_mod, sh );
/**/ myassert( curr_rtn != NULL );
}
}
if( curr_rtn != NULL ) {
curr_rtn->tick_count += massgd_data[index][index2].hits;
if( curr_rtn->first_tick_index == 0 ) {
curr_rtn->first_tick_index = tick_index;
if( curr_mod->first_tick_index == 0
|| curr_mod->first_tick_index > tick_index ) {
curr_mod->first_tick_index = tick_index;
}
}
curr_rtn->last_tick_index = tick_index;
}
tick_index++;
}
CurrSIOData->max_time = 0;
count = 0;
while( count < CurrSIOData->image_count ) {
curr_image = CurrSIOData->images[count];
curr_image->max_time = 0;
count2 = 0;
while( count2 < curr_image->mod_count ) {
curr_mod = curr_image->module[count2];
curr_mod->max_time = 0;
count3 = 0;
while( count3 < curr_mod->file_count ) {
curr_file = curr_mod->mod_file[count3];
curr_rtn = curr_file->routine[0];
if( curr_rtn->unknown_routine && curr_rtn->tick_count == 0 ) {
curr_rtn->ignore_unknown_rtn = true;
curr_file->ignore_unknown_rtn = true;
}
curr_file->max_time = 0;
count4 = 0;
while( count4 < curr_file->rtn_count ) {
curr_rtn = curr_file->routine[count4];
curr_file->agg_count += curr_rtn->tick_count;
if( curr_rtn->tick_count > curr_file->max_time ) {
curr_file->max_time = curr_rtn->tick_count;
}
count4++;
}
curr_mod->agg_count += curr_file->agg_count;
if( curr_file->agg_count > curr_mod->max_time ) {
curr_mod->max_time = curr_file->agg_count;
}
count3++;
}
curr_file = curr_mod->mod_file[0];
if( curr_file->unknown_file && curr_file->agg_count == 0 ) {
curr_file->ignore_unknown_file = true;
curr_mod->ignore_unknown_file = true;
}
curr_image->agg_count += curr_mod->agg_count;
if( curr_mod->agg_count > curr_image->max_time ) {
curr_image->max_time = curr_mod->agg_count;
}
count2++;
}
curr_mod = curr_image->module[0];
if( curr_mod->unknown_module && curr_mod->agg_count == 0 ) {
curr_mod->ignore_unknown_mod = true;
curr_image->ignore_unknown_mod = true;
}
if( curr_image->agg_count > CurrSIOData->max_time ) {
CurrSIOData->max_time = curr_image->agg_count;
}
count++;
}
curr_image = CurrSIOData->images[0];
if( curr_image->unknown_image && curr_image->agg_count == 0 ) {
curr_image->ignore_unknown_image = true;
}
}
