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 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 printMasmHeader( section_ptr sec )
{
orl_sec_alignment alignment;
orl_sec_flags flags;
orl_sec_type type;
orl_sec_frame frame;
orl_sec_combine combine;
orl_sec_size size;
char *name;
char *class;
char *gname;
char *astr;
orl_sec_handle sh;
orl_group_handle grp = NULL;
char comname[ MAX_LINE_LEN ];
size = ORLSecGetSize( sec->shnd );
// Load all necessary information
name = sec->name;
if( !name ) {
name = "";
}
type = ORLSecGetType( sec->shnd );
flags = ORLSecGetFlags( sec->shnd );
frame = ORLSecGetAbsFrame( sec->shnd );
if( DFormat & DFF_ASM ) {
class = ORLSecGetClassName( sec->shnd );
if( !class ) {
class = "";
}
if( flags & ORL_SEC_FLAG_COMDAT ) {
BufferConcat( "; ERROR: Comdat symbols cannot be assembled." );
} else if( frame == ORL_SEC_NO_ABS_FRAME ) {
alignment = ORLSecGetAlignment( sec->shnd );
combine = ORLSecGetCombine( sec->shnd );
BufferQuoteName( name );
BufferStore( "\t\tSEGMENT\t%s %s %s '%s'",
getAlignment( alignment ), getCombine( combine ),
getUse( flags ), class );
} else {
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 );
}
return_val DoPass1( orl_sec_handle shnd, unsigned_8 *contents, orl_sec_size size,
ref_list sec_ref_list, scantab_ptr stl )
// perform pass 1 on one section
{
orl_sec_offset loop;
dis_dec_ins decoded;
dis_value value;
dis_return dr;
unnamed_label_return_struct rs;
return_val error;
unsigned i;
ref_entry r_entry;
dis_inst_flags flags;
orl_sec_offset op_pos;
int is_intel;
int adjusted;
sa_disasm_struct sds;
sds.data = contents;
sds.last = size - 1;
if( sec_ref_list != NULL ) {
r_entry = sec_ref_list->first;
} else {
r_entry = NULL;
}
flags.u.all = DIF_NONE;
if( GetMachineType() == ORL_MACHINE_TYPE_I386 ) {
if( ( GetFormat() != ORL_OMF ) ||
( ORLSecGetFlags( shnd ) & ORL_SEC_FLAG_USE_32 ) ) {
flags.u.x86 = DIF_X86_USE32_FLAGS;
}
is_intel = 1;
} else {
is_intel = IsIntelx86();
}
for( loop = 0; loop < size; loop += decoded.size ) {
// skip data in code segment
while( stl && ( loop > stl->end ) ) {
stl = stl->next;
}
if( stl && ( loop >= stl->start ) ) {
decoded.size = 0;
if( is_intel ) {
r_entry = DoPass1Relocs( contents, r_entry, loop, stl->end );
}
loop = stl->end;
stl = stl->next;
continue;
}
// data may not be listed in scan table, but a fixup at this offset will
// give it away
while( r_entry && ( ( r_entry->offset < loop ) || SkipRef(r_entry) ) ) {
r_entry = r_entry->next;
}
if( r_entry && ( r_entry->offset == loop ) ) {
if( is_intel || IsDataReloc( r_entry ) ) {
// we just skip the data
op_pos = loop;
decoded.size = 0;
loop += RelocSize( r_entry );
r_entry = DoPass1Relocs( contents, r_entry, op_pos, loop );
continue;
}
}
DisDecodeInit( &DHnd, &decoded );
decoded.flags.u.all |= flags.u.all;
sds.offs = loop;
dr = DisDecode( &DHnd, &sds, &decoded );
// if an invalid instruction was found, there is nothing we can do.
if( dr != DR_OK )
return( RC_ERROR );
for( i = 0; i < decoded.num_ops; ++i ) {
adjusted = 0;
op_pos = loop + decoded.op[i].op_position;
switch( decoded.op[i].type & DO_MASK ) {
case DO_IMMED:
if( !is_intel )
break;
/* fall through */
case DO_RELATIVE:
case DO_MEMORY_REL:
if( ( decoded.op[i].type & DO_MASK ) != DO_IMMED ) {
decoded.op[i].value += loop;
adjusted = 1;
}
/* fall through */
case DO_ABSOLUTE:
case DO_MEMORY_ABS:
// Check for reloc at this location
while( r_entry && r_entry->offset < op_pos ) {
r_entry = r_entry->next;
}
if( r_entry && ( r_entry->offset == op_pos ) ) {
if( is_intel && r_entry->label->shnd
&& ( r_entry->type != ORL_RELOC_TYPE_SEGMENT )
&& ( r_entry->label->type == LTYP_SECTION ) ) {
/* For section offsets under intel we MUST generate a
* local label because the offset might change when the
* code is re-assembled
*/
if( r_entry->addend ) {
r_entry->no_val = 0;
CreateUnnamedLabel( r_entry->label->shnd,
HandleAddend( r_entry ), &rs );
} else {
r_entry->no_val = 1;
if( adjusted && isSelfReloc( r_entry ) &&
( r_entry->label->type == LTYP_SECTION ) ) {
/* This is a kludgy reloc done under OMF
*/
decoded.op[i].value -= loop;
decoded.op[i].value -= decoded.size;
switch( RelocSize( r_entry ) ) {
case( 2 ):
decoded.op[i].value =
(uint_16)(decoded.op[i].value);
case( 1 ):
decoded.op[i].value =
(uint_8)(decoded.op[i].value);
}
}
value = decoded.op[i].value;
if( value < 0 || value > ORLSecGetSize( r_entry->label->shnd ) ) {
// can't fold it into the label position - BBB Oct 28, 1996
value = 0;
r_entry->no_val = 0;
}
CreateUnnamedLabel( r_entry->label->shnd, value, &rs );
}
if( rs.error != RC_OKAY )
return( rs.error );
r_entry->label = rs.entry;
} else {
// fixme: got to handle other types of relocs here
}
} else if( ( decoded.op[i].type & DO_MASK ) != DO_IMMED ) {
if( decoded.op[i].base == DR_NONE &&
decoded.op[i].index == DR_NONE ) {
switch( decoded.op[i].type & DO_MASK ) {
case DO_MEMORY_REL:
case DO_MEMORY_ABS:
// use decoded instruction size for absolute memory on amd64.
// the cpu will reference rip _after_ the instruction is
// completely fetched and decoded.
// relocations in pass2 are not applied because they break
// relative memory references if no relocation is present!
if( GetMachineType() == ORL_MACHINE_TYPE_AMD64 ) {
decoded.op[i].value += decoded.size;
// I don't know if this is neccessary, but it will generate
// labels for memory references if no symbol is present
// (ex: executable file)
CreateUnnamedLabel( shnd, decoded.op[i].value, &rs );
if( rs.error != RC_OKAY )
return( rs.error );
error = CreateUnnamedLabelRef( shnd, rs.entry, op_pos );
} else {
// create an LTYP_ABSOLUTE label
CreateAbsoluteLabel( shnd, decoded.op[i].value, &rs );
if( rs.error != RC_OKAY )
return( rs.error );
error = CreateAbsoluteLabelRef( shnd, rs.entry, op_pos );
}
break;
default:
// create an LTYP_UNNAMED label
CreateUnnamedLabel( shnd, decoded.op[i].value, &rs );
if( rs.error != RC_OKAY )
return( rs.error );
error = CreateUnnamedLabelRef( shnd, rs.entry, op_pos );
break;
}
if( error != RC_OKAY ) {
return( error );
}
}
}
break;
}
}
}
return( RC_OKAY );
}
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] ));
}
