static void defineOptSym( // DEFINE SYMBOL FOR THREAD_CTL
OPT_DEFN *odef ) // - optimization definition
{
SYMBOL var; // - new variable
var = SymCreateFileScope( TypePtrToVoid()
, SC_EXTERN
, SF_REFERENCED
, optName( odef ) );
odef->sym = var;
LinkageSet( var, "C" );
}
static SYMBOL defineRoutine // DEFINE R/T ROUTINE
( NAME name ) // - routine name
{
SYMBOL sym; // - created symbol
TYPE sym_type; // - symbol's type
symbol_flag flags; // - symbol's flags
sym_type = TypeVoidFunOfVoid();
flags = SF_REFERENCED | SF_NO_LONGJUMP;
sym = SymCreateFileScope( sym_type, SC_EXTERN, flags, name );
LinkageSet( sym, "C" );
return sym;
}
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 ModuleInitInit( // START MODULE-INITIALIZATION FUNCTION
void )
{
SYMBOL module_init; // - SYMBOL for mod-init. function
SCOPE curr_scope; // - current scope
TYPE fn_type; // - type for init function
curr_scope = moduleInitSave();
fn_type = TypeVoidFunOfVoid();
module_init = SymCreateFileScope( fn_type
, SC_STATIC
, 0
, CppSpecialName( SPECIAL_INIT_FUNCTION ) );
module_init_func = module_init;
SetCurrScope(GetFileScope());
ScopeBeginFunction( module_init );
FunctionBodyStartup( module_init, &module_fd, FUNC_NULL );
module_fd.retn_opt = false;
module_init_scope = GetCurrScope();
ScopeKeep( module_init_scope );
moduleInitRestore( curr_scope );
}
PTREE AsmStmt( void )
/*******************/
{
boolean uses_auto;
AUX_INFO *aux_info;
unsigned skip_token;
unsigned skip_alt_token;
PTREE expr;
TYPE fn_type;
TYPE ret_type;
SYMBOL sym;
char *fn_name;
auto VBUF code_buffer;
ppstate_t save_ppstate;
save_ppstate = PPState;
PPState = PPS_EOL;
PPStateAsm = TRUE;
VbufInit( &code_buffer );
NextTokenSkipEOL();
AsmSysInit();
if( ( CurToken == T_LEFT_BRACE ) || ( CurToken == T_ALT_LEFT_BRACE ) ) {
NextTokenSkipEOL();
for(;;) {
getAsmLine( &code_buffer );
if( CurToken == T_RIGHT_BRACE ) break;
if( CurToken == T_ALT_RIGHT_BRACE ) break;
if( CurToken == T_EOF ) break;
NextTokenSkipEOL();
}
skip_token = T_RIGHT_BRACE;
skip_alt_token = T_ALT_RIGHT_BRACE;
} else {
getAsmLine( &code_buffer );
skip_token = skip_alt_token = T_NULL;
}
PPStateAsm = FALSE;
PPState = save_ppstate;
if( ( CurToken == skip_token ) || ( CurToken == skip_alt_token ) ) {
NextToken();
}
if( AsmCodeAddress != 0 ) {
fn_name = NameDummy();
aux_info = AsmSysCreateAux( fn_name );
uses_auto = AsmSysInsertFixups( &code_buffer );
if( uses_auto ) {
AsmSysUsesAuto();
}
AsmSysDone();
ret_type = GetBasicType( TYP_VOID );
fn_type = MakeModifiableFunction( ret_type, NULL );
fn_type->u.f.pragma = aux_info;
fn_type = CheckDupType( fn_type );
sym = SymCreateFileScope( fn_type, SC_NULL, SF_NULL, fn_name );
LinkageSet( sym, "C" );
expr = genFnCall( fn_name );
} else {
expr = NULL;
}
AsmSysFini();
VbufFree( &code_buffer );
return( expr );
}
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 );
}
PTREE AsmStmt( void )
/*******************/
{
bool uses_auto;
AUX_INFO *auxinfo;
TOKEN skip_token;
TOKEN skip_alt_token;
PTREE expr;
TYPE fn_type;
TYPE ret_type;
SYMBOL sym;
NAME fn_name;
auto VBUF code_buffer;
ppctl_t old_ppctl;
old_ppctl = PPControl;
PPCTL_ENABLE_EOL();
PPCTL_ENABLE_ASM();
VbufInit( &code_buffer );
NextTokenSkipEOL();
AsmSysInit();
if( ( CurToken == T_LEFT_BRACE ) || ( CurToken == T_ALT_LEFT_BRACE ) ) {
NextTokenSkipEOL();
for(;;) {
getAsmLine( &code_buffer );
if( CurToken == T_RIGHT_BRACE ) break;
if( CurToken == T_ALT_RIGHT_BRACE ) break;
if( CurToken == T_EOF ) break;
NextTokenSkipEOL();
}
skip_token = T_RIGHT_BRACE;
skip_alt_token = T_ALT_RIGHT_BRACE;
} else {
getAsmLine( &code_buffer );
skip_token = skip_alt_token = T_NULL;
}
PPControl = old_ppctl;
if( ( CurToken == skip_token ) || ( CurToken == skip_alt_token ) ) {
NextToken();
}
if( AsmCodeAddress != 0 ) {
fn_name = NameDummy();
auxinfo = AsmSysCreateAux( NameStr( fn_name ) );
uses_auto = AsmSysInsertFixups( &code_buffer );
if( uses_auto ) {
AsmSysUsesAuto();
}
AsmSysDone();
ret_type = GetBasicType( TYP_VOID );
fn_type = MakeModifiableFunction( ret_type, NULL );
fn_type->u.f.pragma = auxinfo;
fn_type = CheckDupType( fn_type );
sym = SymCreateFileScope( fn_type, SC_NULL, SF_NULL, fn_name );
LinkageSet( sym, "C" );
expr = genFnCall( fn_name );
} else {
expr = NULL;
}
AsmSysFini();
VbufFree( &code_buffer );
return( expr );
}
