STATIC int writeComdat( obj_rec *objr, pobj_state *state ) {
OBJ_WFILE *out;
uint_8 *ptr;
uint_16 len;
uint_16 save;
int is32;
/**/myassert( objr != NULL );
/**/myassert( objr->command == CMD_COMDAT );
/**/myassert( state != NULL );
/**/myassert( state->pass == POBJ_WRITE_PASS );
save = ObjRTell( objr );
is32 = objr->is_32 || objr->is_phar;
if( is32 ) {
objr->command |= 1;
}
out = state->file_out;
ObjWBegRec( out, objr->command );
ObjWrite8( out, objr->d.comdat.flags );
ObjWrite8( out, objr->d.comdat.attributes );
ObjWrite8( out, objr->d.comdat.align );
if( is32 ) {
ObjWrite32( out, objr->d.comdat.offset );
} else {
ObjWrite16( out, (uint_16)objr->d.comdat.offset );
}
ObjWriteIndex( out, objr->d.comdat.type_idx );
if( ( objr->d.comdat.attributes & COMDAT_ALLOC_MASK ) == COMDAT_EXPLICIT ) {
writeBase( objr, out );
}
ObjWriteIndex( out, objr->d.comdat.public_name_idx );
if( ( objr->d.comdat.flags & COMDAT_ITERATED ) == 0 || objr->is_phar == 0 ) {
/* record is already in ms omf format */
len = ObjRemain( objr );
ptr = ObjGet( objr, len );
/**/ myassert( len <= 1024 );
ObjWrite( out, ptr, len );
} else {
int_16 delta;
uint_16 first_block_offset;
delta = 0; /* id32Block needs to play with this */
first_block_offset = ObjRTell( objr );
while( !ObjEOR( objr ) ) {
id32Block( objr, out, &delta, first_block_offset );
}
}
ObjWEndRec( out );
ObjRSeek( objr, save );
return( 0 );
}
void WriteOptions (void)
/* Write the options to the object file */
{
Option* O;
/* Tell the object file module that we're about to start the options */
ObjStartOptions ();
/* Write the option count */
ObjWriteVar (OptCount);
/* Walk through the list and write the options */
O = OptRoot;
while (O) {
/* Write the type of the option, then the value */
ObjWrite8 (O->Type);
ObjWriteVar (O->Val);
/* Next option */
O = O->Next;
}
/* Done writing options */
ObjEndOptions ();
}
STATIC void id32Block( obj_rec *objr, OBJ_WFILE *out, int_16 *delta,
uint_16 first_block_offset ) {
/*
Since LIDATAs are different under PharLap and MicroSoft 386 formats,
we have to do some magic.
*/
uint_16 rpt_count;
uint_16 blk_count;
uint_8 data_count;
uint_8 *ptr;
rpt_count = ObjGet16( objr );
ObjWrite32( out, rpt_count );
*delta += 2; /* ok, everything from here on will be at +2 offset */
LifixAdd( &lifList, ObjRTell( objr ) - first_block_offset, *delta );
blk_count = ObjGet16( objr );
ObjWrite16( out, blk_count );
if( blk_count == 0 ) {
data_count = ObjGet8( objr );
ObjWrite8( out, data_count );
ptr = ObjGet( objr, data_count );
ObjWrite( out, ptr, data_count );
} else {
for( ; blk_count != 0; --blk_count ) {
id32Block( objr, out, delta, first_block_offset );
}
}
}
void WriteImports (void)
/* Write the imports list to the object file */
{
SymEntry* S;
/* Tell the object file module that we're about to start the imports */
ObjStartImports ();
/* Write the import count to the list */
ObjWriteVar (ImportCount);
/* Walk throught list and write all valid imports to the file. An import
** is considered valid, if it is either referenced, or the forced bit is
** set. Otherwise, the import is ignored (no need to link in something
** that isn't used).
*/
S = SymList;
while (S) {
if ((S->Flags & (SF_UNUSED | SF_IMPORT)) == SF_IMPORT &&
(S->Flags & (SF_REFERENCED | SF_FORCED)) != 0) {
ObjWrite8 (S->AddrSize);
ObjWriteVar (S->Name);
WriteLineInfo (&S->DefLines);
WriteLineInfo (&S->RefLines);
}
S = S->List;
}
/* Done writing imports */
ObjEndImports ();
}
STATIC int writeLinsym( obj_rec *objr, pobj_state *state ) {
int is32;
OBJ_WFILE *out;
/**/myassert( objr != NULL );
/**/myassert( objr->command == CMD_LINSYM );
/**/myassert( state != NULL );
/**/myassert( state->pass == POBJ_WRITE_PASS );
out = state->file_out;
is32 = objr->is_32 || objr->is_phar;
ObjWBegRec( out, is32 ? CMD_LINS32 : CMD_LINSYM );
ObjWrite8( out, objr->d.linsym.d.linsym.flags );
ObjWriteIndex( out, objr->d.linsym.d.linsym.public_name_idx );
writeLinnumData( objr, out );
ObjWEndRec( out );
return( 0 );
}
STATIC int writePubdef( obj_rec *objr, pobj_state *state ) {
int is32;
OBJ_WFILE *out;
const char *name;
size_t name_len;
pubdef_data *pubdata;
pubdef_data *pubstop;
/**/myassert( objr != NULL );
/**/myassert( objr->command == CMD_PUBDEF || objr->command == CMD_STATIC_PUBDEF );
/**/myassert( state != NULL );
/**/myassert( state->pass == POBJ_WRITE_PASS );
is32 = objr->is_32 || objr->is_phar;
if( is32 ) {
objr->command |= 1;
}
out = state->file_out;
ObjWBegRec( out, objr->command );
writeBase( objr, out );
pubdata = objr->d.pubdef.pubs;
if( pubdata != NULL ) {
pubstop = pubdata + objr->d.pubdef.num_pubs;
while( pubdata < pubstop ) {
name = NameGet( pubdata->name );
name_len = strlen( name );
if( name_len > 255 )
name_len = 255;
ObjWrite8( out, (uint_8)name_len );
ObjWrite( out, (uint_8 *)name, (uint_16)name_len );
if( is32 ) {
ObjWrite32( out, pubdata->offset );
} else {
ObjWrite16( out, (uint_16)pubdata->offset );
}
ObjWriteIndex( out, pubdata->type.idx );
++pubdata;
}
}
ObjWEndRec( out );
return( 0 );
}
STATIC int writeComent( obj_rec *objr, pobj_state *state ) {
uint_8 *ptr;
uint_16 len;
uint_16 save;
OBJ_WFILE *out;
/**/myassert( objr != NULL );
/**/myassert( objr->data != NULL );
/**/myassert( state != NULL );
/**/myassert( state->pass == POBJ_WRITE_PASS );
out = state->file_out;
ObjWBegRec( out, CMD_COMENT );
ObjWrite8( out, objr->d.coment.attr );
ObjWrite8( out, objr->d.coment.class );
save = ObjRTell( objr );
len = ObjRemain( objr );
ptr = ObjGet( objr, len );
ObjWrite( out, ptr, len );
ObjRSeek( objr, save );
ObjWEndRec( out );
return( 0 );
}
STATIC int writeSegdef( obj_rec *objr, pobj_state *state ) {
OBJ_WFILE *out;
int is32;
uint_8 acbp;
uint_8 align;
#if ( _WOMP_OPT & _WOMP_NASM )
obj_offset patch;
#endif
/**/myassert( objr != NULL );
/**/myassert( objr->command == CMD_SEGDEF );
/**/myassert( state != NULL );
/**/myassert( state->pass == POBJ_WRITE_PASS );
out = state->file_out;
#if ( _WOMP_OPT & _WOMP_WATFOR ) == 0
is32 = objr->d.segdef.use_32 != 0;
#else
#ifdef _WOMP_WATFOR_8086
is32 = 0;
#else
is32 = 1;
#endif
#endif
ObjWBegRec( out, is32 ? CMD_SEGD32 : CMD_SEGDEF );
acbp = objr->d.segdef.combine << 2;
if( is32 ) {
acbp |= 1;
}
align = objr->d.segdef.align;
switch( align ) {
case SEGDEF_ALIGN_ABS:
acbp |= ALIGN_ABS << 5;
break;
case SEGDEF_ALIGN_BYTE:
acbp |= ALIGN_BYTE << 5;
break;
case SEGDEF_ALIGN_WORD:
acbp |= ALIGN_WORD << 5;
break;
case SEGDEF_ALIGN_PARA:
acbp |= ALIGN_PARA << 5;
break;
case SEGDEF_ALIGN_PAGE:
acbp |= ALIGN_PAGE << 5;
break;
case SEGDEF_ALIGN_DWORD:
acbp |= ALIGN_DWORD << 5;
break;
case SEGDEF_ALIGN_4KPAGE:
acbp |= ALIGN_PAGE;
#if _WOMP_OPT & _WOMP_EXTRAS
PrtMsg( WRN|MSG_MS386_NO_4KPAGE );
#endif
break;
default:
/**/
never_reach();
}
if( !is32 && objr->d.segdef.seg_length == 0x10000 ) {
acbp |= 0x02; /* BIG bit */ /* FIXME no support for 2**32 */
}
ObjWrite8( out, acbp );
#if ( _WOMP_OPT & _WOMP_WATFOR ) == 0
if( align == SEGDEF_ALIGN_ABS ) {
// absolut segment has frame=word and offset=byte
// it isn't fixupp physical reference
// and don't depend on segment size (16/32bit)
ObjWrite16( out, objr->d.segdef.abs.frame );
ObjWrite8( out, (uint_8)objr->d.segdef.abs.offset );
}
#endif
if( is32 ) {
#if ( _WOMP_OPT & _WOMP_NASM )
patch = ObjWSkip32( out );
#else
ObjWrite32( out, objr->d.segdef.seg_length );
#endif
} else {
#if ( _WOMP_OPT & _WOMP_NASM )
patch = ObjWSkip16( out );
#else
ObjWrite16( out, (uint_16)objr->d.segdef.seg_length );
#endif
}
#if ( _WOMP_OPT & _WOMP_NASM )
/**/myassert( objr->data != NULL );
memcpy( objr->data, &patch, sizeof patch);
#endif
ObjWriteIndex( out, objr->d.segdef.seg_name_idx );
ObjWriteIndex( out, objr->d.segdef.class_name_idx );
#if ( _WOMP_OPT & _WOMP_WATFOR ) == 0
ObjWriteIndex( out, objr->d.segdef.ovl_name_idx );
#if ( _WOMP_OPT & _WOMP_EXTRAS )
if( objr->d.segdef.access_valid ) {
PrtMsg( MSG_MS386_NO_ACCESS );
}
#endif
#else
ObjWriteIndex( out, 1 );
#endif
ObjWEndRec( out );
return( 0 );
}
void WriteDbgSyms (void)
/* Write a list of all symbols to the object file */
{
unsigned Count;
SymEntry* S;
/* Tell the object file module that we're about to start the debug info */
ObjStartDbgSyms ();
/* Check if debug info is requested */
if (DbgSyms) {
/* Walk through the list, give each symbol an id and count them */
Count = 0;
S = SymList;
while (S) {
if (IsDbgSym (S)) {
S->DebugSymId = Count++;
}
S = S->List;
}
/* Write the symbol count to the list */
ObjWriteVar (Count);
/* Walk through list and write all symbols to the file. Ignore size
** symbols.
*/
S = SymList;
while (S) {
if (IsDbgSym (S)) {
/* Get the expression bits and the value */
long ConstVal;
unsigned SymFlags = GetSymInfoFlags (S, &ConstVal);
/* Check if this symbol has a size. If so, remember it in the
** flags.
*/
long Size;
SymEntry* SizeSym = FindSizeOfSymbol (S);
if (SizeSym != 0 && SymIsConst (SizeSym, &Size)) {
SymFlags |= SYM_SIZE;
}
/* Write the type */
ObjWriteVar (SymFlags);
/* Write the address size */
ObjWrite8 (S->AddrSize);
/* Write the id of the parent. For normal symbols, this is a
** scope (symbol table), for cheap locals, it's a symbol.
*/
if (SYM_IS_STD (SymFlags)) {
ObjWriteVar (S->Sym.Tab->Id);
} else {
ObjWriteVar (S->Sym.Entry->DebugSymId);
}
/* Write the name */
ObjWriteVar (S->Name);
/* Write the value */
if (SYM_IS_CONST (SymFlags)) {
/* Constant value */
ObjWrite32 (ConstVal);
} else {
/* Expression involved */
WriteExpr (S->Expr);
}
/* If the symbol has a size, write it to the file */
if (SYM_HAS_SIZE (SymFlags)) {
ObjWriteVar (Size);
}
/* If the symbol is an im- or export, write out the ids */
if (SYM_IS_IMPORT (SymFlags)) {
ObjWriteVar (GetSymImportId (S));
}
if (SYM_IS_EXPORT (SymFlags)) {
ObjWriteVar (GetSymExportId (S));
}
/* Write the line infos */
WriteLineInfo (&S->DefLines);
WriteLineInfo (&S->RefLines);
}
S = S->List;
}
} else {
/* No debug symbols */
ObjWriteVar (0);
}
/* Write the high level symbols */
WriteHLLDbgSyms ();
/* Done writing debug symbols */
ObjEndDbgSyms ();
}
void WriteExports (void)
/* Write the exports list to the object file */
{
SymEntry* S;
unsigned Type;
/* Tell the object file module that we're about to start the exports */
ObjStartExports ();
/* Write the export count to the list */
ObjWriteVar (ExportCount);
/* Walk throught list and write all exports to the file */
S = SymList;
while (S) {
if ((S->Flags & (SF_UNUSED | SF_EXPORT)) == SF_EXPORT) {
/* Get the expression bits and the value */
long ConstVal;
unsigned SymFlags = GetSymInfoFlags (S, &ConstVal);
/* Check if this symbol has a size. If so, remember it in the
** flags.
*/
long Size;
SymEntry* SizeSym = FindSizeOfSymbol (S);
if (SizeSym != 0 && SymIsConst (SizeSym, &Size)) {
SymFlags |= SYM_SIZE;
}
/* Count the number of ConDes types */
for (Type = 0; Type < CD_TYPE_COUNT; ++Type) {
if (S->ConDesPrio[Type] != CD_PRIO_NONE) {
SYM_INC_CONDES_COUNT (SymFlags);
}
}
/* Write the type and the export size */
ObjWriteVar (SymFlags);
ObjWrite8 (S->ExportSize);
/* Write any ConDes declarations */
if (SYM_GET_CONDES_COUNT (SymFlags) > 0) {
for (Type = 0; Type < CD_TYPE_COUNT; ++Type) {
unsigned char Prio = S->ConDesPrio[Type];
if (Prio != CD_PRIO_NONE) {
ObjWrite8 (CD_BUILD (Type, Prio));
}
}
}
/* Write the name */
ObjWriteVar (S->Name);
/* Write the value */
if (SYM_IS_CONST (SymFlags)) {
/* Constant value */
ObjWrite32 (ConstVal);
} else {
/* Expression involved */
WriteExpr (S->Expr);
}
/* If the symbol has a size, write it to the file */
if (SYM_HAS_SIZE (SymFlags)) {
ObjWriteVar (Size);
}
/* Write the line infos */
WriteLineInfo (&S->DefLines);
WriteLineInfo (&S->RefLines);
}
S = S->List;
}
/* Done writing exports */
ObjEndExports ();
}
