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 ) ) ); }