static an Unary( cg_op op, an left, type_def *tipe )
/***************************************************/
{
instruction *ins;
an res;
ins = MakeNary( (opcode_defs)op, GenIns( left ), NULL, NULL, TypeClass( tipe ), TypeClass( left->tipe ), 1 );
res = InsName( ins, tipe );
AddIns( ins );
BGDone( left );
return( res );
}
extern void BGRetInline( an addr, type_def *tipe ) {
/********************************************************/
an tempaddr;
if( NotEquiv( tipe, InlineStack->tipe ) ) {
_Zoiks( ZOIKS_070 );
}
if( addr == NULL ) {
InlineStack->addr = MakeTempAddr( BGNewTemp(TypeInteger) );
} else {
tempaddr = MakeTempAddr( BGNewTemp( tipe ) );
InlineStack->addr = BGCopy( tempaddr );
BGDone( BGAssign( tempaddr, addr, tipe ) );
}
}
extern void BGParmInline( cg_sym_handle sym, type_def *tipe ) {
/**************************************************************/
name *temp;
name *parm_value;
inline_parm *parm;
parm = InlineStack->parms;
InlineStack->parms = InlineStack->parms->next;
// if( NotEquiv( parm->addr->tipe, tipe ) ) {
// _Zoiks( ZOIKS_070 );
// }
temp = SAllocUserTemp( sym, TypeClass( tipe ), tipe->length );
temp->v.usage |= USE_IN_ANOTHER_BLOCK;
parm_value = GenIns( parm->addr );
BGDone( parm->addr );
AddIns( MakeMove( parm_value, temp, temp->n.name_class ) );
CGFree( parm );
}
static void Far16Parms( cn call ) {
/*************************************/
instruction *ins;
type_length parm_size;
pn parm, next;
instruction *call_ins;
name *eax;
name *ecx;
name *esi;
label_handle lbl;
type_length offset;
name *parmlist;
call_state *state;
rt_class rtindex;
call_ins = call->ins;
parm_size = 0;
state = call->state;
for( parm = call->parms; parm != NULL; parm = parm->next ) {
parm_size += _RoundUp( parm->name->tipe->length, 2 );
}
parmlist = SAllocTemp( XX, parm_size );
parmlist->v.usage |= NEEDS_MEMORY | USE_IN_ANOTHER_BLOCK | USE_ADDRESS;
offset = 0;
for( parm = call->parms; parm != NULL; parm = parm->next ) {
parm->name->u.i.ins->result = STempOffset( parmlist, offset,
TypeClass( parm->name->tipe ),
parm->name->tipe->length );
offset += _RoundUp( parm->name->tipe->length, 2 );
}
for( parm = call->parms; parm != NULL; parm = next ) {
next = parm->next;
parm->name->format = NF_ADDR; /* so instruction doesn't get freed! */
BGDone( parm->name );
CGFree( parm );
}
eax = AllocRegName( HW_EAX );
ecx = AllocRegName( HW_ECX );
esi = AllocRegName( HW_ESI );
HW_TurnOn( state->parm.used, eax->r.reg );
HW_TurnOn( state->parm.used, ecx->r.reg );
HW_TurnOn( state->parm.used, esi->r.reg );
ins = MakeMove( AllocS32Const( parm_size ), ecx, WD );
AddIns( ins );
ins = MakeUnary( OP_LA, parmlist, esi, WD );
AddIns( ins );
if( ins->head.opcode == OP_CALL ) {
ins = MakeUnary( OP_LA, call->name->u.n.name, eax, WD );
} else {
ins = MakeMove( GenIns( call->name ), eax, WD );
call_ins->head.opcode = OP_CALL;
}
call_ins->num_operands = 2;
AddIns( ins );
if( call_ins->type_class == XX ) {
if( state->attr & ROUTINE_ALLOCS_RETURN ) {
rtindex = RT_Far16Cdecl;
} else {
rtindex = RT_Far16Pascal;
}
} else {
rtindex = RT_Far16Func;
}
lbl = RTLabel( rtindex );
call->name->u.n.name = AllocMemory( lbl, 0, CG_LBL, WD );
call_ins->flags.call_flags |= CALL_FAR16 | CALL_POPS_PARMS;
call_ins->operands[CALL_OP_USED] = AllocRegName( state->parm.used );
call_ins->operands[CALL_OP_POPS] = AllocS32Const( 0 );
call_ins->zap = &call_ins->operands[CALL_OP_USED]->r;
}