static orl_return ReadStrSec( orl_sec_handle o_shnd )
/***************************************************/
{
sectsizes[DW_DEBUG_STR] = ORLSecGetSize( o_shnd );
if( sectsizes[DW_DEBUG_STR] == 0 )
return( ORL_OKAY );
else
return( ORLSecGetContents( o_shnd, §ions[DW_DEBUG_STR] ));
}
static void registerSegment( orl_sec_handle o_shnd )
//**************************************************
{
orl_sec_flags sec_flags;
orl_sec_handle reloc_section;
orl_sec_alignment alignment;
char * content;
int ctr;
segment *seg;
seg = NewSegment();
seg->name = ORLSecGetName( o_shnd );
seg->size = ORLSecGetSize( o_shnd );
seg->start = 0;
seg->use_32 = 1; // only 32-bit object files use ORL
seg->attr = ( 2 << 2 ); // (?) combine public
alignment = ORLSecGetAlignment( o_shnd );
// FIXME: Need better alignment translation.
switch( alignment ) {
case 0:
seg->attr |= ( 1 << 5 ); break;
case 1:
seg->attr |= ( 2 << 5 ); break;
case 3:
case 4:
seg->attr |= ( 3 << 5 ); break;
case 8:
seg->attr |= ( 4 << 5 ); break;
case 2:
seg->attr |= ( 5 << 5 ); break;
case 12:
seg->attr |= ( 6 << 5 ); break;
default:
// fprintf( stderr, "NOTE! 'Strange' alignment (%d) found. Using byte alignment.\n", alignment );
seg->attr |= ( 1 << 5 ); break;
}
sec_flags = ORLSecGetFlags( o_shnd );
if( !( sec_flags & ORL_SEC_FLAG_EXEC ) ) {
seg->data_seg = true;
}
if( seg->size > 0 && ORLSecGetContents( o_shnd, &content ) == ORL_OKAY ) {
Segment = seg;
// Putting contents into segment struct.
for( ctr = 0; ctr < seg->size; ctr++ ) {
PutSegByte( ctr, content[ctr] );
}
}
if( !HashTableInsert( SectionToSegmentTable, (hash_value)o_shnd, (hash_data)seg ) ) {
SysError( ERR_OUT_OF_MEM, false );
}
reloc_section = ORLSecGetRelocTable( o_shnd );
if( reloc_section ) {
if( !addRelocSection( reloc_section ) ) {
SysError( ERR_OUT_OF_MEM, false );
}
}
}
static orl_return DeclareSegment( orl_sec_handle sec )
/****************************************************/
// declare the "segment"
{
segdata *sdata;
segnode *snode;
char *name;
unsigned_32 _WCUNALIGNED *contents;
size_t len;
orl_sec_flags flags;
orl_sec_type type;
unsigned numlines;
unsigned segidx;
type = ORLSecGetType( sec );
if( type != ORL_SEC_TYPE_NO_BITS && type != ORL_SEC_TYPE_PROG_BITS ) {
return( ORL_OKAY );
}
flags = ORLSecGetFlags( sec );
name = ORLSecGetName( sec );
sdata = AllocSegData();
segidx = ORLCvtSecHdlToIdx( sec );
snode = AllocNodeIdx( SegNodes, segidx );
snode->entry = sdata;
snode->handle = sec;
sdata->iscdat = (flags & ORL_SEC_FLAG_COMDAT) != 0;
len = sizeof( CoffIDataSegName ) - 1;
if( strnicmp( CoffIDataSegName, name, len ) == 0 ) {
SeenDLLRecord();
CurrMod->modinfo |= MOD_IMPORT_LIB;
if( name[len + 1] == '6' ) { // it is the segment containg the name
ORLSecGetContents( sec, (unsigned_8 **)&ImpExternalName );
ImpExternalName += 2;
} else if( name[len + 1] == '4' ) { // it is an import by ordinal
ORLSecGetContents( sec, (void *) &contents );
ImpOrdinal = *contents;
}
sdata->isdead = true;
sdata->isidata = true;
}
sdata->combine = COMBINE_ADD;
if( flags & ORL_SEC_FLAG_NO_PADDING ) {
sdata->align = 0;
} else {
sdata->align = ORLSecGetAlignment( sec );
}
sdata->is32bit = true;
sdata->length = ORLSecGetSize( sec );
sdata->u.name = name;
if( flags & ORL_SEC_FLAG_EXEC ) {
sdata->iscode = true;
} else if( flags & ORL_SEC_FLAG_UNINITIALIZED_DATA ) {
sdata->isuninit = true;
#ifdef _DEVELOPMENT
} else {
unsigned namelen;
namelen = strlen(name);
if( namelen >= 3 && memicmp(name + namelen - 3, "bss", 3) == 0 ) {
LnkMsg( ERR+MSG_INTERNAL, "s", "Initialized BSS found" );
}
#endif
}
numlines = ORLSecGetNumLines( sec );
if( numlines > 0 ) {
numlines *= sizeof(orl_linnum);
DBIAddLines( sdata, ORLSecGetLines( sec ), numlines, true );
}
return( ORL_OKAY );
}
static void AllocSeg( void *_snode, void *dummy )
/***********************************************/
{
segnode *snode = _snode;
segdata *sdata;
char *clname;
char *sname;
group_entry *group;
bool isdbi;
dummy = dummy;
sdata = snode->entry;
if( sdata == NULL )
return;
sname = sdata->u.name;
if( CurrMod->modinfo & MOD_IMPORT_LIB ) {
if( sdata->isidata || sdata->iscode ) {
if( sdata->iscode ) {
snode->info |= SEG_CODE;
}
snode->info |= SEG_DEAD;
snode->entry = NULL;
FreeSegData( sdata );
return;
}
}
isdbi = false;
if( memicmp( CoffDebugPrefix, sdata->u.name,
sizeof(CoffDebugPrefix) - 1 ) == 0 ) {
if( CurrMod->modinfo & MOD_IMPORT_LIB ) {
snode->info |= SEG_DEAD;
snode->entry = NULL;
FreeSegData( sdata );
return;
}
isdbi = true;
if( stricmp(CoffDebugSymName, sdata->u.name ) == 0 ) {
clname = _MSLocalClass;
} else if( stricmp(CoffDebugTypeName, sdata->u.name ) == 0 ) {
clname = _MSTypeClass;
} else {
clname = _DwarfClass;
}
} else if( memicmp( TLSSegPrefix, sdata->u.name,
sizeof(TLSSegPrefix) - 1 ) == 0 ) {
clname = TLSClassName;
} else if( sdata->iscode ) {
clname = CodeClassName;
} else if( sdata->isuninit ) {
clname = BSSClassName;
} else {
clname = DataClassName;
if( memcmp( sname, CoffPDataSegName, sizeof(CoffPDataSegName) ) == 0 ) {
sdata->ispdata = true;
} else if( memcmp(sname, CoffReldataSegName,
sizeof(CoffReldataSegName) ) == 0 ) {
sdata->isreldata = true;
}
}
AllocateSegment( snode, clname );
if( clname == TLSClassName ) {
group = GetGroup( TLSGrpName );
AddToGroup( group, snode->entry->u.leader );
} else if( !sdata->iscode && !isdbi ) {
group = GetGroup( DataGrpName );
AddToGroup( group, snode->entry->u.leader );
}
if( sdata->isuninit ) {
snode->contents = NULL;
} else {
snode->entry->u.leader->info |= SEG_LXDATA_SEEN;
if( !sdata->isdead ) {
ORLSecGetContents( snode->handle, &snode->contents );
if( !sdata->iscdat && ( snode->contents != NULL )) {
PutInfo( sdata->u1.vm_ptr, snode->contents, sdata->length );
}
}
}
}
orl_return PrintSecInfo( orl_sec_handle o_shnd )
/**********************************************/
{
char *buf;
int loop;
int loop2;
orl_sec_size size;
orl_sec_type sec_type;
orl_sec_flags sec_flags;
orl_sec_handle reloc_section;
orl_sec_handle symbol_table;
orl_sec_handle string_table;
int sep;
int segname_printed = 0;
size = 0; // just because gcc is a little retarded
sectionFound = 1;
if( dump.sections || dump.sec_contents ) {
buf = ORLSecGetName( o_shnd );
printf( "[%s]\n", buf );
segname_printed = 1;
size = ORLSecGetSize( o_shnd );
}
if( dump.sections ) {
//printf( "\nSection Handle:\t0x%x\n", o_shnd );
printf( "Size=%8.8x ", size );
sec_type = ORLSecGetType( o_shnd );
printf( "Align=%4.4x ", ORLSecGetAlignment( o_shnd ) );
//printf( "Section Type:\t%d\n", sec_type );
printf( "(" );
switch( sec_type ) {
case ORL_SEC_TYPE_NONE:
printf( "sec_type_none" );
break;
case ORL_SEC_TYPE_NO_BITS:
printf( "no bits" );
break;
case ORL_SEC_TYPE_PROG_BITS:
printf( "program bits" );
break;
case ORL_SEC_TYPE_SYM_TABLE:
printf( "symbol table" );
break;
case ORL_SEC_TYPE_DYN_SYM_TABLE:
printf( "dynamic symbol table" );
break;
case ORL_SEC_TYPE_STR_TABLE:
printf( "string table" );
break;
case ORL_SEC_TYPE_RELOCS:
printf( "relocs" );
break;
case ORL_SEC_TYPE_RELOCS_EXPADD:
printf( "relocs with explicit addends" );
break;
case ORL_SEC_TYPE_HASH:
printf( "hash table" );
break;
case ORL_SEC_TYPE_DYNAMIC:
printf( "dynamic linking information" );
break;
case ORL_SEC_TYPE_NOTE:
printf( "note or comment" );
break;
default:
printf( "unknown type? %s", sec_type );
break;
}
printf( ") " );
sec_flags = ORLSecGetFlags( o_shnd );
printf( "ORL_flags=0x%x\n", sec_flags );
sep = 0;
if( sec_flags ) printf( " " );
if( sec_flags & ORL_SEC_FLAG_EXEC ) {
printf( "executable code" );
sep++;
}
if( sec_flags & ORL_SEC_FLAG_INITIALIZED_DATA ) {
if( sep++ ) printf( ", " );
printf( "initialized data" );
}
if( sec_flags & ORL_SEC_FLAG_UNINITIALIZED_DATA ) {
if( sep++ ) printf( ", " );
printf( "uninitialized data" );
}
if( sec_flags & ORL_SEC_FLAG_GROUPED ) {
if( sep++ ) printf( ", " );
printf( "grouped section" );
}
if( sec_flags & ORL_SEC_FLAG_NO_PADDING ) {
if( sep++ ) printf( ", " );
printf( "no padding to next boundary" );
}
if( sec_flags & ORL_SEC_FLAG_OVERLAY ) {
if( sep++ ) printf( ", " );
printf( "contains an overlay" );
}
if( sec_flags & ORL_SEC_FLAG_REMOVE ) {
if( sep++ ) printf( ", " );
printf( "remove at link-time" );
}
if( sec_flags & ORL_SEC_FLAG_COMDAT ) {
if( sep++ ) printf( ", " );
printf( "communal data" );
}
if( sec_flags & ORL_SEC_FLAG_DISCARDABLE ) {
if( sep++ ) printf( ", " );
printf( "discardable" );
}
if( sec_flags & ORL_SEC_FLAG_NOT_CACHED ) {
if( sep++ ) printf( ", " );
printf( "cannot be cached" );
}
if( sec_flags & ORL_SEC_FLAG_NOT_PAGEABLE) {
if( sep++ ) printf( ", " );
printf( "not pageable" );
}
if( sec_flags & ORL_SEC_FLAG_SHARED ) {
if( sep++ ) printf( ", " );
printf( "shared in memory" );
}
if( sec_flags & ORL_SEC_FLAG_EXECUTE_PERMISSION ) {
if( sep++ ) printf( ", " );
printf( "execute permission" );
}
if( sec_flags & ORL_SEC_FLAG_READ_PERMISSION ) {
if( sep++ ) printf( ", " );
printf( "read permission" );
}
if( sec_flags & ORL_SEC_FLAG_WRITE_PERMISSION) {
if( sep++ ) printf( ", " );
printf( "write permission" );
}
if( sep ) printf( "\n" );
}
if( dump.sec_contents ) {
if( ORLSecGetContents( o_shnd, (unsigned_8 **)&buf ) == ORL_OKAY ) {
printf( "Contents:\n" );
for( loop = 0; loop < size; loop += 16 ) {
printf( "0x%8.8x: ", loop );
for( loop2 = 0; loop2 < 16; loop2++ ) {
if( loop + loop2 < size ) {
printf( "%2.2x ", buf[loop+loop2] );
} else {
printf( " " );
}
if( loop2 == 7 ) {
printf( " " );
}
}
printf( " " );
for( loop2 = 0; loop2 < 16 && loop + loop2 < size; loop2++ ) {
if( buf[loop+loop2] >= 32 && buf[loop+loop2] <= 122 ) {
printf( "%c", buf[loop+loop2] );
} else {
printf( "." );
}
if( loop2 == 7 ) {
printf( " " );
}
}
printf( "\n" );
}
}
}
if( dump.relocs ) {
reloc_section = ORLSecGetRelocTable( o_shnd );
if( reloc_section ) {
if( !segname_printed++ ) {
buf = ORLSecGetName( o_shnd );
printf( "[%s]\n", buf );
}
printf( "Relocs in [%s], ", ORLSecGetName( reloc_section ) );
symbol_table = ORLSecGetSymbolTable( reloc_section );
if( symbol_table ) {
printf( "symtab='%s', ", ORLSecGetName( symbol_table ) );
string_table = ORLSecGetStringTable( symbol_table );
if( string_table ) {
printf( "strtab='%s'.\n", ORLSecGetName( string_table ) );
} else {
printf( "strtab=none.\n" );
}
} else {
printf( "symtab=none, strtab=none.\n" );
}
//printf( "Relocs:\n" );
ORLRelocSecScan( reloc_section, &PrintRelocInfo );
}
}
return( ORL_OKAY );
}
static orl_return ReadARSec( orl_sec_handle o_shnd )
/**************************************************/
{
sectsizes[DW_DEBUG_ARANGES] = ORLSecGetSize( o_shnd );
return( ORLSecGetContents( o_shnd, §ions[DW_DEBUG_ARANGES] ));
}
static orl_return ReadMacinfoSec( orl_sec_handle o_shnd )
/*******************************************************/
{
sectsizes[DW_DEBUG_MACINFO] = ORLSecGetSize( o_shnd );
return( ORLSecGetContents( o_shnd, §ions[DW_DEBUG_MACINFO] ));
}
static orl_return ReadLineSec( orl_sec_handle o_shnd )
/****************************************************/
{
sectsizes[DW_DEBUG_LINE] = ORLSecGetSize( o_shnd );
return( ORLSecGetContents( o_shnd, §ions[DW_DEBUG_LINE] ));
}
static orl_return ReadAbbrevSec( orl_sec_handle o_shnd )
/******************************************************/
{
sectsizes[DW_DEBUG_ABBREV] = ORLSecGetSize( o_shnd );
return( ORLSecGetContents( o_shnd, §ions[DW_DEBUG_ABBREV] ));
}
