void PrintPublics( void ) {
int loop;
label_entry entry;
hash_data * data_ptr;
section_ptr sec;
// fixme: data labels get a _ in front, others one after ??
BufferMsg( LIST_OF_PUBLICS );
BufferMsg( SYMBOL );
BufferConcat("\t\t\t");
BufferMsg( SECTION );
BufferConcat("\t\t\t");
BufferMsg( OFFSET );
BufferConcatNL();
BufferPrint();
Print( "--------------------------------------------------------\n" );
for( loop = 0; loop < Publics.number; loop++ ) {
entry = Publics.public_symbols[loop];
BufferConcat( entry->label.name );
data_ptr = HashTableQuery( HandleToSectionTable, (hash_value) entry->shnd );
// fixme: what is the proper behavour if no section found??
if( data_ptr ) {
sec = (section_ptr) *data_ptr;
BufferAlignToTab( SECTION_TAB_POS );
BufferConcat( sec->name );
}
BufferAlignToTab( ADDRESS_TAB_POS );
BufferStore( "%08X\n", entry->offset );
BufferPrint();
}
}
static void printUsage( int msg ) {
int i;
static const char * const banner[]={
banner1w( "Multi-processor Disassembler", _WDISASM_VERSION_ ),
banner2( "1995" ),
banner3,
banner3a,
NULL
};
const char * const *text;
ChangePrintDest( STDERR_FILENO );
if( msg != 0 ) {
BufferMsg( msg );
BufferConcatNL();
BufferConcatNL();
BufferPrint();
}
text = banner;
while( *text ) {
Print( (char *)*text++ );
Print( "\n" );
}
for( i = USAGE_1; i <= USAGE_LAST; i++ ) {
BufferMsg( i );
BufferConcatNL();
BufferPrint();
}
if( ObjFileName != NULL ) {
MemFree( ObjFileName );
}
MemClose();
exit( 1 );
}
void PrintExterns( externs sec_externs )
{
int loop;
ref_entry entry;
label_entry prev_label = NULL;
BufferMsg( EXTERNAL_REFS );
BufferConcatNL();
BufferConcatNL();
BufferMsg( SYMBOL );
BufferConcatNL();
BufferConcat( "-------" );
BufferPrint();
for( loop = 0; loop < sec_externs->number; loop++ ) {
entry = sec_externs->extern_refs[loop];
if( prev_label != entry->label ) {
BufferStore( "\n%s", entry->label->label.name );
BufferAlignToTab( ADDRESSES_POS );
BufferPrint();
prev_label = entry->label;
}
BufferStore( "%04X ", entry->offset );
}
BufferPrint();
Print( "\n\n" );
}
void PrintPowerupInfo( gentity_t *ent, char *targetPW )
{
int i = 0;
int allowArg = 0;
BeginBufferPrint();
for(; i < numPowerups; i++)
{
if(Q_stricmp(powerups[i].name, targetPW) == 0)
{
allowArg = 1;
}
}
if(allowArg == 1)
{
allowArg = 0;
BufferPrint(ent, va("^5Currently showing information for: %s\n ", targetPW));
if(Q_stricmp("noslow", targetPW) == 0)
{
BufferPrint(ent, va("^7Removes your slowing effects for %.2f seconds.\n", (float)sr_pw_noSlowDuration.integer / 1000));
}
else if(Q_stricmp("lowgravity", targetPW) == 0)
{
BufferPrint(ent, va("^7Decreases your gravity to %d for %.2f seconds.\n", sr_pw_lowGravity.integer, (float)sr_pw_lowGravityDuration.integer / 1000));
}
else if(Q_stricmp("satchelboost", targetPW) == 0)
{
BufferPrint(ent, va("^7Increases your blast force by %dx for next %d satchel/s.\n", sr_pw_satchelBoostKnockback.integer, sr_pw_satchelBoost.integer));
}
else if(Q_stricmp("satchelunboost", targetPW) == 0)
{
BufferPrint(ent, va("^7Decreases the opponents satchel blast force by %dx for next %d satchel/s.\n", sr_pw_satchelUnboostKnockback.integer, sr_pw_satchelUnboost.integer));
}
else if(Q_stricmp("slow", targetPW) == 0)
{
BufferPrint(ent, va("^7Decreases the opponents speed by %d percent for %.2f seconds.\n", sr_pw_slowPercent.integer, (float)sr_pw_slowDuration.integer / 1000));
}
else if(Q_stricmp("gravity", targetPW) == 0)
{
BufferPrint(ent, va("^7Increases the opponents gravity to %d for %.2f seconds.\n", sr_pw_gravity.integer, (float)sr_pw_gravityDuration.integer / 1000));
}
else if(Q_stricmp("root", targetPW) == 0)
{
BufferPrint(ent, va("^7Stops the enemy from moving for %.2f seconds.\n", (float)sr_pw_rootDuration.integer / 1000));
}
else if(Q_stricmp("slick", targetPW) == 0)
{
BufferPrint(ent, va("^7Makes the ground slippery for opposing players for %.2f seconds\n", (float)sr_pw_slickDuration.integer / 1000));
}
}
else
{
BufferPrint(ent, "Invalid powerup.\n");
}
FinishBufferPrint(ent);
}
static return_val bssMasmASMSection( section_ptr section, dis_sec_size size, label_entry l_entry )
{
size_t offset = OFFSET_UNDEF;
dis_value value;
PrintHeader( section );
value.u._32[I64HI32] = 0;
for( ; l_entry != NULL; l_entry = l_entry->next ) {
if( l_entry->type != LTYP_SECTION ) {
if( offset != l_entry->offset ) {
BufferStore( " ORG " );
value.u._32[I64LO32] = l_entry->offset;
BufferHex( 8, value );
offset = l_entry->offset;
BufferConcatNL();
BufferPrint();
}
switch( l_entry->type ) {
case LTYP_UNNAMED:
BufferStore( "%c$%d", LabelChar, l_entry->label.number );
break;
case LTYP_SECTION:
case LTYP_NAMED:
BufferStore( "%s", l_entry->label.name );
break;
}
BufferConcat( " LABEL\tBYTE" );
BufferConcatNL();
BufferPrint();
}
}
if( offset == OFFSET_UNDEF ) {
if( size > 0 ) {
BufferStore( " ORG 0" );
BufferConcatNL();
BufferPrint();
}
offset = 0;
}
if( size > offset ) {
BufferStore( " ORG " );
value.u._32[I64LO32] = size;
BufferHex( 8, value );
BufferConcatNL();
BufferPrint();
}
PrintTail( section );
BufferConcatNL();
BufferPrint();
return( RC_OKAY );
}
static void printDescriptor( orl_sec_offset offset,
descriptor_struct *descriptor, ref_entry *r_entry )
{
char *PreString;
if( DFormat & DFF_ASM ) {
PreString = "\t\t.long\t";
} else {
PreString = "\t";
}
BufferStore("%s", PreString );
doDescriptorRelocs( r_entry, offset, descriptor->begin_address );
BufferAlignToTab(6);
BufferStore("%s ", CommentString );
BufferMsg( BEGIN_ADDRESS );
BufferStore(": %d\n", descriptor->begin_address );
BufferStore("%s", PreString );
doDescriptorRelocs( r_entry, offset+4, descriptor->end_address );
BufferAlignToTab(6);
BufferStore("%s ", CommentString );
BufferMsg( END_ADDRESS );
BufferStore(": %d\n", descriptor->end_address );
BufferPrint();
BufferStore("%s", PreString );
doDescriptorRelocs( r_entry, offset+8, descriptor->exception_handler );
BufferAlignToTab(6);
BufferStore("%s ", CommentString );
BufferMsg( EXCEPTION_HANDLER );
BufferStore(": %d\n", descriptor->exception_handler );
BufferStore("%s", PreString );
doDescriptorRelocs( r_entry, offset+12, descriptor->handler_data );
BufferAlignToTab(6);
BufferStore("%s ", CommentString );
BufferMsg( HANDLER_DATA );
BufferStore(": %d\n", descriptor->handler_data );
BufferStore("%s", PreString );
doDescriptorRelocs( r_entry, offset+16, descriptor->prolog_end );
BufferAlignToTab(6);
BufferStore("%s ", CommentString );
BufferMsg( PROLOG_END );
BufferStore(": %d\n\n", descriptor->prolog_end );
BufferPrint();
}
static void printRest( unsigned_8 *bytes, size_t size )
{
size_t i;
size_t d;
const char *btype;
bool is_masm;
dis_value value;
is_masm = IsMasmOutput();
if( is_masm ) {
btype = " DB\t";
} else {
btype = " .byte\t";
}
BufferConcat( btype );
value.u._32[I64HI32] = 0;
for( i = 0; i < size; ) {
// see if we can replace large chunks of homogenous
// segment space by using the DUP macro
if( is_masm && (i % 8) == 0 ) {
d = tryDUP( bytes, i, size );
if( d > 0 ) {
i += d;
if( i < size ) {
BufferConcatNL();
BufferConcat( btype );
BufferPrint();
}
continue;
}
}
value.u._32[I64LO32] = bytes[i];
BufferHex( 2, value );
if( i < size - 1 ) {
if( (i % 8) == 7 ) {
BufferConcatNL();
BufferConcat( btype );
BufferPrint();
} else {
BufferConcat( ", " );
}
}
i++;
}
BufferConcatNL();
BufferPrint();
}
static void printOut( char *string, size_t offset, size_t size )
{
char * string_left = string;
size_t curr_pos = 0;
int ascii;
offset = offset;
ascii = !IsMasmOutput();
for( ;; ) {
if( string_left < ( string + size ) ) {
if( ascii && printableString( string_left ) && strlen( string_left ) > 0 ) {
if( strlen( string_left ) < ( size - curr_pos ) ) {
BufferConcat( " .asciiz\t" );
curr_pos = printString( string_left, ASCIZ );
} else {
BufferConcat( " .ascii\t" );
curr_pos = printString( string_left, ASCII );
}
string_left += curr_pos;
} else {
printRest( (unsigned_8 *)string_left, size - (size_t)( string_left - string ) );
break;
}
} else {
break;
}
BufferConcatNL();
BufferPrint();
}
}
return_val DumpASMGroupFini( void )
{
BufferConcatNL();
BufferPrint();
useComma = 0;
return( RC_OKAY );
}
void ASIOSocketWrapper::sendManyDequeItems(const std::tr1::weak_ptr<MultiplexedSocket>&weakParentMultiSocket, const ErrorCode &error, std::size_t bytes_sent) {
MultiplexedSocketPtr parentMultiSocket(weakParentMultiSocket.lock());
mOutstandingDataParent.reset();
if (parentMultiSocket) {
std::deque<TimestampedChunk> local_toSend;
local_toSend.swap(mToSend);
if (error ) {
triggerMultiplexedConnectionError(&*parentMultiSocket,this,error);
SILOG(tcpsst,insane,"Socket disconnected...waiting for recv to trigger error condition\n");
} else {
size_t total_size=0;
for (std::deque<TimestampedChunk>::const_iterator i=local_toSend.begin(),ie=local_toSend.end(); i!=ie; ++i) {
finishedSendingChunk(*i);
size_t cursize=i->size();
total_size+=cursize;
if (cursize) {
BufferPrint(this,".sec",&*i->chunk->begin(),cursize);
TCPSSTLOG(this,"snd",&*i->begin(),i->size,error);
}
delete i->chunk;
}
assert(total_size==bytes_sent);//otherwise should have given us an error
//and send further items on the global queue if they are there
finishAsyncSend(parentMultiSocket);
}
}
}
static void printOut( const char *string, size_t offset, size_t size )
{
const char *string_left;
size_t item_size;
bool ascii;
/* unused parameters */ (void)offset;
ascii = !IsMasmOutput();
item_size = 0;
string_left = string;
for( ; string_left < ( string + size ); ) {
if( !ascii || !printableString( string_left ) || strlen( string_left ) == 0 ) {
printRest( (unsigned_8 *)string_left, size - (size_t)( string_left - string ) );
break;
}
if( strlen( string_left ) < ( size - item_size ) ) {
BufferConcat( " .asciiz\t" );
item_size = printString( string_left, ASCIZ );
} else {
BufferConcat( " .ascii\t" );
item_size = printString( string_left, ASCII );
}
string_left += item_size;
BufferConcatNL();
BufferPrint();
}
}
static label_entry handleLabels( char *sec_name, orl_sec_offset offset, orl_sec_offset end,
label_entry l_entry, orl_sec_size size )
// handle any labels at this offset and skip all unused non-label symbols
{
bool is32bit;
is32bit = ( size >= 0x10000 );
for( ; ( l_entry != NULL ) && ( l_entry->offset < end ); l_entry = l_entry->next ) {
switch( l_entry->type ) {
case LTYP_SECTION:
case LTYP_NAMED:
if( strcmp( l_entry->label.name, sec_name ) == 0 )
continue;
/* fall through */
case LTYP_UNNAMED:
if( l_entry->offset > offset )
return( l_entry );
break;
case LTYP_ABSOLUTE:
case LTYP_FUNC_INFO:
default:
continue;
}
switch( l_entry->type ) {
case LTYP_NAMED:
if( !( DFormat & DFF_ASM ) ) {
if( offset != 0 && l_entry->binding == ORL_SYM_BINDING_GLOBAL ) {
routineSize = offset - routineBase;
BufferConcatNL();
BufferMsg( ROUTINE_SIZE );
BufferStore(" %d ", routineSize );
BufferMsg( BYTES );
BufferConcat(", ");
BufferMsg( ROUTINE_BASE );
BufferStore(" %s + %04X\n\n", sec_name, routineBase );
routineBase = offset;
}
}
case LTYP_SECTION:
if( !( DFormat & DFF_ASM ) ) {
PrintLinePrefixAddress( offset, is32bit );
BufferAlignToTab( PREFIX_SIZE_TABS );
}
BufferStore( "%s:\n", l_entry->label.name );
break;
case LTYP_UNNAMED:
if( !( DFormat & DFF_ASM ) ) {
PrintLinePrefixAddress( offset, is32bit );
BufferAlignToTab( PREFIX_SIZE_TABS );
}
BufferStore( "%c$%d:\n", LabelChar, l_entry->label.number );
break;
}
BufferPrint();
}
return( l_entry );
}
static size_t printString( char *string, string_type type )
{
char *buffer;
size_t i, j;
buffer = MemAlloc( strlen( string ) * 2 + 1 );
for( i = 0, j = 0; i < strlen( string ); i++ ) {
switch( string[i] ){
case '\n':
buffer[j++] = '\\';
buffer[j++] = 'n';
break;
case '\r':
buffer[j++] = '\\';
buffer[j++] = 'r';
break;
case '\t':
buffer[j++] = '\\';
buffer[j++] = 't';
break;
case '\f':
buffer[j++] = '\\';
buffer[j++] = 'f';
break;
case '\\':
buffer[j++] = '\\';
buffer[j++] = '\\';
break;
case '\"':
buffer[j++] = QuoteChar;
buffer[j++] = '\"';
break;
case '\'':
buffer[j++] = '\\';
buffer[j++] = '\'';
break;
default:
buffer[j++] = string[i];
break;
}
}
buffer[j] = 0;
BufferStore( "\"%s\"", buffer );
BufferPrint();
MemFree( buffer );
switch( type ) {
case ASCII:
return( strlen( string ) );
case ASCIZ:
return( strlen( string ) + 1 );
}
// shouldn't get here, but compiler complains.
return( 0 );
}
return_val DumpASMSection( section_ptr section, unsigned_8 *contents, dis_sec_size size, unsigned pass )
{
hash_data *h_data;
label_list sec_label_list;
label_entry l_entry;
ref_list sec_ref_list;
ref_entry r_entry;
return_val err;
hash_key h_key;
h_key.u.sec_handle = section->shnd;
h_data = HashTableQuery( HandleToLabelListTable, h_key );
if( h_data != NULL ) {
sec_label_list = h_data->u.sec_label_list;
l_entry = sec_label_list->first;
} else {
sec_label_list = NULL;
l_entry = NULL;
}
r_entry = NULL;
h_data = HashTableQuery( HandleToRefListTable, h_key );
if( h_data != NULL ) {
sec_ref_list = h_data->u.sec_ref_list;
if( sec_ref_list != NULL ) {
r_entry = sec_ref_list->first;
}
}
if( pass == 1 ) {
DoPass1Relocs( contents, r_entry, 0, size );
return( RC_OKAY );
}
if( size == 0 ) {
if( IsMasmOutput() ) {
PrintHeader( section );
dumpAsmLabel( l_entry, section, 0, 0, NULL, NULL );
PrintTail( section );
}
return( RC_OKAY );
}
PrintHeader( section );
err = DumpASMDataFromSection( contents, 0, size, &l_entry, &r_entry, section );
if( size > 0 ) {
l_entry = dumpAsmLabel( l_entry, section, size, size, NULL, NULL );
}
BufferConcatNL();
BufferPrint();
if( err == RC_OKAY ) {
PrintTail( section );
}
return( err );
}
return_val DumpASMSection( section_ptr sec, unsigned_8 *contents, orl_sec_size size, unsigned pass )
{
hash_data *data_ptr;
label_list sec_label_list;
label_entry l_entry;
ref_list sec_ref_list;
ref_entry r_entry;
return_val err;
data_ptr = HashTableQuery( HandleToLabelListTable, (hash_value) sec->shnd );
if( data_ptr ) {
sec_label_list = (label_list) *data_ptr;
l_entry = sec_label_list->first;
} else {
sec_label_list = NULL;
l_entry = NULL;
}
r_entry = NULL;
data_ptr = HashTableQuery( HandleToRefListTable, (hash_value) sec->shnd );
if( data_ptr ) {
sec_ref_list = (ref_list) *data_ptr;
if( sec_ref_list != NULL ) {
r_entry = sec_ref_list->first;
}
}
if( pass == 1 ) {
DoPass1Relocs( contents, r_entry, 0, size );
return( RC_OKAY );
}
if( size == 0 ) {
if( IsMasmOutput() ) {
PrintHeader( sec );
dumpAsmLabel( l_entry, sec, 0, 0, NULL, NULL );
PrintTail( sec );
}
return( RC_OKAY );
}
PrintHeader( sec );
err = DumpASMDataFromSection( contents, 0, size, &l_entry, &r_entry, sec );
if( size > 0 ) {
l_entry = dumpAsmLabel( l_entry, sec, size, size, NULL, NULL );
}
BufferConcatNL();
BufferPrint();
if( err == RC_OKAY ) {
PrintTail( sec );
}
return( err );
}
void ASIOSocketWrapper::sendToWire(const MultiplexedSocketPtr&parentMultiSocket, TimestampedChunk toSend) {
//sending a single chunk is a straightforward call directly to asio
mToSend.resize(0);
mToSend.push_back(toSend);
BufferPrint(this,".buw",&*toSend.chunk->begin(),toSend.size());
mOutstandingDataParent=parentMultiSocket;//keep parent alive until send finishes
boost::asio::async_write(*mSocket,
boost::asio::buffer(&*toSend.chunk->begin(),toSend.size()),
boost::asio::transfer_at_least(toSend.size()),
mSendManyDequeItems);
}
void PrintErrorMsg( return_val exit_code, int where )
{
ChangePrintDest( STDERR_FILENO );
if( exit_code == RC_OUT_OF_MEMORY ) {
BufferMsg( OUT_OF_MEMORY );
} else if( exit_code == RC_ERROR ) {
BufferMsg( ERROR_OCCURRED );
}
BufferMsg( where );
BufferConcatNL();
BufferPrint();
ChangePrintDest( OutputDest );
}
void PrintPowerupHelp( gentity_t *ent )
{
int i = 0;
BeginBufferPrint();
BufferPrint(ent, "Powerup:\n");
BufferPrint(ent, "Usage: /powerup [name|any|random]\n");
BufferPrint(ent, "name: spawns a specified powerup.\n");
BufferPrint(ent, "list of powerups: ");
for(; i < numPowerups; i++)
{
BufferPrint(ent, va("%s ", powerups[i].name));
}
BufferPrint(ent, "\nany: spawns a powerup that can be any powerup.\n");
BufferPrint(ent, "random: spawns a random powerup that is always the same.");
FinishBufferPrint(ent);
}
static void processDataInCode( section_ptr sec, unsigned_8 *contents, struct pass2 *data,
orl_sec_size size, label_entry *l_entry )
{
orl_sec_size offset;
offset = data->loop + size;
if( DFormat & DFF_ASM ) {
DumpASMDataFromSection( contents, data->loop, offset, l_entry,
&(data->r_entry), sec );
BufferPrint();
} else {
DumpDataFromSection( contents, data->loop, offset, l_entry,
&(data->r_entry), sec );
}
while( data->r_entry && ( data->r_entry->offset < offset ) ) {
data->r_entry = data->r_entry->next;
}
data->loop = offset;
}
void ASIOSocketWrapper::sendToWire(const MultiplexedSocketPtr&parentMultiSocket, std::deque<TimestampedChunk>&input_toSend) {
std::vector<boost::asio::mutable_buffer> bufs;
size_t total_size=0;
for (std::deque<TimestampedChunk>::const_iterator i=input_toSend.begin(),ie=input_toSend.end(); i!=ie; ++i) {
size_t cursize=i->chunk->size();
bufs.push_back(boost::asio::buffer(&*i->chunk->begin(),cursize));
total_size+=cursize;
if( cursize) {
BufferPrint(this,".buw",&*i->chunk->begin(),cursize);
}
}
mToSend.swap(input_toSend);
mOutstandingDataParent=parentMultiSocket;//keep parent alive until send finishes
boost::asio::async_write(*mSocket,
bufs,
boost::asio::transfer_at_least(total_size),
mSendManyDequeItems);
}
static label_entry dumpAsmLabel( label_entry l_entry, section_ptr sec,
orl_sec_offset curr_pos, orl_sec_offset end,
unsigned_8 *contents, char *buffer )
{
int raw;
int is_masm;
end = end;
raw = buffer && contents;
is_masm = IsMasmOutput();
while( l_entry != NULL
&& ( l_entry->type == LTYP_ABSOLUTE || l_entry->offset <= curr_pos ) ) {
switch( l_entry->type ) {
case( LTYP_ABSOLUTE ):
// no print any absolute label here
break;
case( LTYP_SECTION ):
if( is_masm )
break;
/* fall through */
case( LTYP_NAMED ):
if( strcmp( l_entry->label.name, sec->name ) == 0 )
break;
/* fall through */
case( LTYP_UNNAMED ):
if( raw ) {
strncpy( buffer, (char *)contents + curr_pos, sizeof( unsigned_32 ) );
}
if( l_entry->type == LTYP_UNNAMED ) {
if( !(DFormat & DFF_ASM) ) {
BufferStore( "\t %04X\t%c$%d:", LabelChar, curr_pos,
l_entry->label.number );
if( raw ) {
printRawAndAddress( buffer, curr_pos );
}
} else {
if( l_entry->offset != curr_pos ) {
BufferStore( "%c$%d equ $-%d", LabelChar, l_entry->label.number, (int)( curr_pos - l_entry->offset ) );
} else {
BufferStore( "%c$%d:", LabelChar, l_entry->label.number );
}
}
} else {
if( !(DFormat & DFF_ASM) ) {
BufferStore( "\t %04X\t%s:", curr_pos,
l_entry->label.name );
if( raw ) {
printRawAndAddress( buffer, curr_pos );
}
} else {
if( l_entry->offset != curr_pos ) {
BufferStore( "%s equ $-%d", l_entry->label.name, (int)( curr_pos - l_entry->offset ) );
} else {
BufferStore( "%s:", l_entry->label.name );
}
}
}
BufferConcatNL();
BufferPrint();
}
l_entry = l_entry->next;
}
return( l_entry );
}
static label_entry dumpAsmLabel( label_entry l_entry, section_ptr section,
dis_sec_offset curr_pos, dis_sec_offset end,
unsigned_8 *contents, char *buffer )
{
bool raw;
bool is_masm;
/* unused parameters */ (void)end;
raw = ( buffer != NULL && contents != NULL );
is_masm = IsMasmOutput();
for( ; l_entry != NULL && ( l_entry->type == LTYP_ABSOLUTE || l_entry->offset <= curr_pos ); l_entry = l_entry->next ) {
switch( l_entry->type ) {
case LTYP_ABSOLUTE:
// no print any absolute label here
break;
case LTYP_SECTION:
if( is_masm )
break;
/* fall through */
case LTYP_NAMED:
if( strcmp( l_entry->label.name, section->name ) == 0 )
break;
/* fall through */
case LTYP_UNNAMED:
if( raw ) {
strncpy( buffer, (char *)contents + curr_pos, sizeof( unsigned_32 ) );
}
if( l_entry->type == LTYP_UNNAMED ) {
if( (DFormat & DFF_ASM) == 0 ) {
BufferStore( "\t %04X\t%c$%d:", LabelChar, curr_pos, l_entry->label.number );
if( raw ) {
printRawAndAddress( buffer, curr_pos );
}
} else {
if( l_entry->offset != curr_pos ) {
BufferStore( "%c$%d equ $-%d", LabelChar, l_entry->label.number, (int)( curr_pos - l_entry->offset ) );
} else {
BufferStore( "%c$%d:", LabelChar, l_entry->label.number );
}
}
} else {
if( (DFormat & DFF_ASM) == 0 ) {
BufferStore( "\t %04X\t%s:", curr_pos, l_entry->label.name );
if( raw ) {
printRawAndAddress( buffer, curr_pos );
}
} else {
if( l_entry->offset != curr_pos ) {
BufferStore( "%s equ $-%d", l_entry->label.name, (int)( curr_pos - l_entry->offset ) );
} else {
BufferStore( "%s:", l_entry->label.name );
}
}
}
BufferConcatNL();
BufferPrint();
}
}
return( l_entry );
}
size_t HandleAReference( dis_value value, int ins_size, ref_flags flags,
orl_sec_offset offset, orl_sec_size sec_size,
ref_entry * r_entry, char *buff )
// handle any references at this offset
{
return_val error;
dis_value nvalue;
char *p;
buff[0] = '\0';
for( ; *r_entry && (*r_entry)->offset == offset; *r_entry = (*r_entry)->next ) {
if( (*r_entry)->no_val == 0 ) {
nvalue = value;
} else if( (*r_entry)->addend ) {
nvalue = HandleAddend( *r_entry );
} else {
nvalue = 0;
}
switch( (*r_entry)->type ) {
case ORL_RELOC_TYPE_MAX + 1:
case ORL_RELOC_TYPE_JUMP:
case ORL_RELOC_TYPE_REL_21_SH:
case ORL_RELOC_TYPE_WORD_26:
error = referenceString( *r_entry, sec_size, "j^", "", "",
buff, flags );
if( error != RC_OKAY ) {
// label is defined to be beyond the boundaries of the section!
if( !(DFormat & DFF_ASM) ){
BufferStore("\t %04X", offset );
BufferAlignToTab( COMMENT_TAB_POS );
} else {
BufferConcat("\t" );
}
BufferConcat( CommentString );
BufferMsg( LABEL_BEYOND_SECTION );
BufferConcatNL();
BufferPrint();
*r_entry = (*r_entry)->next;
return( 0 );
}
continue; // Don't print addend
break;
case ORL_RELOC_TYPE_SEC_REL:
referenceString( *r_entry, sec_size, "s^", "s^", "@s", buff,
flags );
break;
case ORL_RELOC_TYPE_HALF_HI:
referenceString( *r_entry, sec_size, "h^", "h^", "@h", buff,
flags );
break;
case ORL_RELOC_TYPE_HALF_HA:
referenceString( *r_entry, sec_size, "ha^", "ha^", "@ha", buff,
flags );
break;
case ORL_RELOC_TYPE_HALF_LO:
referenceString( *r_entry, sec_size, "l^", "l^", "@l", buff,
flags );
break;
case ORL_RELOC_TYPE_REL_14:
case ORL_RELOC_TYPE_REL_24:
case ORL_RELOC_TYPE_WORD_14:
case ORL_RELOC_TYPE_WORD_24:
nvalue &= ~0x3;
case ORL_RELOC_TYPE_WORD_16:
case ORL_RELOC_TYPE_WORD_32:
case ORL_RELOC_TYPE_WORD_64:
if( ( (*r_entry)->label->type != LTYP_GROUP ) &&
( flags & RFLAG_IS_IMMED ) && IsMasmOutput() ) {
referenceString( *r_entry, sec_size, "offset ", "offset ",
"", buff, flags );
} else {
referenceString( *r_entry, sec_size, "", "", "", buff,
flags );
}
break;
case ORL_RELOC_TYPE_REL_16:
if( IsIntelx86() && !(*r_entry)->no_val ) {
nvalue -= ins_size;
}
if( ( (*r_entry)->label->type != LTYP_GROUP ) &&
( flags & RFLAG_IS_IMMED ) && IsMasmOutput() ) {
referenceString( *r_entry, sec_size, "offset ", "offset ",
"", buff, flags );
} else {
referenceString( *r_entry, sec_size, "", "", "", buff,
flags );
}
break;
case ORL_RELOC_TYPE_WORD_8:
case ORL_RELOC_TYPE_WORD_16_SEG:
case ORL_RELOC_TYPE_WORD_HI_8:
case ORL_RELOC_TYPE_WORD_32_SEG:
// Keep these seperate because they are OMF specific
referenceString( *r_entry, sec_size, "", "", "", buff, flags );
break;
case ORL_RELOC_TYPE_SEGMENT:
if( ( (*r_entry)->label->type != LTYP_GROUP )
&& ( (*r_entry)->label->type != LTYP_SECTION )
&& ( flags & RFLAG_IS_IMMED )
&& IsMasmOutput() ) {
referenceString( *r_entry, sec_size, "seg ", "seg ", "",
buff, flags );
} else {
referenceString( *r_entry, sec_size, "", "", "", buff,
flags );
}
break;
case ORL_RELOC_TYPE_REL_32_NOADJ:
// this is a little kluge because Brian's ELF files seem to have
// -4 in the implicit addend for calls and such BBB May 09, 1997
nvalue += 4;
// fall through
case ORL_RELOC_TYPE_REL_8:
case ORL_RELOC_TYPE_REL_16_SEG:
case ORL_RELOC_TYPE_REL_HI_8:
case ORL_RELOC_TYPE_REL_32_SEG:
case ORL_RELOC_TYPE_REL_32:
case ORL_RELOC_TYPE_REL_32_ADJ5:
case ORL_RELOC_TYPE_REL_32_ADJ4:
case ORL_RELOC_TYPE_REL_32_ADJ3:
case ORL_RELOC_TYPE_REL_32_ADJ2:
case ORL_RELOC_TYPE_REL_32_ADJ1:
// For some reason we add the instruction size to the value
// of the displacement in a relative call and get a bad
// offset, due to CORE implementation
//
// Main reason :
// instruction size with displacement and with addend is correct for
// relative addresses without relocate
//
// in amd64 code the instruction size will be added in pass1.c!
if( (*r_entry)->no_val == 0 && !( GetMachineType() == ORL_MACHINE_TYPE_AMD64 ) ) {
nvalue -= ins_size;
}
referenceString( *r_entry, sec_size, "", "", "", buff, flags );
break;
case ORL_RELOC_TYPE_TOCREL_14:
nvalue &= ~0x3;
case ORL_RELOC_TYPE_TOCREL_16:
referenceString( *r_entry, sec_size, "[toc]", "[toc]", "@toc",
buff, flags );
break;
case ORL_RELOC_TYPE_TOCVREL_14:
nvalue &= ~0x3;
case ORL_RELOC_TYPE_TOCVREL_16:
referenceString( *r_entry, sec_size, "[tocv]", "[tocv]", "@tocv",
buff, flags );
break;
case ORL_RELOC_TYPE_GOT_16:
referenceString( *r_entry, sec_size, "", "", "@got", buff, flags );
break;
case ORL_RELOC_TYPE_GOT_16_HI:
referenceString( *r_entry, sec_size, "", "", "@got@h", buff, flags );
break;
case ORL_RELOC_TYPE_GOT_16_HA:
referenceString( *r_entry, sec_size, "", "", "@got@ha", buff, flags );
break;
case ORL_RELOC_TYPE_GOT_16_LO:
referenceString( *r_entry, sec_size, "", "", "@got@l", buff, flags );
break;
case ORL_RELOC_TYPE_PLTREL_24:
case ORL_RELOC_TYPE_PLTREL_32:
case ORL_RELOC_TYPE_PLT_32:
referenceString( *r_entry, sec_size, "", "", "@plt", buff, flags );
break;
case ORL_RELOC_TYPE_PLT_16_HI:
referenceString( *r_entry, sec_size, "", "", "@plt@h", buff, flags );
break;
case ORL_RELOC_TYPE_PLT_16_HA:
referenceString( *r_entry, sec_size, "", "", "@plt@ha", buff, flags );
break;
case ORL_RELOC_TYPE_PLT_16_LO:
referenceString( *r_entry, sec_size, "", "", "@plt@l", buff, flags );
break;
default:
continue;
}
// LTYP_UNNAMED labels are always at the correct location
// if( nvalue != 0 && (*r_entry)->label->type != LTYP_UNNAMED ) {
// not so - BBB Oct 28, 1996
if(( (*r_entry)->no_val == 0 ) && ( nvalue != 0 )) {
p = &buff[strlen(buff)];
if( nvalue < 0 ) {
*p++ = '-';
nvalue = -nvalue;
} else {
*p++ = '+';
}
FmtHexNum( p, 0, nvalue, FALSE );
}
}
return( strlen( buff ) );
}
static void printUnixHeader( section_ptr sec )
{
orl_sec_alignment alignment;
orl_sec_flags flags;
orl_sec_type type;
char attributes[10];
char * ca;
alignment = ORLSecGetAlignment( sec->shnd );
type = ORLSecGetType( sec->shnd );
flags = ORLSecGetFlags( sec->shnd );
ca = attributes;
if( !(Options & METAWARE_COMPATIBLE) ) {
if( (flags & ORL_SEC_FLAG_EXEC) || sec->type == SECTION_TYPE_TEXT ) {
*ca++ = 'c';
}
if( (flags & ORL_SEC_FLAG_INITIALIZED_DATA) || sec->type == SECTION_TYPE_DATA || sec->type == SECTION_TYPE_PDATA ) {
*ca++ = 'd';
}
if( (flags & ORL_SEC_FLAG_UNINITIALIZED_DATA) || sec->type == SECTION_TYPE_BSS ) {
*ca++ = 'u';
}
if( (type == ORL_SEC_TYPE_NOTE) || sec->type == SECTION_TYPE_DRECTVE ) {
*ca++ = 'i';
}
if( flags & ORL_SEC_FLAG_DISCARDABLE ) {
*ca++ = 'n';
}
if( flags & ORL_SEC_FLAG_REMOVE ) {
*ca++ = 'R';
}
if( flags & ORL_SEC_FLAG_READ_PERMISSION ) {
*ca++ = 'r';
}
if( flags & ORL_SEC_FLAG_WRITE_PERMISSION ) {
*ca++ = 'w';
}
if( flags & ORL_SEC_FLAG_EXECUTE_PERMISSION ) {
*ca++ = 'x';
}
if( flags & ORL_SEC_FLAG_SHARED ) {
*ca++ = 's';
}
*ca++ = '0' + alignment;
*ca = '\0';
if( !( DFormat & DFF_ASM ) ){
BufferConcat("\t\t\t\t");
}
BufferStore(".new_section %s, \"%s\"", sec->name, attributes );
} else {
if( !(flags & ORL_SEC_FLAG_REMOVE ) ) {
*ca++ = 'a';
}
if( flags & ORL_SEC_FLAG_EXEC ) {
*ca++ = 'x';
}
if( flags & ORL_SEC_FLAG_WRITE_PERMISSION ) {
*ca++ = 'w';
}
*ca++ = '\0';
if( !( DFormat & DFF_ASM ) ) {
BufferConcat("\t\t\t\t");
}
BufferStore(".section %s, \"%s\"", sec->name, attributes );
BufferConcatNL();
if( !( DFormat & DFF_ASM ) ) {
BufferConcat("\t\t\t\t");
}
BufferStore(".align %d", (int)alignment );
}
BufferConcatNL();
BufferPrint();
}
void HandleArgs( char *cmd )
{
char * ptr;
bool list_file = FALSE;
DFormat |= DFF_PSEUDO | DFF_SYMBOLIC_REG;
cmd = skipBlanks( cmd );
if( *cmd == '\0' || *cmd == '?' ) {
printUsage( 0 );
} else {
while( *cmd ) {
if( IS_OPT_DELIM( *cmd ) ) {
cmd++;
switch( tolower( *cmd ) ) {
case 'a':
DFormat |= DFF_ASM;
if( cmd[1] == 'u' ) {
++cmd;
DFormat |= DFF_X86_UNIX;
}
break;
case 'e':
Options |= PRINT_EXTERNS;
break;
case 'i':
cmd++;
if( *cmd == '=' ) {
cmd++;
if( !isspace( *cmd ) ) {
LabelChar = toupper( *cmd );
} else {
printUsage( INVALID_I );
}
} else {
printUsage( INVALID_I );
}
break;
case 'l':
if( ListFileName ) {
printUsage( ONLY_ONE_LISTING );
}
list_file = TRUE;
cmd++;
if( *cmd == '=' ) {
cmd++;
ptr = cmd;
cmd = FindNextWS( cmd );
ListFileName = getFileName( ptr, cmd );
}
break;
case 'f':
switch( cmd[1] ) {
case 'p':
DFormat ^= DFF_PSEUDO;
++cmd;
break;
case 'r':
DFormat ^= DFF_SYMBOLIC_REG;
++cmd;
break;
case 'f':
Options |= PRINT_FPU_EMU_FIXUP;
break;
case 'i':
DFormat ^= DFF_X86_ALT_INDEXING;
++cmd;
break;
case 'u':
++cmd;
switch( cmd[1] ) {
case 'r':
DFormat ^= DFF_REG_UP;
++cmd;
break;
case 'i':
DFormat ^= DFF_INS_UP;
++cmd;
break;
default:
DFormat ^= DFF_INS_UP | DFF_REG_UP;
}
break;
}
break;
case 'm':
if( cmd[1] == 'w' ) {
Options |= METAWARE_COMPATIBLE;
++cmd;
break;
}
Options |= NODEMANGLE_NAMES;
break;
case 'p':
Options |= PRINT_PUBLICS;
break;
case 's':
if( SourceFileName ) {
printUsage( ONLY_ONE_SOURCE );
}
source_mix = TRUE;
cmd++;
if( *cmd == '=' ) {
cmd++;
ptr = cmd;
cmd = FindNextWS( cmd );
SourceFileName = getFileName( ptr, cmd );
}
break;
default:
BufferMsg( INVALID_OPTION );
BufferStore( " -%c\n\n", *cmd );
BufferPrint();
printUsage( 0 );
break;
}
} else {
if( ObjFileName ) {
printUsage( ONLY_ONE_OBJECT );
}
ptr = cmd;
cmd = FindNextWS( cmd );
ObjFileName = getFileName( ptr, cmd );
}
cmd = skipToNextArg( cmd );
}
}
if( !ObjFileName ) {
printUsage( NO_OBJECT );
}
composeFileNames( list_file );
if( DFormat & DFF_ASM ) {
Options &= ~(PRINT_PUBLICS | PRINT_EXTERNS);
}
}
static return_val bssUnixASMSection( section_ptr sec, orl_sec_size size,
label_entry l_entry )
{
orl_sec_offset dsiz = 0;
char *prefix;
label_entry prev_entry;
if( ( size == 0 ) && ( l_entry == NULL ) )
return( RC_OKAY );
PrintHeader( sec );
prev_entry = NULL;
for( ; l_entry != NULL; l_entry = l_entry->next ) {
if( ( l_entry->type == LTYP_SECTION ) && ( strcmp( l_entry->label.name, sec->name ) == 0 ) ) {
continue;
} else if( prev_entry == NULL ) {
prev_entry = l_entry;
continue;
} else if( prev_entry->offset > l_entry->offset ) {
continue;
} else if( prev_entry->offset == l_entry->offset ) {
dsiz = 0;
prefix = "";
} else {
dsiz = l_entry->offset - prev_entry->offset;
prefix = " .lcomm\t";
}
switch( prev_entry->type ) {
case LTYP_UNNAMED:
BufferStore( "%s%c$%d", prefix, LabelChar, prev_entry->label.number );
break;
case LTYP_SECTION:
case LTYP_NAMED:
BufferStore( "%s%s", prefix, prev_entry->label.name );
break;
default:
break;
}
if( dsiz ) {
BufferStore( ", 0x%08x", dsiz );
} else {
BufferConcat( ":" );
}
BufferConcatNL();
BufferPrint();
prev_entry = l_entry;
}
if( prev_entry != NULL ) {
if( prev_entry->offset < size ) {
dsiz = size - prev_entry->offset;
prefix = " .lcomm\t";
} else {
dsiz = 0;
prefix = "";
}
switch( prev_entry->type ) {
case LTYP_UNNAMED:
BufferStore( "%s%c$%d", prefix, LabelChar, prev_entry->label.number );
break;
case LTYP_SECTION:
case LTYP_NAMED:
BufferStore( "%s%s", prefix, prev_entry->label.name );
break;
default:
break;
}
if( dsiz ) {
BufferStore( ", 0x%08x", dsiz );
} else {
BufferConcat( ":" );
}
BufferConcatNL();
BufferPrint();
}
BufferConcatNL();
BufferPrint();
return( RC_OKAY );
}
num_errors DoPass2( section_ptr sec, unsigned_8 *contents, orl_sec_size size,
label_list sec_label_list, ref_list sec_ref_list )
// perform pass 2 on one section
{
struct pass2 data;
label_entry l_entry;
dis_dec_ins decoded;
char name[ MAX_INS_NAME ];
char ops[ MAX_OBJ_NAME + 24 ]; // at most 1 label/relocation per instruction, plus room for registers, brackets and other crap
dis_inst_flags flags;
scantab_ptr st;
int is_intel;
sa_disasm_struct sds;
char *FPU_fixup;
int pos_tabs;
bool is32bit;
routineBase = 0;
st = sec->scan;
data.size = size;
sds.data = contents;
sds.last = size - 1;
l_entry = NULL;
if( sec_label_list != NULL ) {
l_entry = sec_label_list->first;
}
if( sec_ref_list != NULL ) {
data.r_entry = sec_ref_list->first;
} else {
data.r_entry = NULL;
}
data.disassembly_errors = 0;
if( source_mix ) {
GetSourceFile( sec );
}
PrintHeader( sec );
if( size && sec_label_list )
PrintAssumeHeader( sec );
flags.u.all = DIF_NONE;
if( GetMachineType() == ORL_MACHINE_TYPE_I386 ) {
if( ( GetFormat() != ORL_OMF ) ||
( ORLSecGetFlags( sec->shnd ) & ORL_SEC_FLAG_USE_32 ) ) {
flags.u.x86 = DIF_X86_USE32_FLAGS;
}
is_intel = 1;
} else {
is_intel = IsIntelx86();
}
is32bit = ( size >= 0x10000 );
for( data.loop = 0; data.loop < size; data.loop += decoded.size ) {
// process data in code segment
while( st && ( data.loop > st->end ) ) {
st = st->next;
}
if( st && ( data.loop >= st->start ) ) {
decoded.size = 0;
processDataInCode( sec, contents, &data, st->end - data.loop, &l_entry );
st = st->next;
continue;
}
// data may not be listed in scan table, but a fixup at this offset will
// give it away
while( data.r_entry && ( data.r_entry->offset < data.loop ) ) {
data.r_entry = data.r_entry->next;
}
FPU_fixup = processFpuEmulatorFixup( &data.r_entry, data.loop );
if( data.r_entry && ( data.r_entry->offset == data.loop ) ) {
if( is_intel || IsDataReloc( data.r_entry ) ) {
// we just skip the data
decoded.size = 0;
processDataInCode( sec, contents, &data, RelocSize( data.r_entry ), &l_entry );
continue;
}
}
if( source_mix ) {
MixSource( data.loop );
}
DisDecodeInit( &DHnd, &decoded );
decoded.flags.u.all |= flags.u.all;
sds.offs = data.loop;
DisDecode( &DHnd, &sds, &decoded );
if( sec_label_list ) {
l_entry = handleLabels( sec->name, data.loop, data.loop + decoded.size, l_entry, size );
if( ( l_entry != NULL )
&& ( l_entry->offset > data.loop )
&& ( l_entry->offset < data.loop + decoded.size ) ) {
/*
If we have a label planted in the middle of this
instruction (see inline memchr for example), put
out a couple of data bytes, and then restart decode
and label process from offset of actual label.
*/
decoded.size = 0;
processDataInCode( sec, contents, &data, l_entry->offset - data.loop, &l_entry );
continue;
}
}
DisFormat( &DHnd, &data, &decoded, DFormat, name, sizeof( name ), ops, sizeof( ops ) );
if( FPU_fixup != NULL ) {
if( !(DFormat & DFF_ASM) ) {
BufferAlignToTab( PREFIX_SIZE_TABS );
}
BufferStore( "\t%sFPU fixup %s\n", CommentString, FPU_fixup );
}
if( !(DFormat & DFF_ASM) ) {
unsigned_64 *tmp_64;
unsigned_32 *tmp_32;
unsigned_16 *tmp_16;
tmp_64 = (unsigned_64 *)(contents + data.loop);
tmp_32 = (unsigned_32 *)(contents + data.loop);
tmp_16 = (unsigned_16 *)(contents + data.loop);
if( DHnd.need_bswap ) {
switch( DisInsSizeInc( &DHnd ) ) {
//case 8: SWAP_64( *tmp_64 );
// break;
case 4: SWAP_32( *tmp_32 );
break;
case 2: SWAP_16( *tmp_16 );
break;
default:
break;
}
}
PrintLinePrefixAddress( data.loop, is32bit );
PrintLinePrefixData( contents, data.loop, size, DisInsSizeInc( &DHnd ), decoded.size );
BufferAlignToTab( PREFIX_SIZE_TABS );
}
BufferStore( "\t%s", name );
if( *ops != '\0' ) {
pos_tabs = ( DisInsNameMax( &DHnd ) + TAB_WIDTH ) / TAB_WIDTH + 1;
if( !(DFormat & DFF_ASM) ) {
pos_tabs += PREFIX_SIZE_TABS;
}
BufferAlignToTab( pos_tabs );
BufferConcat( ops );
}
BufferConcatNL();
BufferPrint();
}
if( sec_label_list ) {
l_entry = handleLabels( sec->name, size, (orl_sec_offset)-1, l_entry, size );
}
if( !(DFormat & DFF_ASM) ) {
routineSize = data.loop - routineBase;
BufferConcatNL();
BufferMsg( ROUTINE_SIZE );
BufferStore(" %d ", routineSize );
BufferMsg( BYTES );
BufferConcat(", ");
BufferMsg( ROUTINE_BASE );
BufferStore(" %s + %04X\n\n", sec->name, routineBase );
BufferPrint();
}
if( source_mix ) {
EndSourceMix();
}
PrintTail( sec );
return( data.disassembly_errors );
}
return_val DumpASMDataFromSection( unsigned_8 *contents, orl_sec_offset start,
orl_sec_offset end, label_entry *labent,
ref_entry *refent, section_ptr sec )
{
size_t curr_pos;
size_t curr_size;
size_t tmp_size;
size_t size;
label_entry l_entry;
ref_entry r_entry;
char *buffer;
l_entry = *labent;
r_entry = *refent;
size = end - start;
if( size < sizeof( unsigned_32 ) )
size = sizeof( unsigned_32 );
buffer = MemAlloc( size + 1 );
if( !buffer ) {
PrintErrorMsg( RC_OUT_OF_MEMORY, WHERE_PRINT_SECTION );
return( RC_OUT_OF_MEMORY );
}
for( curr_pos = start; curr_pos < end; curr_pos += curr_size ) {
/* dump labels
*/
l_entry = dumpAsmLabel( l_entry, sec, curr_pos, end, contents, buffer );
curr_size = end - curr_pos;
if( l_entry != NULL ) {
tmp_size = l_entry->offset - curr_pos;
if( tmp_size < curr_size ) {
curr_size = tmp_size;
}
}
/* Skip over pair relocs */
while( r_entry != NULL && (r_entry->type == ORL_RELOC_TYPE_PAIR || r_entry->offset < curr_pos) ) {
r_entry = r_entry->next;
}
if( r_entry != NULL && r_entry->offset < (curr_pos + curr_size) ) {
if( r_entry->offset == curr_pos ) {
BufferConcat(" ");
curr_size = HandleRefInData(r_entry, contents + curr_pos, TRUE);
BufferConcatNL();
BufferPrint();
continue;
} else {
tmp_size = r_entry->offset - curr_pos;
if( tmp_size < curr_size ) {
curr_size = tmp_size;
}
}
}
memcpy( buffer, (contents + curr_pos), curr_size );
buffer[ curr_size ] = 0;
printOut( buffer, curr_pos, curr_size );
}
*labent = l_entry;
*refent = r_entry;
MemFree( buffer );
return( RC_OKAY );
}
