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 SYMBOL inlineSymbol( // CREATE TRANSLATION SYMBOL IF REQ'D
SYMBOL sym ) // - original symbol
{
SYMBOL old; // - same as "sym"
FN_CTL* fctl; // - current file control
fctl = FnCtlTop();
if( sym == fctl->this_sym ) {
return( sym );
}
if( sym == fctl->cdtor_sym ) {
return( sym );
}
if( CgBackInlinedDepth() > 0
&& ! SymIsFunction( sym )
&& ! SymIsStaticData( sym ) ) {
old = sym;
sym = push_inline_sym( old );
SymTransPush( old, sym );
// code used to only have SymIsCatchAlias so we
// make sure SymIsAlias includes SymIsCatchAlias
DbgAssert( ! SymIsCatchAlias( sym ) ||
( SymIsCatchAlias( sym ) && SymIsAlias( sym ) ) );
if( SymIsAlias( sym ) || SymIsAnonymousMember( sym ) ) {
if( SymIsAutomatic( sym ) ) {
sym->u.alias = SymTrans( sym->u.alias );
}
}
}
return( sym );
}
void CgBackFreeHandle( // FREE A BACK HANDLE FOR A SYMBOL
SYMBOL sym ) // - the symbol
{
if( ( sym->flag2 & SF2_CG_HANDLE )
&&( ! SymIsAnonymous( sym ) )
&&( ! SymIsAutomatic( sym ) ) ) { // - only because of RO,RW-DTORS
sym->flag2 &= ~SF2_CG_HANDLE;
BEFreeBack( (back_handle)sym->locn->u.cg_handle );
}
}
enum sym_state AsmQueryState( void *handle )
{
#if 1
SYMBOL sym = handle;
enum sym_state state;
state = SYM_UNDEFINED;
if( sym != NULL ) {
if( SymIsAutomatic( sym ) ) {
state = SYM_STACK;
} else {
state = SYM_EXTERNAL;
}
}
return( state );
#else
id = id;
return( SYM_UNDEFINED );
#endif
}
bool CgDeclSkippableConstObj( // DETERMINE IF SKIPPABLE CONST OBJ
SYMBOL sym ) // - symbol
{
if( SymAddrTaken( sym ) ) {
return( false );
}
if( SymIsAutomatic( sym ) && ( GenSwitches & DBG_LOCALS ) ) {
// if we are debugging locals; don't skip initialization
return( false );
}
if( SymIsConstantInt( sym ) ) {
return( true );
}
if( SymIsConstantNoCode( sym ) && ! SymIsReferenced( sym ) ) {
if( SymIsStaticData( sym ) ) {
return( true );
}
}
return( false );
}
enum sym_state AsmQueryExternal(
char *name )
{
#if 1
SYMBOL sym;
enum sym_state state;
state = SYM_UNDEFINED;
sym = ScopeASMLookup( name );
if( sym != NULL ) {
if( SymIsAutomatic( sym ) ) {
state = SYM_STACK;
} else {
state = SYM_EXTERNAL;
}
}
return( state );
#else
name = name;
return( SYM_UNDEFINED );
#endif
}
static void checkAutoReturn( // CHECK IF AUTOMATIC BEING RETURNED
PTREE node, // - node to be checked
TYPE ret_type ) // - return type
{
TYPE func_ret; // - type of function return
SYMBOL func; // - function called
SYMBOL comped; // - function being compiled
PTREE expr; // - node for error
TYPE refed; // - NULL ==> not reference
comped = ScopeFunctionInProgress();
if( SymIsGenedFunc( comped ) ) {
return;
}
expr = node;
refed = TypeReference( ret_type );
for( ; ; ) {
node = NodeRemoveCastsCommas( node );
if( ( node->op == PT_SYMBOL )
&&( SymIsAutomatic( node->u.symcg.symbol ) ) ) {
if( NULL == refed ) {
PTreeWarnExpr( expr, WARN_RET_ADDR_OF_AUTO );
} else {
PTreeErrorExpr( expr, ERR_RET_AUTO_REF );
}
break;
} else if( NodeIsBinaryOp( node, CO_DOT )
|| NodeIsBinaryOp( node, CO_DOT_STAR ) ) {
node = PTreeOpLeft( node );
} else if( NodeIsUnaryOp( node, CO_ADDR_OF ) ) {
node = PTreeOpLeft( node );
} else if( NULL != refed ) {
if( NodeIsBinaryOp( node, CO_DTOR ) ) {
node = PTreeOpRight( node );
} else if( NodeIsBinaryOp( node, CO_CALL_EXEC ) ) {
node = PTreeOpLeft( PTreeOpLeft( node ) );
if( node->op == PT_SYMBOL ) {
func = node->u.symcg.symbol;
if( SymIsCtor( func ) ) {
PTreeErrorExpr( expr, ERR_RET_AUTO_REF );
} else {
func_ret = SymFuncReturnType( func );
if( NULL != StructType( func_ret ) ) {
PTreeErrorExpr( expr, ERR_RET_AUTO_REF );
}
}
}
break;
} else if( NodeIsBinaryOp( node, CO_CALL_EXEC_IND ) ) {
func_ret = TypeFunctionCalled( NodeFuncForCall( node )->type );
func_ret = func_ret->of;
if( NULL != StructType( func_ret ) ) {
PTreeErrorExpr( expr, ERR_RET_AUTO_REF );
}
break;
} else {
break;
}
} else {
break;
}
}
}
