segment_id DgCurrSeg( void )
{
segment_id curr_seg;
curr_seg = BESetSeg( UNDEFSEG );
BESetSeg( curr_seg );
return( curr_seg );
}
static fe_seg_id dgCurrSeg( void )
{
fe_seg_id curr_seg;
curr_seg = BESetSeg( SEG_CONST );
BESetSeg( curr_seg );
return( curr_seg );
}
cg_name CgDtorStatic( // DTOR STATIC OBJECT
SYMBOL sym ) // - object symbol
{
STAB_CTL sctl; // - state-table instance
STAB_DEFN dctl; // - state-table definition
RT_DEF def; // - control for run-time call
SE* se; // - state entry
segment_id old_seg; // - old segment
StabCtlInit( &sctl, &dctl );
StabDefnInit( &dctl, DTRG_STATIC_INITLS );
#ifndef NDEBUG
if( PragDbgToggle.dump_stab ) {
printf( "State Table for static object: %p\n", &dctl.state_table );
}
#endif
sctl.rw = CgVarRw( CgbkInfo.size_rw_base + CgbkInfo.size_data_ptr, SC_STATIC );
dctl.ro = CgVarRo( 1, SC_STATIC, NULL );
se = SeAlloc( DTC_SYM_STATIC );
se->base.gen = true;
se->sym_static.sym = sym;
se->sym_static.dtor = RoDtorFind( sym );
se = StateTableAdd( se, &sctl );
StabGenerate( &sctl );
old_seg = DgSetSegSym( sctl.rw );
CgBackGenLabelInternal( sctl.rw );
DgInitBytes( CgbkInfo.size_data_ptr, 0 );
DgPtrSymData( dctl.ro );
DgOffset( 1 );
DgPtrSymData( sym );
BESetSeg( old_seg );
CgRtCallInit( &def, RTF_REG_LCL );
CgRtParamAddrSym( &def, sctl.rw );
return( CgRtCallExec( &def ) );
}
void DgSymbolDefInit( // DATA GENERATE SYMBOL (DEFAULT DATA)
SYMBOL sym ) // - the symbol
{
segment_id old_seg; // - old segment
segment_id seg_id; // - symbol segment
target_size_t size; // - size of symbol
seg_id = FESegID( sym );
old_seg = BESetSeg( seg_id );
DgAlignSegment( seg_id, SegmentAlignment( sym->sym_type ) );
CgBackGenLabel( sym );
size = CgMemorySize( sym->sym_type );
if( sym->segid == SEG_BSS ) {
DgUninitBytes( size );
} else {
DgInitBytes( size, 0 );
}
BESetSeg( old_seg );
}
fe_seg_id CgBackGenLabel( // GENERATE A LABEL
SYMBOL sym ) // - symbol defining label
{
segment_id old_id; // - old segment
segment_id seg_id; // - new segment
seg_id = FESegID( sym );
old_id = BESetSeg( seg_id );
DGLabel( FEBack( sym ) );
return old_id;
}
fe_seg_id CgBackGenLabelInternal(// GENERATE A LABEL FOR INTERNAL STRUCTURE
SYMBOL sym ) // - symbol defining label
{
segment_id old_id; // - old segment
segment_id seg_id; // - new segment
seg_id = FESegID( sym );
old_id = BESetSeg( seg_id );
DgAlignInternal();
DGLabel( FEBack( sym ) );
return old_id;
}
void EmitSegLabels( void ) /* 15-mar-92 */
{
int seg;
struct user_seg *useg;
BACK_HANDLE bck;
SYM_ENTRY sym;
seg = FIRST_USER_SEGMENT;
for( useg = UserSegments; useg; useg = useg->next ) {
if( useg->sym_handle != 0 ) {
SymGet( &sym, useg->sym_handle );
bck = BENewBack( useg->sym_handle );
sym.info.backinfo = bck;
SymReplace( &sym, useg->sym_handle );
BESetSeg( seg );
DGLabel( bck );
}
++seg;
}
}
static SYMBOL segEmitLabel( // EMIT SEGMENT LABEL
PC_SEGMENT* seg ) // - current segment
{
SYMBOL label; // - label in segment
segment_id old_seg; // - old segment
label = seg->label;
if( label != NULL && ! seg->lab_gened ) {
if( seg->seg_id == SEG_STACK ) {
CGAutoDecl( (cg_sym_handle)label, TY_UINT_1 );
} else {
old_seg = DgSetSegSym( label );
CgBackGenLabel( label );
BESetSeg( old_seg );
}
seg->lab_gened = TRUE;
_markUsed( seg, TRUE );
}
return label;
}
void ThrowRoGen( // GENERATE A THROW R/O BLOCK
void )
{
THROW_RO *ro; // - R/O block for symbol
segment_id old_seg; // - old segment
TYPE type; // - type being converted
THROW_CNV_CTL ctl; // - control for conversions
target_offset_t offset; // - offset within class
RingIterBeg( ring_throw_ro, ro ) {
if( ! ro->emitted ) {
ro->emitted = true;
old_seg = DgSetSegSym( ro->sym );
CgBackGenLabelInternal( ro->sym );
offset = ThrowCnvInit( &ctl, ro->sig->type );
DbgVerify( ! ctl.error_occurred
, "cgGenThrowRo -- failure in ThrowCnvInit" );
#ifndef NDEBUG
if( PragDbgToggle.dump_stab ) {
printf( "ThrowRo[%p] offset=%p sig=%x\n"
, ro
, ro->sig
, offset );
}
#endif
DgOffset( offset );
for( ; ; ) {
type = ThrowCnvType( &ctl, &offset );
if( type == NULL )
break;
cgGenThrowCnv( type, offset );
}
ThrowCnvFini( &ctl );
BESetSeg( old_seg );
}
} RingIterEnd( ro );
}
static void EmitDQuad( DATA_QUAD *dq )
{
cg_type data_type;
int size_of_item;
unsigned long amount;
auto SYM_ENTRY sym;
static int segment;
static unsigned long size = 0;
if( dq->flags & Q_NEAR_POINTER ) {
data_type = T_NEAR_POINTER;
size_of_item = TARGET_NEAR_POINTER;
} else if( dq->flags & Q_FAR_POINTER ) {
data_type = T_LONG_POINTER;
size_of_item = TARGET_FAR_POINTER;
} else if( dq->flags & Q_CODE_POINTER ) {
data_type = T_CODE_PTR;
size_of_item = TARGET_POINTER;
#if _CPU == 8086
if( TargetSwitches & BIG_CODE ) {
size_of_item = TARGET_FAR_POINTER;
}
#endif
} else {
data_type = T_POINTER;
size_of_item = TARGET_POINTER;
#if _CPU == 8086
if( TargetSwitches & BIG_DATA ) {
size_of_item = TARGET_FAR_POINTER;
}
#endif
}
#if _CPU == 8086
if( size >= 0x10000 ) {
if( segment != SEG_CONST && segment != SEG_DATA ) {
++segment;
BESetSeg( segment );
size -= 0x10000;
}
}
#endif
switch( dq->type ) {
case QDT_STATIC:
SymGet( &sym, dq->u.var.sym_handle );
segment = sym.u.var.segment;
BESetSeg( segment );
AlignIt( sym.sym_type );
DGLabel( FEBack( dq->u.var.sym_handle ) );
size = 0;
break;
case QDT_CHAR:
case QDT_UCHAR:
case QDT_BOOL:
DGInteger( dq->u.long_values[0], T_UINT_1 );
size += sizeof( char );
if( dq->flags & Q_2_INTS_IN_ONE ) {
DGInteger( dq->u.long_values[1], T_UINT_1 );
size += sizeof( char );
}
break;
case QDT_SHORT:
case QDT_USHORT:
DGInteger( dq->u.long_values[0], T_UINT_2 );
size += sizeof( target_short );
if( dq->flags & Q_2_INTS_IN_ONE ) {
DGInteger( dq->u.long_values[1], T_UINT_2 );
size += sizeof( target_short );
}
break;
case QDT_INT:
case QDT_UINT:
DGInteger( dq->u.long_values[0], T_INTEGER );
size += sizeof( target_int );
if( dq->flags & Q_2_INTS_IN_ONE ) {
DGInteger( dq->u.long_values[1], T_INTEGER );
size += sizeof( target_int );
}
break;
case QDT_LONG:
case QDT_ULONG:
DGInteger( dq->u.long_values[0], T_UINT_4 );
size += sizeof( target_long );
if( dq->flags & Q_2_INTS_IN_ONE ) {
DGInteger( dq->u.long_values[1], T_UINT_4 );
size += sizeof( target_long );
}
break;
case QDT_LONG64:
case QDT_ULONG64:
DGInteger64( dq->u.long64, T_UINT_8 );
size += sizeof( int64 );
break;
case QDT_FLOAT:
case QDT_FIMAGINARY:
// ftoa( dq->u.double_value, Buffer );
// DGFloat( Buffer, T_SINGLE );
{
DATA_QUAD local_dq;
float float_value;
// dq->u.double_value may not have proper alignment on Alpha
// so copy pieces to local copy on stack which will have
// proper alignment
local_dq.u.long_values[0] = dq->u.long_values[0];
local_dq.u.long_values[1] = dq->u.long_values[1];
float_value = (float)local_dq.u.double_value;
DGBytes( sizeof(float), (char *)&float_value );
}
size += sizeof( float );
break;
case QDT_DOUBLE:
case QDT_DIMAGINARY:
// ftoa( dq->u.double_value, Buffer );
// DGFloat( Buffer, TY_DOUBLE );
DGBytes( sizeof(double), (char *)&dq->u.double_value );
size += sizeof( double );
break;
case QDT_LONG_DOUBLE:
case QDT_LDIMAGINARY:
DGBytes( sizeof(long_double), (char *)&dq->u.long_double_value );
size += sizeof( long_double );
break;
case QDT_STRING:
EmitStrPtr( dq->u.string_leaf, data_type );
size += size_of_item;
break;
case QDT_POINTER:
case QDT_ID:
if( dq->u.var.sym_handle == 0 ) {
DGInteger( dq->u.var.offset, data_type );
} else {
DGFEPtr( dq->u.var.sym_handle, data_type, dq->u.var.offset );
}
size += size_of_item;
break;
case QDT_CONST: /* array of characters */
size += EmitBytes( dq->u.string_leaf );
break;
case QDT_CONSTANT:
#if _CPU == 8086
for( amount = dq->u.long_values[0]; amount != 0; ) {
if( amount + size >= 0x00010000 ) {
EmitZeros( 0x10000 - size );
amount -= ( 0x10000 - size );
size = 0;
if( segment != SEG_CONST && segment != SEG_DATA ) {
++segment;
BESetSeg( segment );
}
} else {
EmitZeros( amount );
size += amount;
amount = 0;
}
}
#else
amount = dq->u.long_values[0];
EmitZeros( amount );
size += amount;
#endif
break;
}
}
bool StabGenerate( // GENERATE A STATE TABLE
STAB_CTL* sctl ) // - state-table information
{
STAB_DEFN* defn; // - state-table definition
SE* se; // - current state entry
SE* state_table; // - the state table
segment_id old_seg; // - old segment
if( sctl->rw == NULL ) return FALSE;
defn = sctl->defn;
old_seg = DgSetSegSym( defn->ro );
CgBackGenLabelInternal( defn->ro );
DgOffset( defn->kind );
#if _CPU == _AXP
if( defn->kind == DTRG_FUN ) {
DgOffset( - CgOffsetRw( 0 ) );
}
#endif
state_table = defn->state_table;
RingIterBeg( state_table, se ) {
if( se->base.gen ) {
switch( se->base.se_type ) {
case DTC_SYM_AUTO :
DbgVerify( UNDEF_AREL != se->sym_auto.offset, "cgStateTable -- no offset for SYM_AUTO" );
DgPtrSymCode( se->sym_auto.dtor );
DgOffset( CgOffsetRw( se->sym_auto.offset ) );
padOffsetToPtrSize();
break;
case DTC_SYM_STATIC :
DgPtrSymCode( se->sym_static.dtor );
DgPtrSymData( se->sym_static.sym );
break;
case DTC_TEST_FLAG :
cgStateTableCmd( CgCmdTestFlag( se ), 0 );
break;
case DTC_TRY :
se->try_blk.sym = cgStateTableCmd( CgCmdTry( se ), 0 );
break;
case DTC_CATCH :
cgStateTableCmd( se->catch_blk.try_blk->try_blk.sym, sizeof( DTOR_CMD_CODE ) );
break;
case DTC_FN_EXC :
cgStateTableCmd( CgCmdFnExc( se ), 0 );
break;
case DTC_SET_SV :
if( se != state_table ) {
cgStateTableCmd( CgCmdSetSv( se ), 0 );
}
break;
case DTC_ACTUAL_DBASE :
case DTC_ACTUAL_VBASE :
case DTC_COMP_VBASE :
case DTC_COMP_DBASE :
case DTC_COMP_MEMB :
cgStateTableCmd( CgCmdComponent( se ), 0 );
break;
case DTC_ARRAY_INIT :
cgStateTableCmd( CgCmdArrayInit( se ), 0 );
break;
case DTC_DLT_1 :
cgStateTableCmd( CgCmdDlt1( se ), 0 );
break;
case DTC_DLT_2 :
cgStateTableCmd( CgCmdDlt2( se ), 0 );
break;
case DTC_DLT_1_ARRAY :
cgStateTableCmd( CgCmdDlt1Array( se ), 0 );
break;
case DTC_DLT_2_ARRAY :
cgStateTableCmd( CgCmdDlt2Array( se ), 0 );
break;
case DTC_CTOR_TEST :
cgStateTableCmd( CgCmdCtorTest( se ), 0 );
break;
DbgDefault( "cgStateTable -- impossible" );
}
}
} RingIterEnd( se )
#if !defined( NDEBUG ) || !defined( _INTEL_CPU )
DgPtrSymCode( NULL );
DgPtrSymData( NULL );
#endif
BESetSeg( old_seg );
StabDefnFreeStateTable( defn );
return TRUE;
}
back_handle DgStringConst( // STORE STRING CONSTANT WITH NULL
STRING_CONSTANT str, // - string to store
uint_16 *psegid, // - addr(string segid)
unsigned control ) // - control mask (DSC_*)
{
back_handle handle; // - back handle for literal
target_offset_t str_align; // - string's alignment
target_size_t str_len; // - string's length (in bytes)
segment_id str_seg; // - string's segment
segment_id old_seg; // - old segment
str_seg = str->segid;
handle = str->cg_handle;
if( control & DSC_CONST ) {
if( handle == 0 ) {
handle = BENewBack( 0 );
str->cg_handle = handle;
str_len = str->len + TARGET_CHAR;
if( str->wide_string ) {
str_align = TARGET_WIDE_CHAR;
} else {
str_align = TARGET_CHAR;
}
#if _CPU == _AXP
str_seg = SEG_CONST;
#else
if( CompFlags.strings_in_code_segment && ( control & DSC_CODE_OK ) != 0 ) {
if( IsBigData() ) {
str_seg = SegmentAddStringCodeFar( str_len, str_align );
} else {
if( IsFlat() ) {
str_seg = SegmentAddStringCodeFar( str_len, str_align );
} else {
str_seg = SEG_CONST;
}
}
} else {
if( IsBigData() ) {
str_seg = SegmentAddStringConstFar( str_len, str_align );
} else {
str_seg = SEG_CONST;
}
}
#endif
str->segid = str_seg;
old_seg = BESetSeg( str_seg );
#if _CPU == _AXP
DGAlign( TARGET_INT );
#else
DGAlign( str_align ); // NT requires word aligned wide strings
#endif
DGLabel( handle );
DGString( str->string, str->len );
DgByte( 0 );
#if _CPU == _AXP
DGAlign( TARGET_INT );
#endif
BESetSeg( old_seg );
}
} else {
// char a[] = "asdf"; initialization (use current segment)
str_seg = DgCurrSeg();
str->segid = str_seg;
DGString( str->string, str->len );
DgByte( 0 );
}
if( psegid != NULL ) {
*psegid = str_seg;
}
return( handle );
}
segment_id DgSetSegSym( SYMBOL sym )
{
return( BESetSeg( FESegID( sym ) ) );
}
