static bool CheckFlags( orl_file_handle filehdl )
/***********************************************/
{
orl_machine_type machtype;
stateflag typemask;
stateflag test;
orl_file_flags flags;
machtype = ORLFileGetMachineType( filehdl );
switch( machtype ) {
case ORL_MACHINE_TYPE_I386:
typemask = HAVE_I86_CODE;
break;
case ORL_MACHINE_TYPE_AMD64:
typemask = HAVE_X64_CODE;
break;
case ORL_MACHINE_TYPE_ALPHA:
typemask = HAVE_ALPHA_CODE;
break;
case ORL_MACHINE_TYPE_PPC601:
typemask = HAVE_PPC_CODE;
break;
case ORL_MACHINE_TYPE_R3000:
typemask = HAVE_MIPS_CODE;
break;
case ORL_MACHINE_TYPE_NONE:
typemask = 0;
break;
default:
typemask = HAVE_MACHTYPE_MASK; // trigger the error
break;
}
test = (typemask | LinkState) & HAVE_MACHTYPE_MASK;
test &= test - 1; // turn off one bit
if( test != 0 ) { // multiple bits were turned on.
LnkMsg( WRN+MSG_MACHTYPE_DIFFERENT, "s", CurrMod->f.source->file->name);
} else {
LinkState |= typemask;
}
if( ORLFileGetType( filehdl ) != ORL_FILE_TYPE_OBJECT ) {
BadObject();
return( false );
}
flags = ORLFileGetFlags( filehdl );
#if 0
if( flags & ORL_FILE_FLAG_BIG_ENDIAN ) { // MS lies about this.
LnkMsg( ERR+LOC+MSG_NO_BIG_ENDIAN, NULL );
return( false );
}
#endif
if( flags & ORL_FILE_FLAG_64BIT_MACHINE ) {
Set64BitMode();
} else if( flags & ORL_FILE_FLAG_16BIT_MACHINE ) {
Set16BitMode();
} else {
Set32BitMode();
}
return( true );
}
/*
* Collect all external symbols from an object file. Returns 0 on error.
*/
static int handle_obj_file( const char *filename, orl_handle o_hnd )
/******************************************************************/
{
orl_file_handle o_fhnd;
orl_file_format o_format;
orl_file_type o_filetype;
orl_sec_handle o_symtab;
orl_return o_rc;
int fileh;
/*** Make ORL interested in the file ***/
fileh = open( filename, O_BINARY | O_RDONLY );
if( fileh == -1 ) {
return( 0 );
}
o_format = ORLFileIdentify( o_hnd, (void *)(pointer_int)fileh );
if( o_format == ORL_UNRECOGNIZED_FORMAT ) {
close( fileh );
return( 0 );
}
o_fhnd = ORLFileInit( o_hnd, (void *)(pointer_int)fileh, o_format );
if( o_fhnd == NULL ) {
close( fileh );
return( 0 );
}
o_filetype = ORLFileGetType( o_fhnd );
if( o_filetype != ORL_FILE_TYPE_OBJECT ) {
close( fileh );
return( 0 );
}
/*** Scan the file's symbol table ***/
o_symtab = ORLFileGetSymbolTable( o_fhnd );
if( o_symtab == NULL ) {
close( fileh );
return( 0 );
}
o_rc = ORLSymbolSecScan( o_symtab, &do_orl_symbol );
if( o_rc != ORL_OKAY ) {
close( fileh );
return( 0 );
}
o_rc = ORLFileFini( o_fhnd );
if( o_rc != ORL_OKAY ) {
close( fileh );
return( 0 );
}
close( fileh );
return( 1 );
}
int main( int argc, char *argv[] )
/********************************/
{
orl_handle o_hnd;
orl_file_handle o_fhnd;
orl_funcs funcs;
int file;
orl_file_flags file_flags;
orl_machine_type machine_type;
orl_file_type file_type;
orl_file_format type;
int c;
int sep;
char *secs[MAX_SECS];
int num_secs = 0;
if( argc < 2 ) {
printf( "Usage: objread [-ahrsSx] [-o<section>] <objfile>\n" );
printf( "Where <objfile> is a COFF, ELF or OMF object file\n" );
printf( "objread reads and dumps an object using ORL\n" );
printf( "Options: -a dumps all information (except hex dump)\n" );
printf( " -h dumps file header information\n" );
printf( " -r dumps relocation information\n" );
printf( " -s dumps symbol table\n" );
printf( " -S dumps section information\n" );
printf( " -x get hex dump of section content\n" );
printf( " -o only scan <section> for info\n" );
return( 1 );
}
while( (c = getopt( argc, argv, "axhrsSo:" )) != EOF ) {
switch( c ) {
case 'a':
dump.relocs++;
dump.header++;
dump.symbols++;
dump.sections++;
break;
case 'x':
dump.sec_contents++;
break;
case 'h':
dump.header++;
break;
case 'r':
dump.relocs++;
break;
case 's':
dump.symbols++;
break;
case 'S':
dump.sections++;
break;
case 'o':
secs[num_secs++] = optarg;
break;
default:
// error occured
exit(1);
};
};
if( optind != argc - 1 ) {
fprintf( stderr, "must specify 1 filename\n" );
exit(1);
}
file = open( argv[optind], O_BINARY | O_RDONLY );
if( file == -1 ) {
printf( "Error opening file.\n" );
return( 2 );
}
TRMemOpen();
funcs.read = &objRead;
funcs.seek = &objSeek;
funcs.alloc = &TRMemAlloc;
funcs.free = &TRMemFree;
o_hnd = ORLInit( &funcs );
if( o_hnd == NULL ) {
printf( "Got NULL orl_handle.\n" );
return( 2 );
}
type = ORLFileIdentify( o_hnd, (void *)file );
if( type == ORL_UNRECOGNIZED_FORMAT ) {
printf( "The object file is not in either ELF, COFF or OMF format." );
return( 1 );
}
switch( type ) {
case ORL_ELF:
printf( "ELF" );
break;
case ORL_COFF:
printf( "COFF" );
break;
case ORL_OMF:
printf( "OMF" );
break;
default:
printf( "Unknown" );
break;
}
printf( " object file.\n" );
o_fhnd = ORLFileInit( o_hnd, (void *)file, type );
if( o_fhnd == NULL ) {
printf( "Got NULL orl_file_handle.\n" );
return( 2 );
}
if( dump.header ) {
printf( "File %s:\n", argv[optind] );
machine_type = ORLFileGetMachineType( o_fhnd );
printf( "Machine Type: " );
if( machine_type >= ( sizeof( machType ) / sizeof( *machType ) ) ) {
// We've probably added some new types?
printf( "?(%d)", machine_type );
} else {
printf( "%s", machType[ machine_type ] );
}
file_type = ORLFileGetType( o_fhnd );
printf( " (" );
switch( file_type ) {
case ORL_FILE_TYPE_NONE:
printf( "file_type_none" );
break;
case ORL_FILE_TYPE_OBJECT:
printf( "object file" );
break;
case ORL_FILE_TYPE_EXECUTABLE:
printf( "executable" );
break;
case ORL_FILE_TYPE_SHARED_OBJECT:
printf( "shared object" );
break;
case ORL_FILE_TYPE_DLL:
printf( "DLL" );
break;
default:
printf( "unknown file type?" );
break;
}
printf( ")\n" );
file_flags = ORLFileGetFlags( o_fhnd );
//printf(" File flags=0x%x\n", file_flags );
sep = 0;
if( file_flags & ORL_FILE_FLAG_LINE_NUMS_STRIPPED ) {
printf( "line number info stripped" );
sep = 1;
}
if( file_flags & ORL_FILE_FLAG_RELOCS_STRIPPED ) {
if( sep++ ) printf( ", " );
printf( "relocs stripped" );
}
if( file_flags & ORL_FILE_FLAG_LOCAL_SYMS_STRIPPED ) {
if( sep++ ) printf( ", " );
printf( "local symbols stripped" );
}
if( file_flags & ORL_FILE_FLAG_DEBUG_STRIPPED ) {
if( sep++ ) printf( ", " );
printf( "debug info stripped" );
}
if( file_flags & ORL_FILE_FLAG_16BIT_MACHINE ) {
if( sep++ ) printf( ", " );
printf( "for 16-bit machine" );
}
if( file_flags & ORL_FILE_FLAG_32BIT_MACHINE ) {
if( sep++ ) printf( ", " );
printf( "for 32-bit machine" );
}
if( file_flags & ORL_FILE_FLAG_64BIT_MACHINE ) {
if( sep++ ) printf( ", " );
printf( "for 64-bit machine" );
}
if( file_flags & ORL_FILE_FLAG_LITTLE_ENDIAN ) {
if( sep++ ) printf( ", " );
printf( "little-endian byte order" );
}
if( file_flags & ORL_FILE_FLAG_BIG_ENDIAN ) {
if( sep++ ) printf( ", " );
printf( "big-endian byte order" );
}
if( file_flags & ORL_FILE_FLAG_SYSTEM ) {
if( sep++ ) printf( ", " );
printf( "system file" );
}
if( sep ) printf( "\n" );
}
if( num_secs ) {
for( c = 0; c < num_secs; c++ ) {
sectionFound = 0;
if( ORLFileScan( o_fhnd, secs[c], &PrintSecInfo ) != ORL_OKAY ) {
printf( "Error occured in scanning section '%s'.\n", secs[c] );
}
if( !sectionFound ) {
printf( "Section '%s' not found in object.\n", secs[c] );
}
}
} else {
if( ORLFileScan( o_fhnd, NULL, &PrintSecInfo ) != ORL_OKAY ) {
printf( "Error occured in scanning file.\n" );
return( 2 );
}
}
if( ORLFileScan( o_fhnd, ".symtab", &PrintSymTable ) != ORL_OKAY ) {
printf( "Error occured in scanning file for symbol table\n" );
return( 2 );
}
if( ORLFileFini( o_fhnd ) != ORL_OKAY ) {
printf( "Error calling ORLFileFini.\n" );
return( 2 );
}
if( close( file ) == -1 ) {
printf( "Error closing file.\n" );
return( 2 );
}
if( ORLFini( o_hnd ) != ORL_OKAY ) {
printf( "Error calling ORLFini.\n" );
}
freeBuffList();
#ifdef TRMEM
TRMemPrtList();
#endif
TRMemClose();
return( 0 );
}
