1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Reads rom symbol file and provides interface to acquire

    15 *               binary and function information using memory addresss.

    16 *

    17 */

    18 

    19 #include "../inc/ATCommonDefines.h"

    20 #include "../inc/catromsymbol.h"

    21 #include "../inc/catfilereader.h"

    22 #include "../inc/CATBase.h"

    23 #include "../inc/CATMemoryAddress.h"

    24 

    25 // -----------------------------------------------------------------------------

    26 // RofsBinary::RofsBinary

    27 // Default construcor

    28 // -----------------------------------------------------------------------------

    29 RofsBinary::RofsBinary()

    30 {

    31 	LOG_LOW_FUNC_ENTRY("RofsBinary::RofsBinary");

    32 	m_sBinary = "";

    33 	vSymbols.clear();

    34 }

    35 

    36 // -----------------------------------------------------------------------------

    37 // RofsBinary::RofsBinary

    38 // Construcor

    39 // -----------------------------------------------------------------------------

    40 RofsBinary::RofsBinary( const string& sBinary )

    41 {

    42 	LOG_LOW_FUNC_ENTRY("RofsBinary::RofsBinary");

    43 	m_sBinary = sBinary;

    44 	vSymbols.clear();

    45 }

    46 

    47 // -----------------------------------------------------------------------------

    48 // RofsBinary::~RofsBinary

    49 // Destructor

    50 // -----------------------------------------------------------------------------

    51 RofsBinary::~RofsBinary()

    52 {

    53 	LOG_LOW_FUNC_ENTRY("RofsBinary::~RofsBinary");

    54 	for ( vector<Symbol*>::iterator it = vSymbols.begin() ; it != vSymbols.end() ; it++ )

    55 		delete *it;

    56 	vSymbols.clear();

    57 }

    58 

    59 // -----------------------------------------------------------------------------

    60 // CATRomSymbol::CATRomSymbol

    61 // Constructor.

    62 // -----------------------------------------------------------------------------

    63 CATRomSymbol::CATRomSymbol()

    64 {

    65 	LOG_FUNC_ENTRY("CATRomSymbol::CATRomSymbol");

    66 	m_bSymbolsRead = false;

    67 	m_iRomEndAddress = 0;

    68 	m_iRomStartAddress = 0;

    69 	m_vRomFiles.clear();

    70 	m_sErrorMessage = "";

    71 	m_vRomCache.clear();

    72 	m_vRomSymbols.clear();

    73 	m_bShowProgressMessages = false;

    74 }

    75 

    76 // -----------------------------------------------------------------------------

    77 // CATRomSymbol::~CATRomSymbol

    78 // Destructor.

    79 // -----------------------------------------------------------------------------

    80 CATRomSymbol::~CATRomSymbol()

    81 {

    82 	LOG_FUNC_ENTRY("CATRomSymbol::~CATRomSymbol");

    83 	// Rom

    84 	for ( vector<Symbol*>::iterator it = m_vRomSymbols.begin() ; it != m_vRomSymbols.end() ; it++ )

    85 	{

    86 		delete *it;

    87 	}

    88 	m_vRomSymbols.clear();

    89 	// Rofs

    90 	for ( vector<RofsBinary*>::iterator it = m_vRofsBinaries.begin() ; it != m_vRofsBinaries.end() ; it++ )

    91 	{

    92 		delete *it;

    93 	}

    94 	m_vRofsBinaries.clear();

    95 }

    96 

    97 // -----------------------------------------------------------------------------

    98 // CATRomSymbol::Open

    99 // This funtion should not be used anymore since

   100 // we support multiple rom/rofs files.

   101 // -----------------------------------------------------------------------------

   102 bool CATRomSymbol::Open( const string& /*sString*/, const unsigned long /*iLong*/)

   103 {

   104 	LOG_FUNC_ENTRY("CATRomSymbol::Open");

   105 	return false;

   106 }

   107 

   108 // -----------------------------------------------------------------------------

   109 // CATRomSymbol::SetSymbols

   110 // Set symbol file(s) to be used.

   111 // This also checks that files exists and identifies them as rom/rofs.

   112 // -----------------------------------------------------------------------------

   113 bool CATRomSymbol::SetSymbols( const vector<string>& vSymbols )

   114 {

   115 	LOG_FUNC_ENTRY("CATRomSymbol::SetSymbols");

   116 	bool ok = true;

   117 	// Check no same symbol defined twice.

   118 	for( vector<string>::const_iterator it = vSymbols.begin() ;

   119 		it != vSymbols.end(); it++ )

   120 	{

   121 		for( vector<string>::const_iterator it2 = vSymbols.begin() ;

   122 			it2 != vSymbols.end(); it2++ )

   123 		{

   124 			if ( it == it2 )

   125 				continue;

   126 			if ( _stricmp( (*it).c_str(), (*it2).c_str() ) == 0 )

   127 			{

   128 				m_sErrorMessage.append( "Same symbol file defined twice (" );

   129 				m_sErrorMessage.append( (*it) );

   130 				m_sErrorMessage.append( ")\n" );

   131 				return false;

   132 			}

   133 		}

   134 	}

   135 	// Loop given symbol files.

   136 	for( vector<string>::const_iterator it = vSymbols.begin() ;

   137 		it != vSymbols.end(); it++ )

   138 	{

   139 		// Symbol file exists?

   140 		if ( ! CATBase::FileExists( (*it).c_str() ) )

   141 		{

   142 			ok = false;

   143 			m_sErrorMessage.append( "Symbol file does not exists (" );

   144 			m_sErrorMessage.append( *it );

   145 			m_sErrorMessage.append( ").\n");

   146 			continue;

   147 		}

   148 		// Identify symbol file.

   149 		int type = IdentifySymbolFile( *it );

   150 		// Depending on type move it correct vector.

   151 		switch( type )

   152 		{

   153 		case SYMBOL_FILE_INVALID:

   154 			ok = false;

   155 			m_sErrorMessage.append( "Symbol file with invalid content (" );

   156 			m_sErrorMessage.append( *it );

   157 			m_sErrorMessage.append( ").\n");

   158 			break;

   159 		case SYMBOL_FILE_ROM:

   160 			m_vRomFiles.push_back( *it );

   161 			break;

   162 		case SYMBOL_FILE_ROFS:

   163 			m_vRofsFiles.push_back( *it );

   164 			break;

   165 		default:

   166 			ok = false;

   167 			LOG_STRING("IdentifySymbolFile returned unknown type.");

   168 			break;

   169 		}

   170 	}

   171 	if ( ok )

   172 	{

   173 		// Read symbols.

   174 		if ( m_vRomFiles.size() > 0 )

   175 		{

   176 			if ( ! ReadRomFiles() )

   177 				ok = false;

   178 			else

   179 				m_bSymbolsRead = true;

   180 		}

   181 		if ( m_vRofsFiles.size() > 0 )

   182 		{

   183 			if ( ! ReadRofsFiles() )

   184 				ok = false;

   185 			else

   186 				m_bSymbolsRead = true;

   187 		}

   188 	}

   189 	return ok;

   190 }

   191 

   192 // -----------------------------------------------------------------------------

   193 // CATRomSymbol::IdentifySymbolFile

   194 // Identify given file is it rom / rofs.

   195 // -----------------------------------------------------------------------------

   196 int CATRomSymbol::IdentifySymbolFile( const string& sFile )

   197 {

   198 	LOG_FUNC_ENTRY("CATRomSymbol::IdentifySymbolFile");

   199 	// Set type as invalid.

   200 	int iType = SYMBOL_FILE_INVALID;

   201 	// Line counter.

   202 	int iLineCount = 0;

   203 	// Minimun line length to identify it.

   204 	size_t iLineMinLength = MAX_LINE_LENGTH;

   205 	if ( ROFS_SYMBOL_IDENTIFY_STRING.length() > ROM_SYMBOL_IDENTIFY_STRING.length() )

   206 		iLineMinLength = ROFS_SYMBOL_IDENTIFY_STRING.length();

   207 	else

   208 		iLineMinLength = ROM_SYMBOL_IDENTIFY_STRING.length();

   209 	try {

   210 		ifstream in;

   211 		in.open( sFile.c_str(), ios::in );

   212 		if ( ! in.good() )

   213 			return SYMBOL_FILE_INVALID;

   214 		char cLine[MAX_LINE_LENGTH];

   215 		do {

   216 			// Dont read too many lines. (File might be contain invalid data).

   217 			iLineCount++;

   218 			if ( iLineCount > IDENTIFY_MAX_LINES_READ )

   219 				break;

   220 

   221 			// Get line -> string.

   222 			in.getline( cLine, MAX_LINE_LENGTH );

   223 			string sLine(cLine);

   224 			

   225 			// Check its not too short.

   226 			if( sLine.length() < iLineMinLength )

   227 				continue;

   228 

   229 			// Take substring from start of line to identify it to rofs/rom.

   230 			if ( ! sLine.substr( 0, ROFS_SYMBOL_IDENTIFY_STRING.length() ).compare( ROFS_SYMBOL_IDENTIFY_STRING ) )

   231 			{

   232 				iType = SYMBOL_FILE_ROFS;

   233 				break;

   234 			}

   235 			else if ( ! sLine.substr( 0, ROM_SYMBOL_IDENTIFY_STRING.length() ).compare( ROM_SYMBOL_IDENTIFY_STRING ) )

   236 			{

   237 				iType = SYMBOL_FILE_ROM;

   238 				break;

   239 			}

   240 		} while ( in.good() );

   241 		in.close();

   242 	}

   243 	catch(...)

   244 	{

   245 		LOG_STRING("CATRomSymbol::IdentifySymbolFile unhandled exception.");

   246 	}

   247 	return iType;

   248 }

   249 

   250 // -----------------------------------------------------------------------------

   251 // CATRomSymbol::ReadRomFiles

   252 // Reads rom file(s) and creates symbols to vector.

   253 // -----------------------------------------------------------------------------

   254 bool CATRomSymbol::ReadRomFiles()

   255 {

   256 	LOG_FUNC_ENTRY("CATRomSymbol::ReadRomFile");

   257 

   258 	// Clear symbols.

   259 	for ( vector<Symbol*>::iterator it = m_vRomSymbols.begin() ; it != m_vRomSymbols.end() ; it++ )

   260 	{

   261 		delete *it;

   262 	}

   263 	m_vRomSymbols.clear();

   264 	

   265 	// Clear cache. note cache is just pointers dont delete them.

   266 	m_vRomCache.clear();

   267 

   268 	// Any errors?

   269 	bool ok = true;

   270 

   271 	for( vector<string>::iterator it = m_vRomFiles.begin();

   272 		it != m_vRomFiles.end() ; it++ )

   273 		ok = ReadRomFile( *it );

   274 	

   275 	// If size smaller than 1 it is not good rom file(s).

   276 	if ( m_vRomSymbols.size() < 1  || ok != true)

   277 		return false;

   278 

   279 	// Rom start and end addresses.

   280 	m_iRomStartAddress = (*m_vRomSymbols.begin())->iStartAddress;

   281 	m_iRomEndAddress = (*m_vRomSymbols.rbegin())->iEndAddress;

   282 	return true;

   283 }

   284 

   285 // -----------------------------------------------------------------------------

   286 // CATRomSymbol::ReadRofsFiles

   287 // Read rofs files.

   288 // -----------------------------------------------------------------------------

   289 bool CATRomSymbol::ReadRofsFiles()

   290 {

   291 	LOG_FUNC_ENTRY("CATRomSymbol::ReadRofsFiles");

   292 	// Clear.

   293 	for ( vector<RofsBinary*>::iterator it = m_vRofsBinaries.begin() ; it != m_vRofsBinaries.end() ; it++ )

   294 	{

   295 		delete *it;

   296 	}

   297 	m_vRofsBinaries.clear();

   298 	

   299 	// Any errors?

   300 	bool ok = true;

   301 

   302 	for( vector<string>::iterator it = m_vRofsFiles.begin();

   303 		it != m_vRofsFiles.end() ; it++ )

   304 		ok = ReadRofsFile( *it );

   305 	

   306 	// If size smaller than 1 it is not good rofs file(s).

   307 	if ( m_vRofsBinaries.size() < 1  || ok != true)

   308 		return false;

   309 	return true;

   310 }

   311 

   312 // -----------------------------------------------------------------------------

   313 // CATRomSymbol::ReadRomFile

   314 // Read given rom file

   315 // -----------------------------------------------------------------------------

   316 bool CATRomSymbol::ReadRomFile( const string& sFile )

   317 {

   318 	LOG_FUNC_ENTRY("CATRomSymbol::ReadRomfile");

   319 	// Open rom file.

   320 	CATFileReader* reader = new CATFileReader();

   321 	// Show progress message if flag set.

   322 	if ( m_bShowProgressMessages )

   323 		cout << AT_MSG << "Reading rom symbol file: " << sFile << "..." << endl;

   324 	if ( ! reader->Open( sFile.c_str() ) )

   325 	{

   326 		reader->Close();

   327 		delete reader;

   328 		return false;

   329 	}

   330 

   331 	// Show progress message if flag set.

   332 	if ( m_bShowProgressMessages )

   333 		cout << AT_MSG << "Parsing rom symbol file: " << sFile << "..." << endl;

   334 

   335 	// Loop thrue lines.

   336 	string sLine("");

   337 	string sBinary("");

   338 	while( reader->GetLine( sLine ) )

   339 	{

   340 		// From rom we just read symbols that have lenght, no need to separate them into diff binaries.

   341 		try {

   342 			if ( sLine.size() < 2 )

   343 			{

   344 				continue;

   345 			}

   346 			else if ( sLine.at(0) == '8' )

   347 			{

   348 				// Create new item.

   349 				Symbol* symbol = new Symbol();

   350 				ParseSymbolFromLine( sLine, symbol);

   351 				// Ignore symbols which have same start & end address (zero length).

   352 				if ( symbol->iStartAddress != symbol->iEndAddress )

   353 					m_vRomSymbols.push_back( symbol );

   354 				else

   355 					delete symbol;

   356 			}

   357 		} catch(...)

   358 		{

   359 			// Catch all possible exception here so analyze will succeed even rom file invalid.

   360 			m_sErrorMessage.append( "Unhandled exception parsing rom symbol file.\n" );

   361 			// Close and delete reader.

   362 			reader->Close();

   363 			delete reader;

   364 			return false;

   365 		}

   366 	}

   367 	// Close and delete reader.

   368 	reader->Close();

   369 	delete reader;

   370 	return true;

   371 }

   372 

   373 // -----------------------------------------------------------------------------

   374 // CATRomSymbol::ReadRofsFile

   375 // Read given rofs file

   376 // -----------------------------------------------------------------------------

   377 bool CATRomSymbol::ReadRofsFile( const string& sFile )

   378 {

   379 	LOG_FUNC_ENTRY("CATRomSymbol::ReadRofsFile");

   380 	// open/read rofs file.

   381 	CATFileReader* reader = new CATFileReader();

   382 	// Show progress message if flag set.

   383 	if ( m_bShowProgressMessages )

   384 		cout << AT_MSG << "Reading rofs symbol file: " << sFile << "..." << endl;

   385 	if ( ! reader->Open( sFile.c_str() ) )

   386 	{

   387 		reader->Close();

   388 		delete reader;

   389 		return false;

   390 	}

   391 

   392 	// Show progress message if flag set.

   393 	if ( m_bShowProgressMessages )

   394 		cout << AT_MSG << "Parsing rofs symbol file: " << sFile << "..." << endl;

   395 

   396 	// Loop thrue lines.

   397 	string sLine("");

   398 	string sBinary("");

   399 	RofsBinary* rb = NULL;

   400 	while( reader->GetLine( sLine ) )

   401 	{

   402 		try {

   403 			if ( sLine.size() < 2 )

   404 			{

   405 				continue;

   406 			}

   407 			else if ( sLine.at(0) == 'F' )

   408 			{

   409 				if ( rb != NULL )

   410 				{

   411 					// Check last binary if no symbols in it dont add it.

   412 					if ( rb->vSymbols.size() == 0 )

   413 					{

   414 						delete rb;

   415 						rb = NULL;

   416 					}

   417 					else

   418 						m_vRofsBinaries.push_back( rb );

   419 				}

   420 				// new binary name.

   421 				size_t i = sLine.rfind("\\");

   422 				sLine.erase(0, i+1);

   423 				rb = new RofsBinary( sLine );

   424 

   425 			}

   426 			else if ( sLine.at(0) == '0' )

   427 			{

   428 				// Cannot pickup symbols if no binary defined.

   429 				if ( rb == NULL )

   430 					continue;

   431 				// Create new item.

   432 				Symbol* symbol = new Symbol();

   433 				ParseSymbolFromLine( sLine, symbol);

   434 				// Ignore symbols which have same start & end address (zero length).

   435 				if ( symbol->iStartAddress != symbol->iEndAddress )

   436 					rb->vSymbols.push_back( symbol );

   437 				else

   438 					delete symbol;

   439 			}

   440 		} catch(...)

   441 		{

   442 			// Catch all possible exception here so analyze will succeed even rofs file invalid.

   443 			m_sErrorMessage.append( "Unhandled exception parsing rofs symbol file.\n" );

   444 			// Close and delete reader.

   445 			reader->Close();

   446 			delete reader;

   447 			return false;

   448 		}

   449 	}

   450 	// Last added binary.

   451 	if ( rb != NULL )

   452 	{

   453 		if ( rb->vSymbols.size() == 0 )

   454 		{

   455 			delete rb;

   456 			rb = NULL;

   457 		}

   458 		else

   459 			m_vRofsBinaries.push_back( rb );

   460 	}

   461 	// Close and delete reader.

   462 	reader->Close();

   463 	delete reader;

   464 	return true;

   465 }

   466 

   467 // -----------------------------------------------------------------------------

   468 // CATRomSymbol::ParseSymbolFromLine

   469 // Parses given line into given symbol.

   470 // -----------------------------------------------------------------------------

   471 void CATRomSymbol::ParseSymbolFromLine( const string& sLine, Symbol* pSymbol )

   472 {

   473 	LOG_LOW_FUNC_ENTRY("CATRomSymbol::ParseSymbolFromLine");

   474 	if ( pSymbol == NULL )

   475 		return;

   476 	size_t s,x;

   477 	string temp;

   478 	// address.

   479 	x = sLine.find( ' ' );

   480 	temp = sLine.substr( 0, x );

   481 	pSymbol->iStartAddress = CATBase::_httoi( temp.c_str() );

   482 	// "Erase spaces" move starting point.

   483 	s = x;

   484 	s = sLine.find_first_not_of( ' ', s );

   485 	// length.

   486 	x = sLine.find( ' ', s );

   487 	temp = sLine.substr(s,x-s);

   488 	unsigned long length = CATBase::_httoi( temp.c_str() );

   489 	pSymbol->iEndAddress = pSymbol->iStartAddress + length;

   490 	// "Erase spaces" move starting point.

   491 	s = x;

   492 	s = sLine.find_first_not_of( ' ', s);

   493 	// function. Function might have spaces so we find 2 spaces which indicates end of it.

   494 	x = sLine.find( "  ", s );

   495 	temp = sLine.substr( s, x-s );

   496 	pSymbol->sFunction = temp;

   497 }

   498 

   499 // -----------------------------------------------------------------------------

   500 // CATRomSymbol::GetError

   501 // Get error string if error occured in other methods.

   502 // -----------------------------------------------------------------------------

   503 string CATRomSymbol::GetError( void )

   504 {

   505 	LOG_FUNC_ENTRY("CATRomSymbol::GetError");

   506 	return m_sErrorMessage;

   507 }

   508 

   509 // -----------------------------------------------------------------------------

   510 // CATRomSymbol::Close

   511 // Close (stop using).

   512 // -----------------------------------------------------------------------------

   513 bool CATRomSymbol::Close( void )

   514 {

   515 	LOG_FUNC_ENTRY("CATRomSymbol::Close");

   516 	return true;

   517 }

   518 

   519 // -----------------------------------------------------------------------------

   520 // CATRomSymbol::AddressToLine

   521 // Try locate binary and function name for given memory address.

   522 // -----------------------------------------------------------------------------

   523 bool CATRomSymbol::AddressToLine( CATMemoryAddress* result )

   524 {

   525 	LOG_LOW_FUNC_ENTRY("CATRomSymbol::AddressToLine");

   526 	// Have symbols been read.

   527 	if ( ! m_bSymbolsRead )

   528 		return false;

   529 	// check that its lenght > 2

   530 	if ( result->GetAddressString().size() < 2 )

   531 		return false;

   532 	/* Check first is address in range of rom */

   533 	if ( result->GetAddress() < m_iRomStartAddress

   534 		|| result->GetAddress() > m_iRomEndAddress )

   535 	{

   536 		return AddressToLineRofs( result );		

   537 	}

   538 	return AddressToLineRom( result );

   539 }

   540 

   541 // -----------------------------------------------------------------------------

   542 // CATRomSymbol::AddressToLineRom

   543 // Locate function from rom address range.

   544 // -----------------------------------------------------------------------------

   545 bool CATRomSymbol::AddressToLineRom( CATMemoryAddress* result )

   546 {

   547 	LOG_LOW_FUNC_ENTRY( "CATRomSymbol::AddressToLineRom" );

   548 	// Address to find in integer & string.

   549 	unsigned long iAddressToFind = result->GetAddress();

   550 	string sAddressToFind = result->GetAddressString();

   551 	

   552 	// Find symbol.

   553 	Symbol* pFound = NULL;

   554 

   555 	// Check from cache first.

   556 	vector<Symbol*>::iterator it;

   557 	for ( it = m_vRomCache.begin(); it != m_vRomCache.end(); it++ )

   558 	{

   559 		if ( iAddressToFind >= (*it)->iStartAddress

   560 			&& (*it)->iEndAddress > iAddressToFind )

   561 		{

   562 			pFound = *it;

   563 			break;

   564 		}

   565 	}

   566 	

   567 	if ( pFound == NULL )

   568 	{

   569 		// From all symbols.

   570 		bool reverse = false;

   571 		int offSetFromStart = iAddressToFind - m_iRomStartAddress;

   572 		int offSetFromEnd = m_iRomEndAddress - iAddressToFind;

   573 		if ( offSetFromEnd < offSetFromStart ) 

   574 			reverse = true;

   575 		

   576 		if ( reverse )

   577 		{

   578 			// Iterate vector in reverse.

   579 			vector<Symbol*>::reverse_iterator it;

   580 			for ( it = m_vRomSymbols.rbegin(); it != m_vRomSymbols.rend(); ++it )

   581 			{

   582 				if ( iAddressToFind >= (*it)->iStartAddress

   583 					&& (*it)->iEndAddress > iAddressToFind )

   584 				{

   585 					pFound = *it;

   586 					break;

   587 				}

   588 			}

   589 		}

   590 		else

   591 		{

   592 			// Iterate vector normal direction.

   593 			vector<Symbol*>::iterator it;

   594 			for ( it = m_vRomSymbols.begin(); it != m_vRomSymbols.end(); it++ )

   595 			{

   596 				if ( iAddressToFind >= (*it)->iStartAddress

   597 					&& (*it)->iEndAddress > iAddressToFind )

   598 				{

   599 					pFound = *it;

   600 					break;

   601 				}

   602 			}

   603 		}

   604 	}

   605 

   606 	// Set result if found.

   607 	if ( pFound != NULL )

   608 	{

   609 		result->SetFunctionName( pFound->sFunction );

   610 		result->SetAddressToLineState( CATMemoryAddress::SYMBOL );

   611 		// Add found symbols pointer to cache.

   612 		m_vRomCache.push_back( pFound );

   613 		return true;

   614 	}

   615 	return false;

   616 }

   617 

   618 // -----------------------------------------------------------------------------

   619 // CATRomSymbol::AddressToLineRofs

   620 // Locate function from rofs address range.

   621 // -----------------------------------------------------------------------------

   622 bool CATRomSymbol::AddressToLineRofs( CATMemoryAddress* result)

   623 {

   624 	LOG_LOW_FUNC_ENTRY("CATRomSymbol::AddressToLineRofs");

   625 	// Check that binary name is defined in memory address.

   626 	string sBinary = result->GetModuleName();

   627 	if ( sBinary.empty() )

   628 		return false;

   629 	// Try find that named module.

   630 	vector<RofsBinary*>::iterator rofs = m_vRofsBinaries.begin();

   631 	while( rofs != m_vRofsBinaries.end() )

   632 	{

   633 		if ( (*rofs)->m_sBinary.compare( sBinary ) == 0 )

   634 			break;

   635 		rofs++;

   636 	}

   637 	if ( rofs == m_vRofsBinaries.end() )

   638 		return false;

   639 

   640 	// Offset what we are looking from binary

   641 	unsigned long offSet = result->GetAddress();

   642 	offSet -= result->GetModuleStartAddress();

   643 	for( vector<Symbol*>::iterator it = (*rofs)->vSymbols.begin() ;

   644 		it != (*rofs)->vSymbols.end(); it++ )

   645 	{

   646 		if ( (*it)->iStartAddress <= offSet && offSet < (*it)->iEndAddress )

   647 		{

   648 			result->SetFunctionName( (*it)->sFunction );

   649 			result->SetAddressToLineState( CATMemoryAddress::SYMBOL );

   650 			return true;

   651 		}

   652 	}

   653 	return false;

   654 }

   655 

   656 //EOF