fe_seg_id CgSegIdData( SYMBOL sym, SEGID_CONTROL control )
/********************************************************/
{
fe_seg_id id;
type_flag flags;
if( SymIsAutomatic( sym ) ) {
id = cgSegIdAuto( sym );
} else if( SymIsFunction( sym ) ) {
id = CgSegIdFunction( sym );
} else {
id = sym->segid;
if( id == SEG_NULL ) {
TypeGetActualFlags( sym->sym_type, &flags );
if( flags & TF1_THREAD ) {
id = cgSegIdThread( sym, flags );
} else if( flags & TF1_BASED ) {
id = cgSegIdBased( sym, flags );
#if _CPU == _AXP || COMP_CFG_COFF == 1
} else if( SymIsComdatData( sym ) ) {
id = SegmentAddComdatData( sym, control );
#endif
} else {
id = cgSegIdVariable( sym, flags, control );
}
sym->segid = id;
}
SegmentMarkUsed( id );
}
return( id );
}
static void genInitFiniReference( // GENERATE INIT/FINI REFERENCE TO FUNCTION
SYMBOL func, // - function to be called
unsigned priority, // - priority
NAME name, // - name for reference
fe_seg_id tgt_seg ) // - segment # of target segment
{
SYMBOL init_ref; // - reference to mod-init. function
TYPE type; // - used to build type
SegmentMarkUsed( tgt_seg );
type = MakePointerTo( func->sym_type );
init_ref = SymCreateFileScope( type
, SC_STATIC
, SF_INITIALIZED | SF_REFERENCED
, name );
init_ref->segid = tgt_seg;
if( tgt_seg == SEG_INIT_REF ) {
CgFrontInitRef();
} else {
CgFrontFiniRef();
}
CgFrontDataPtr( IC_DATA_LABEL, init_ref );
#if _INTEL_CPU
CgFrontDataPtr( IC_SET_TYPE, GetBasicType( TYP_UCHAR ) );
if( IsBigCode() ) {
CgFrontDataInt( IC_DATA_INT, 1 );
} else {
CgFrontDataInt( IC_DATA_INT, 0 );
}
CgFrontDataInt( IC_DATA_INT, priority );
#elif _CPU == _AXP
CgFrontDataPtr( IC_SET_TYPE, GetBasicType( TYP_UINT ) );
CgFrontDataInt( IC_DATA_INT, 0 );
CgFrontDataInt( IC_DATA_INT, priority );
#else
#error BAD _CPU
#endif
CgFrontDataPtr( IC_SET_TYPE, type );
CgFrontDataInt( IC_DATA_PTR_OFFSET, 0 );
CgFrontDataPtr( IC_DATA_PTR_SYM, func );
#if _CPU == 8086
if( !IsBigCode() ) {
CgFrontDataInt( IC_DATA_INT, 0 );
}
#elif COMP_CFG_COFF == 1
CgFrontDataPtr( IC_SET_TYPE, GetBasicType( TYP_USHORT ) );
CgFrontDataInt( IC_DATA_INT, 0 );
#endif
}
void SegmentCodeCgInit( // TURN OFF USED BIT FOR ALL CODE SEGMENTS
void )
{
PC_SEGMENT *segment; // - current segment
// reset any #pragma data_seg/code_seg changes back to defaults
SegmentData( NULL, NULL );
SegmentCode( NULL, NULL );
RingIterBeg( seg_list, segment ) {
if( ( segment->attrs & EXEC ) && ! segment->has_data ) {
_markUsed( segment, FALSE );
}
} RingIterEnd( segment )
// call out for non-call graph code segment uses
DbgSuppSegRequest();
// used for default code segment externs
SegmentMarkUsed( SEG_CODE );
}
fe_seg_id SegmentForDefinedFunc(// GET SEGMENT FOR A DEFINED FUNCTION
SYMBOL func ) // - function
{
fe_seg_id segid;
segid = func->segid;
if( segid == SEG_NULL ) {
if( NULL != BasedType( func->sym_type ) ) {
segid = SegmentFindBased( func->sym_type );
} else if( CompFlags.zm_switch_used ) {
#if _INTEL_CPU
if( SymIsGennedComdatFun( func ) ) {
segid = seg_code_comdat;
if( SEG_NULL == segid ) {
segid = nextZmSegment();
seg_code_comdat = segid;
}
} else {
segid = nextZmSegment();
}
#elif _CPU == _AXP || COMP_CFG_COFF == 1
segid = nextZmSegment();
if( SymIsGennedComdatFun( func ) ) {
segid = markSegmentComdat( segid );
}
#else
#error Bad Machine Type
#endif
#if _CPU == _AXP || COMP_CFG_COFF == 1
} else if( SymIsGennedComdatFun( func ) ) {
segid = nextZmSegment();
segid = markSegmentComdat( segid );
#endif
} else {
segid = code_def_seg.pcseg->seg_id;
SegmentMarkUsed( segid );
code_def_seg.ds_used = TRUE;
}
}
return segid;
}
static fe_seg_id nextZmSegment( // GET NEXT CODE SEGMENT FOR -zm
void )
{
fe_seg_id segid; // - segment id
unsigned ads_control; // - def seg control
if( code_def_seg.ds_used ) {
ads_control = ADS_NULL;
if( IsBigCode() && CompFlags.zm_switch_used ) {
if( !CompFlags.zmf_switch_used ) {
ads_control = ADS_ZM_SEGMENT;
}
}
segid = addDefSeg( &code_def_seg, ads_control )->seg_id;
} else {
code_def_seg.ds_used = TRUE;
segid = code_def_seg.pcseg->seg_id;
SegmentMarkUsed( segid );
}
return segid;
}
void SegmentMarkRoBlock( // INDICATE R/O BLOCK TO BE GENERATED
void )
{
// NYI: should never be used (use SegmentMarkUsed with the symbol's segid)
SegmentMarkUsed( SEG_CONST2 );
}
TYPE_SIG *TypeSigFind( // FIND TYPE SIGNATURE
TYPE_SIG_ACCESS acc, // - access type
TYPE type, // - type for signature
TOKEN_LOCN* err_locn, // - error location for access errors
bool *error_occurred ) // - to set error indication
{
TYPE_SIG *srch; // - signature for searching
TYPE_SIG *sig; // - signature
SYMBOL sym; // - symbol
unsigned size; // - size of R/O data
NAME typesig_name; // - name of type signature
TYPE typesig_type; // - type of type signature
bool err_this_time; // - true ==> we have error
TYPE_SIG_ACCESS acc_ind; // - indirect access
err_this_time = false;
type = TypeCanonicalThr( type );
sig = NULL;
RingIterBeg( type_sigs, srch ) {
if( TypesSameExclude( srch->type, type, TC1_NOT_ENUM_CHAR ) ) {
sig = srch;
break;
}
} RingIterEnd( srch );
if( sig == NULL ) {
THROBJ thr; // - category of object
DbgVerify( 0 == ( acc & TSA_GEN )
, "TypeSigFind -- no type signature & TSA_GEN" );
sig = RingCarveAlloc( carveTYPE_SIG, &type_sigs );
sig->type = type;
sig->default_ctor = NULL;
sig->copy_ctor = NULL;
sig->dtor = NULL;
sig->sym = NULL;
sig->base = NULL;
sig->cgref = false;
sig->cggen = false;
sig->free = false;
thr = ThrowCategory( type );
if( acc & TSA_INDIRECT ) {
acc_ind = acc | TSA_INDIRECT_ACCESS;
} else if( acc & TSA_INDIRECT_ACCESS ) {
acc_ind = ( acc & ~ TSA_INDIRECT ) | TSA_INDIRECT_GEN;
} else {
acc_ind = acc;
}
size = 0;
switch( thr ) {
case THROBJ_PTR_SCALAR :
case THROBJ_PTR_CLASS :
sig->base = TypeSigFind( acc_ind & TSA_INDIRECT
, TypePointedAtModified( type )
, err_locn
, &err_this_time );
size = typeSigHdrSize();
break;
case THROBJ_SCALAR :
case THROBJ_PTR_FUN :
case THROBJ_VOID_STAR :
size = typeSigHdrSize() + SizeTargetSizeT();
break;
case THROBJ_REFERENCE :
sig->base = TypeSigFind( acc_ind
, TypeReference( type )
, err_locn
, &err_this_time );
break;
case THROBJ_CLASS :
case THROBJ_CLASS_VIRT :
size = 3 * CgCodePtrSize() + CgDataPtrSize() + typeSigHdrSize();
break;
case THROBJ_ANYTHING :
break;
default :
DbgStmt( CFatal( "cgTypeSignature -- invalid throw category" ) );
}
size += typeSigNameSize( thr );
if( size == 0 ) {
sym = NULL;
} else { // - type for TYPE SIGNATURE variable
typesig_name = CppNameTypeSig( type );
sym = ScopeAlreadyExists( GetFileScope(), typesig_name );
if( sym == NULL ) {
typesig_type = MakeInternalType( size );
typesig_type = MakeCompilerConstCommonData( typesig_type );
sym = SymCreateFileScope( typesig_type
, SC_PUBLIC
, SF_REFERENCED | SF_ADDR_TAKEN
, typesig_name );
LinkageSet( sym, "C++" );
CgSegId( sym );
}
}
sig->sym = sym;
}
if( err_this_time ) {
*error_occurred = true;
} else {
if( NULL != sig->sym ) {
SegmentMarkUsed( sig->sym->segid );
}
*error_occurred = false;
typeSigAccess( acc, sig, err_locn, error_occurred );
}
return( sig );
}
