?? coffloader.cpp
字號:
Tmem.Space = Space;
Tmem.Asize = M_SIZE16;
Tmem.Bsize = M_SIZE16;
Tmem.Length = Count;
Tmem.pData = pData;
if( m_pSdti_Intf->pMem->Write( m_Sdti_Hndl, &Tmem ) == FALSE )
return( FALSE );
return( TRUE );
}
/*F***************************************************************************
* NAME: ReadMemory( MEM_TADDR Addr, MEM_SPACE Space, TREG_16 *pData,
* DWORD Count )
*
* DESCRIPTION: Read 16 bit data to memory
*
*F***************************************************************************/
BOOL CoffLoader::ReadMemory( MEM_TADDR Addr,
MEM_SPACE Space,
TREG_16 * pData,
DWORD Count )
{
TMEM_DESC Tmem;
// Always test for connection to prevent user calling in disconnected
// state or with NULL handles.
if( CheckConnection() == FALSE ) {
return( FALSE );
}
Tmem.Taddr = Addr;
Tmem.Space = Space;
Tmem.Asize = M_SIZE16;
Tmem.Bsize = M_SIZE16;
Tmem.Length = Count;
Tmem.pData = pData;
if( m_pSdti_Intf->pMem->Read( m_Sdti_Hndl, &Tmem ) == FALSE )
return( FALSE );
return( TRUE );
}
/*F***************************************************************************
* NAME: ReadRegister( char * RegName, DWORD *pReg );
*
* DESCRIPTION: Read register
*
*F***************************************************************************/
BOOL CoffLoader::ReadRegister( char * RegName, DWORD *pReg )
{
TREG reg;
// Always test for connection to prevent user calling in disconnected
// state or with NULL handles.
if( CheckConnection() == FALSE ) {
return( FALSE );
}
if ( m_pSdti_Intf->pReg->ReadByName( m_Sdti_Hndl, RegName, ® ) == FALSE )
return( FALSE );
// We treat all registers as 32 bit values even though most are just
// 16 bit. The sdti code knows to do the right thing.
*pReg = reg.Reg32;
return( TRUE );
}
/*F***************************************************************************
* NAME: WriteRegister( char * RegName, DWORD *pReg );
*
* DESCRIPTION: Write register
*
*F***************************************************************************/
BOOL CoffLoader::WriteRegister( char * RegName, DWORD *pReg )
{
TREG reg;
// Always test for connection to prevent user calling in disconnected
// state or with NULL handles.
if( CheckConnection() == FALSE ) {
return( FALSE );
}
// We treat all registers as 32 bit values even though most are just
// 16 bit. The sdti code knows to do the right thing.
reg.Reg32 = *pReg;
if ( m_pSdti_Intf->pReg->WriteByName( m_Sdti_Hndl, RegName, ® ) == FALSE )
return( FALSE );
return( TRUE );
}
/*F***************************************************************************
* NAME: LoadCoff( )
*
* DESCRIPTION: Load coff file to the target and load it's symbol table.
*
*
*F***************************************************************************/
BOOL CoffLoader::LoadCoff( )
{
TREG reg;
CString entryPoint;
BOOL success = FALSE;
m_coffHndl = NULL;
// Always test for connection to prevent user calling in disconnected
// state or with NULL handles.
if( CheckConnection() == FALSE ) {
return( FALSE );
}
// Error checking of parameters
if ( ( !m_pSdti_Intf ) || ( !m_Sdti_Hndl ) )
return FALSE;
// Open the file and fetch all coff settings
if ( m_coffLib->COFFR_FileOpen( m_coffFileName, &m_coffOpts, &m_coffHndl ) )
{
ErrMsg( "ERROR \tFailed to Open Coff File." );
goto EXIT_COFF_LOAD;
}
// Build the symbol table
BuildSymbolTable();
// Load raw data onto processor memory
success = LoadRawData( );
if ( success )
{
reg.Reg32 = m_coffHndl->FileInfo->entry_point;
/* For string formatting purposes */
entryPoint.Format( "%x", reg.Reg32 );
if ( m_pSdti_Intf->pReg->WriteByName( m_Sdti_Hndl, "PC", ® ) == FALSE )
success = FALSE;
}
EXIT_COFF_LOAD:
// Close the coff file. This could be removed as we will cleanup
// in the destructor.
if ( m_coffHndl )
{
m_coffLib->COFFR_FileClose( m_coffHndl );
m_coffHndl = NULL;
}
return success;
}
/*F***************************************************************************
* NAME: LoadRawData( )
*
* DESCRIPTION: Load the raw coff data
*
*
*F***************************************************************************/
BOOL CoffLoader::LoadRawData( )
{
TI_SCNHDR* pSection_Hdr;
TMEM_DESC Tmem;
unsigned char* pCoff_Buffer;
long coff_buffer_size;
long total_byte_size,num_vals;
int num_sections;
short i;
BOOL success = TRUE;
CString sectionId;
CString entryPoint;
CString memAddress;
CString memLength;
// Always test for connection to prevent user calling in disconnected
// state or with NULL handles.
if( CheckConnection() == FALSE ) {
return( FALSE );
}
// Coff section size is in target bytes so convert to host bytes
coff_buffer_size = m_coffLib->LOCTOBYTE( m_coffHndl, m_coffHndl->FileInfo->largest_sect_size );
// Allocate memory for coff buffer
pCoff_Buffer = ( unsigned char* )new( char[coff_buffer_size] );
if ( ! pCoff_Buffer )
return FALSE;
// Pointer to section header
pSection_Hdr = ( TI_SCNHDR* )( m_coffHndl->FileInfo->sect_hdrs );
num_sections = m_coffHndl->FileInfo->file_hdr.f_nscns;
Message( "Loading COFF file.\r\n" );
Message( "Filename: " + m_coffFileName);
// For string formatting purposes
entryPoint.Format( "%x", m_coffHndl->FileInfo->entry_point );
while ( entryPoint.GetLength() < 8 )
entryPoint.Insert(0, "0");
Message( "File entry point: 0x" + entryPoint + "\r\n" );
// Go through each section to determine if it should be loaded
for ( i = 1 ; i <= num_sections ; i++, pSection_Hdr++ )
{
if ( m_coffLib->COFFR_IsLoadSection( m_coffHndl, i ) != COFF_NOLOADSECT_ERR )
{
m_coffLib->COFFR_GetSectData( m_coffHndl, ( short )i, pCoff_Buffer, 0,
m_coffLib->LOCTOBYTE( m_coffHndl, pSection_Hdr->s_size ),
&total_byte_size );
// Convert to target vals
num_vals = m_coffLib->BYTETOLOC(m_coffHndl,total_byte_size);
// Set parameters to write the section of the coff file
Tmem.Taddr = pSection_Hdr->s_vaddr;
Tmem.Space = ( pSection_Hdr->s_page == 0 ) ? M_PROGRAM : M_DATA;
Tmem.Asize = M_SIZE16;
Tmem.Bsize = M_SIZE8; // Our buffer is 8 bit chars for coff
Tmem.Length = num_vals;
Tmem.pData = ( void* )( pCoff_Buffer );
// Write data to memory
if ( ( success = m_pSdti_Intf->pMem->Write( m_Sdti_Hndl, &Tmem ) ) == FALSE )
break;
}/* End of COFFR_IsLoadSection */
}
if ( success == FALSE )
Message( "\t\t...FAILED." );
// Free coff buffer
delete( pCoff_Buffer );
return success;
}
/*F***************************************************************************
* NAME: BytesPerDataSize(struct SYMBOL * s)
*
* DESCRIPTION: Determine the number of bytes for a given symbol type. Just
* handles the easy cases.
*
*F***************************************************************************/
int CoffLoader::BytesPerDataSize(struct SYMBOL * s)
{
switch( s->symtype &0x0f )
{
case TI_T_LONG: /* LONG INTEGER */
case TI_T_ULONG: /* UNSIGNED LONG */
return( 4 );
// Not used in the programamer
case TI_T_FLOAT: /* SINGLE PRECISION FLOATING POINT */
case TI_T_DOUBLE: /* DOUBLE PRECISION FLOATING POINT */
case TI_T_STRUCT: /* STRUCTURE */
case TI_T_UNION: /* UNION */
case TI_T_ENUM: /* ENUMERATION */
case TI_T_LDOUBLE: /* LONG DOUBLE FLOATING POINT */
return( 0 );
case TI_T_VOID: /* VOID TYPE */
case TI_T_SCHAR: /* CHARACTER (EXPLICITLY "signed") */
case TI_T_CHAR: /* CHARACTER (IMPLICITLY SIGNED) */
case TI_T_SHORT: /* SHORT INTEGER */
case TI_T_INT: /* INTEGER */
case TI_T_UCHAR: /* UNSIGNED CHARACTER */
case TI_T_USHORT: /* UNSIGNED SHORT */
case TI_T_UINT: /* UNSIGNED INTEGER */
default:
return( 2 );
}
}
/*F***************************************************************************
* NAME: FindSymbol(char * name)
*
* DESCRIPTION: Search the symbol table for symbol name
*
*
*F***************************************************************************/
struct SYMBOL * CoffLoader::FindSymbol(char * name)
{
SYMBOL_L * n;
//Go through list from head to tail - if the name matches, return
n = m_symlist;
while (n != (SYMBOL_L *)NULL )
{
if( (strcmp(name, n->s->symname) == 0) // C name _Symbol
|| (strcmp(name+1, n->s->symname) == 0)) // asm name Symbol
break;
n = n->next;
}
if ( n!= (SYMBOL_L *)NULL )
return ( n->s );
return ((struct SYMBOL *)NULL );
}
/*F***************************************************************************
* NAME: DeleteSymbolList( void )
*
* DESCRIPTION: Delete the symbol table
*
*
*F***************************************************************************/
BOOL CoffLoader::DeleteSymbolList( void )
{
SYMBOL_L * n;
while (m_symlist != (SYMBOL_L *)NULL )
{
n = m_symlist->next;
delete(m_symlist->s->symname); m_symlist->s->symname = (char *)NULL;
delete(m_symlist->s); m_symlist->s = (struct SYMBOL *)NULL;
delete(m_symlist);
m_symlist = n;
}
return(TRUE);
}
/*F***************************************************************************
* NAME: BuildSymbolTable( void )
*
* DESCRIPTION: Build the symbol table. This is crude at best but does get
* job done for such a simple application.
*
*
*F***************************************************************************/
BOOL CoffLoader::BuildSymbolTable( void )
{
TI_SCNHDR * pSectionHdr;
long SymbolIndex;
COFF_SYMTYPE SymbolType;
TI_SYMENT SymbolEntry;
TI_AUXENT AuxEntry;
long NumSymbolsRead;
long NumSymbolsSaved = 0;
if( m_coffHndl == NULL )
return( FALSE );
// Unload old symbols before loading new symbols
if( m_symlist != NULL ) {
DeleteSymbolList();
}
// Load the string table first
m_coffLib->COFFR_LoadStrings( m_coffHndl );
SymbolIndex = 0;
NumSymbolsRead = 0;
while( SymbolIndex < m_coffHndl->FileInfo->file_hdr.f_nsyms )
{
m_coffLib->COFFR_GetSymbolTableEntry( m_coffHndl,
&SymbolIndex,
&SymbolType,
&SymbolEntry,
&AuxEntry );
switch( SymbolType )
{
case COFF_AUX_TAG:
SymbolIndex = AuxEntry.x_tag.x_endndx;
break;
case COFF_AUX_FILE:
case COFF_AUX_SECT:
case COFF_AUX_BB:
case COFF_AUX_EOS:
break;
default:
if( SymbolEntry.n_sclass == TI_C_EXT ) // The interesting symbols, globals
{
char name[256];
SYMBOL_L * new_list_elem;
struct SYMBOL * new_sym;
size_t name_length;
// Only load interesting symbols
if ( ( SymbolEntry.n_scnum < 1)
|| ( SymbolEntry.n_scnum > m_coffHndl->FileInfo->file_hdr.f_nscns))
break;
pSectionHdr = (TI_SCNHDR *)(m_coffHndl->FileInfo->sect_hdrs);
pSectionHdr += (SymbolEntry.n_scnum-1);
m_coffLib->COFFR_GetSymbolName( m_coffHndl, &SymbolEntry, 256, name );
// Allocate a new symbol, and new symbol list element. Add symbol to
// the head of the list
new_sym = (struct SYMBOL *)new( struct SYMBOL );
new_list_elem = (SYMBOL_L *)new( SYMBOL_L );
new_list_elem->s = new_sym;
new_list_elem->next = m_symlist; // New symbol at head of the list
m_symlist = new_list_elem;
// Fill in the name, address, and page info for the symbol.
name_length = (strlen(name)+1);
new_sym->symname = (char *)new( char[name_length]);
strcpy(new_sym->symname, name);
new_sym->symaddr = (unsigned long)(SymbolEntry.n_value);
new_sym->sympage = (unsigned long)(pSectionHdr->s_page);
new_sym->symtype = (unsigned long)(SymbolEntry.n_type );
new_sym->symsclass = (unsigned long)(SymbolEntry.n_sclass );
new_sym->symnumaux = (unsigned long)(SymbolEntry.n_numaux );
NumSymbolsSaved++;
} /* End Default */
break;
}/* End of switch */
} /* End of while */
m_numSymbols = NumSymbolsSaved;
return( TRUE );
}
/*F***************************************************************************
* NAME: FindSwbp(char * name)
*
* DESCRIPTION: Search the bp table for symbol name
*
*
*F***************************************************************************/
SWBP_SYMBOL * CoffLoader::FindSwbp(char * name )
{
SWBP_SYMBOL * b;
SYMBOL * sym;
//Go through list from head to tail - if the name matches, return
b = m_swbplist;
while (b != (SWBP_SYMBOL *)NULL )
{
sym = b->s;
if( (strcmp(name, sym->symname) == 0) // C name _Symbol
|| (strcmp(name+1, sym->symname) == 0)) // asm name Symbol
break;
b = b->next;
}
if ( b!= (SWBP_SYMBOL *)NULL )
return ( b );
return ((SWBP_SYMBOL *)NULL );
}
/*F***************************************************************************
* NAME: DeleteSwbpList( void )
*
* DESCRIPTION: Delete the bp table table
*
*
*F***************************************************************************/
BOOL CoffLoader::DeleteSwbpList( void )
{
SWBP_SYMBOL * b;
while (m_swbplist != (SWBP_SYMBOL *)NULL )
{
b = m_swbplist->next;
delete(m_swbplist);
?? 快捷鍵說明
復(fù)制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -