static SYMBOL registerHandler( // REGISTER THE HANDLER
SYMBOL rw, // - symbol for R/W block
unsigned rtn_code ) // - R/T handler code
{
#if 0
CgAssignPtr( CgSymbolPlusOffset( rw, CgbkInfo.size_data_ptr )
, CgAddrSymbol( RunTimeCallSymbol( rtn_code ) ) );
#else
CgAssign( CgSymbolPlusOffset( rw, CgbkInfo.size_data_ptr )
, CgAddrSymbol( RunTimeCallSymbol( rtn_code ) )
, TY_CODE_PTR );
#endif
return rw;
}
cg_name CgDestructSymOffset( // CONSTRUCT DTOR CALL FOR SYMBOL+OFFSET
FN_CTL* fctl, // - function control
SYMBOL dtor, // - destructor
SYMBOL sym, // - SYMBOL to be DTOR'ed
target_offset_t offset, // - offset from "sym"
unsigned cdtor ) // - CDTOR to be used
{
call_handle handle; // - call handle
SYMBOL trans; // - translated symbol
SYMBOL bound; // - bound reference
target_offset_t bound_off; // - bound offset
bool inlined; // - true ==> inlined dtor call
handle = initDtorCall( dtor );
inlined = CgBackFuncInlined( dtor );
if( inlined ) {
CallStackPush( dtor, handle, TY_POINTER );
IbpAdd( sym, offset, fctl );
IbpDefineIndex( 0 );
}
if( IbpReference( sym, &trans, &bound, &bound_off ) ) {
trans = bound;
offset += bound_off;
}
addDtorArgs( handle, dtor, CgSymbolPlusOffset( trans, offset ), cdtor );
if( inlined ) {
CallStackPop();
}
return finiDtorCall( handle, cdtor );
}
void CondInfoSetFlag( // SET FLAG FOR CONDITIONAL DTOR BLOCK
FN_CTL* fctl, // - function control
bool set_flag ) // - true ==> set the flag; false ==> clear
{
COND_STK* stk; // - conditional entry
cg_name op_flg; // - expression for flag setting
cg_name op_mask; // - mask operand
COND_INFO cond; // - conditional information
patch_handle patch; // - handle for patch
cg_op opcode; // - opcode for set/clr
stk = PstkTopElement( &stack_cond_blks );
CondInfoSetup( stk->offset, &cond, fctl );
patch = BEPatch();
op_mask = CGPatchNode( patch, TY_UINT_1 );
if( set_flag ) {
stk->mask_set = cond.mask;
stk->handle_set = patch;
opcode = O_OR;
} else {
stk->mask_clr = NOT_BITARR_MASK( cond.mask );
stk->handle_clr = patch;
opcode = O_AND;
}
op_flg = CgSymbolPlusOffset( cond.sym, cond.offset );
op_flg = CGLVPreGets( opcode, op_flg, op_mask, TY_UINT_1 );
CgExprPush( op_flg, TY_POINTER );
}
void CgFunRegister( // REGISTER A FUNCTION
FN_CTL* fctl, // - function information
SYMBOL rw, // - symbol for R/W block
SYMBOL ro ) // - symbol for R/O block
{
SE* se; // - current position
#if _CPU == _AXP
CgAssignPtr( CgSymbolPlusOffset( rw, 0 ), CgAddrSymbol( ro ) );
CompFlags.inline_fun_reg = TRUE;
#else
RT_DEF def; // - R/T call control
cg_name opt_thr; // - optimized expression for addr[THREAD_CTL]
DbgVerify( CompFlags.rw_registration, "not R/W Registration" );
if( CompFlags.fs_registration ) {
CompFlags.inline_fun_reg = TRUE;
CgRtCallInit( &def, RTF_FS_PUSH );
CgRtParamAddrSym( &def, rw );
CgRtCallExecDone( &def );
rw = registerHandler( rw, RTF_FS_HANDLER );
} else {
opt_thr = pointOptSym( &optFuncReg );
if( opt_thr == NULL ) {
rtRegister( rw, ro );
} else {
CompFlags.inline_fun_reg = TRUE;
CgAssignPtr( CgSymbolPlusOffset( rw, 0 )
, CgFetchPtr( opt_thr ) );
CgAssignPtr( CgSymbol( optFuncReg.sym )
, CgAddrSymbol( rw ) );
rw = registerHandler( rw, RTF_FS_HANDLER_RTN );
}
}
CgAssignPtr( CgSymbolPlusOffset
( rw, CgbkInfo.size_data_ptr + CgbkInfo.size_fs_hand )
, CgAddrSymbol( ro ) );
#endif
if( fctl->is_dtor ) {
se = BlkPosnCurr();
} else {
se = NULL;
}
FstabAssignStateVar( se );
}
cg_name CgAssignStateVar( // ASSIGN STATE-VAR VALUE
SYMBOL blk, // - R/W Block
SE* se, // - state entry
target_offset_t offset ) // - offset of state variable
{
return CGLVAssign( CgSymbolPlusOffset( blk, offset )
, CgOffset( SeStateVar( se ) )
, CgTypeOffset() );
}
void CgFunDeregister( // DE-REGISTER A FUNCTION
SYMBOL rw ) // - symbol for R/W block
{
RT_DEF def; // - R/T call control
cg_name opt_thr; // - optimized expression for addr[THREAD_CTL]
DbgVerify( CompFlags.rw_registration, "not R/W Registration" );
if( CompFlags.fs_registration ) {
cg_name expr;
CgRtCallInit( &def, RTF_FS_POP );
expr = CgSymbolPlusOffset( rw, 0 );
expr = CgFetchPtr( expr );
CgRtParam( expr, &def, TY_POINTER );
CgRtCallExecDone( &def );
} else {
opt_thr = pointOptSym( (OPT_DEFN *)&optFuncReg );
if( opt_thr == NULL ) {
CgRtCallExecNoArgs( RTF_DEREGISTER );
} else {
CgAssignPtr( opt_thr, CgFetchPtr( CgSymbolPlusOffset( rw, 0 ) ) );
}
}
}
static cg_name condSet( // SET/RESET FLAG
unsigned index, // - index of flag
bool set_flag, // - true ==> set the flag; false ==> clear
FN_CTL* fctl ) // - function information
{
cg_name op_flg; // - expression for flag setting
cg_name op_mask; // - mask operand
COND_INFO cond; // - conditional information
CondInfoSetup( index, &cond, fctl );
op_flg = CgSymbolPlusOffset( cond.sym, cond.offset );
if( set_flag ) {
op_mask = CGInteger( cond.mask, TY_UINT_1 );
op_flg = CGLVPreGets( O_OR, op_flg, op_mask, TY_UINT_1 );
} else {
op_mask = CGInteger( NOT_BITARR_MASK( cond.mask ), TY_UINT_1 );
op_flg = CGLVPreGets( O_AND, op_flg, op_mask, TY_UINT_1 );
}
return( op_flg );
}
static cg_name ctorFlagSet( // SET/RESET CTOR FLAG
FN_CTL* fctl, // - function info
cg_op opcode, // - set/reset opcode
patch_handle* a_ph ) // - addr[ patch_handle ]
{
unsigned offset; // - offset of flag byte
unsigned mask; // - mask for byte
cg_name op_flg; // - expression for code-gen
mask = FnCtlCondFlagCtor( fctl );
offset = mask / 8;
mask &= 7;
op_flg = CgSymbolPlusOffset( FstabRw(), offset + CgbkInfo.size_rw_base );
*a_ph = BEPatch();
op_flg = CGLVPreGets( opcode
, op_flg
, CGPatchNode( *a_ph, TY_UINT_1 )
, TY_UINT_1 );
return op_flg;
}
