void CgBackGenLabelInternal( // GENERATE A LABEL FOR INTERNAL STRUCTURE
SYMBOL sym ) // - symbol defining label
{
#if _CPU == _AXP
DgAlignSegment( SEG_CONST, TARGET_POINTER );
#endif
DGLabel( FEBack( sym ) );
}
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 DgSymbolDefInit( // DATA GENERATE SYMBOL (DEFAULT DATA)
SYMBOL sym ) // - the symbol
{
segment_id old_id; // - old segment
segment_id seg_id; // - symbol segment
target_size_t size; // - size of symbol
seg_id = FESegID( sym );
old_id = BESetSeg( seg_id );
DgAlignSymbol( sym );
DGLabel( FEBack( sym ) );
size = CgMemorySize( sym->sym_type );
if( sym->segid == SEG_BSS ) {
DgUninitBytes( size );
} else {
DgInitBytes( size, 0 );
}
BESetSeg( 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 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;
}
}
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 );
}
void CgBackGenLabel( // GENERATE A LABEL
SYMBOL sym ) // - symbol defining label
{
DGLabel( FEBack( sym ) );
}
