//--------- Begin of function FirmMonster::assign_unit ---------//
//
// Mobilized defender units are assigned back to the firm.
//
void FirmMonster::assign_unit(int unitRecno)
{
Unit* unitPtr = unit_array[unitRecno];
UnitInfo* unitInfo = unit_res[unitPtr->unit_id];
err_when( !unitInfo->is_monster );
switch( unitPtr->rank_id )
{
case RANK_KING:
set_king(unitPtr->get_monster_id(), unitPtr->skill.combat_level);
break;
case RANK_GENERAL:
add_general(unitRecno);
break;
case RANK_SOLDIER:
add_soldier(unitPtr->leader_unit_recno);
break;
}
//--------- the unit disappear in firm -----//
unit_array.disappear_in_firm(unitRecno);
}
static void
calculate_sizes (MonoMethodSignature *sig, guint *stack_size, guint *code_size,
gboolean string_ctor, gboolean *use_memcpy)
{
guint i, fr, gr;
guint32 simpletype;
fr = gr = 0;
*stack_size = MINIMAL_STACK_SIZE * SLOT_SIZE;
*code_size = (PROLOG_INS + CALL_INS + EPILOG_INS) * 4;
/* function arguments */
if (sig->hasthis)
add_general (&gr, stack_size, code_size, TRUE);
for (i = 0; i < sig->param_count; i++) {
if (sig->params[i]->byref) {
add_general (&gr, stack_size, code_size, TRUE);
continue;
}
simpletype = sig->params[i]->type;
enum_calc_size:
switch (simpletype) {
case MONO_TYPE_R4:
#if SPARCV9
(*code_size) += 4; /* for the fdtos */
#else
(*code_size) += 12;
(*stack_size) += 4;
#endif
case MONO_TYPE_BOOLEAN:
case MONO_TYPE_CHAR:
case MONO_TYPE_I1:
case MONO_TYPE_U1:
case MONO_TYPE_I2:
case MONO_TYPE_U2:
case MONO_TYPE_I4:
case MONO_TYPE_U4:
case MONO_TYPE_I:
case MONO_TYPE_U:
case MONO_TYPE_PTR:
case MONO_TYPE_CLASS:
case MONO_TYPE_OBJECT:
case MONO_TYPE_STRING:
case MONO_TYPE_SZARRAY:
add_general (&gr, stack_size, code_size, TRUE);
break;
case MONO_TYPE_VALUETYPE: {
gint size;
guint32 align;
if (sig->params[i]->data.klass->enumtype) {
simpletype = sig->params[i]->data.klass->enum_basetype->type;
goto enum_calc_size;
}
size = mono_class_native_size (sig->params[i]->data.klass, &align);
#if SPARCV9
if (size != 4) {
#else
if (1) {
#endif
DEBUG(fprintf(stderr, "copy %d byte struct on stack\n", size));
*use_memcpy = TRUE;
*code_size += 8*4;
*stack_size = (*stack_size + (align - 1)) & (~(align -1));
*stack_size += (size + 3) & (~3);
if (gr > OUT_REGS) {
*code_size += 4;
*stack_size += 4;
}
} else {
add_general (&gr, stack_size, code_size, TRUE);
#if SPARCV9
*code_size += 8;
#else
*code_size += 4;
#endif
}
break;
}
case MONO_TYPE_I8:
case MONO_TYPE_R8:
add_general (&gr, stack_size, code_size, FALSE);
break;
default:
g_error ("Can't trampoline 0x%x", sig->params[i]->type);
}
}
/* function return value */
if (sig->ret->byref || string_ctor) {
*code_size += 8;
} else {
simpletype = sig->ret->type;
enum_retvalue:
switch (simpletype) {
case MONO_TYPE_BOOLEAN:
case MONO_TYPE_I1:
case MONO_TYPE_U1:
case MONO_TYPE_I2:
case MONO_TYPE_U2:
case MONO_TYPE_CHAR:
case MONO_TYPE_I4:
case MONO_TYPE_U4:
case MONO_TYPE_I:
case MONO_TYPE_U:
case MONO_TYPE_CLASS:
case MONO_TYPE_OBJECT:
case MONO_TYPE_PTR:
case MONO_TYPE_STRING:
case MONO_TYPE_R4:
case MONO_TYPE_R8:
case MONO_TYPE_SZARRAY:
case MONO_TYPE_ARRAY:
*code_size += 8;
break;
case MONO_TYPE_I8:
*code_size += 12;
break;
case MONO_TYPE_VALUETYPE: {
gint size;
if (sig->ret->data.klass->enumtype) {
simpletype = sig->ret->data.klass->enum_basetype->type;
goto enum_retvalue;
}
size = mono_class_native_size (sig->ret->data.klass, NULL);
#if SPARCV9
if (size <= 32)
*code_size += 8 + (size + 7) / 2;
else
*code_size += 8;
#else
*code_size += 8;
#endif
break;
}
case MONO_TYPE_VOID:
break;
default:
g_error ("Can't handle as return value 0x%x", sig->ret->type);
}
}
if (*use_memcpy) {
*stack_size += 8;
*code_size += 24;
if (sig->hasthis) {
*stack_size += SLOT_SIZE;
*code_size += 4;
}
}
*stack_size = (*stack_size + (FRAME_ALIGN - 1)) & (~(FRAME_ALIGN -1));
}
static inline guint32 *
emit_epilog (guint32 *p, MonoMethodSignature *sig, guint stack_size)
{
int ret_offset = 8;
/*
* Standard epilog.
* 8 may be 12 when returning structures (to skip unimp opcode).
*/
#if !SPARCV9
if (sig != NULL && !sig->ret->byref && sig->ret->type == MONO_TYPE_VALUETYPE && !sig->ret->data.klass->enumtype)
ret_offset = 12;
#endif
sparc_jmpl_imm (p, sparc_i7, ret_offset, sparc_zero);
sparc_restore (p, sparc_zero, sparc_zero, sparc_zero);
return p;
}
static void inline
calculate_sizes (MonoMethodSignature *sig, size_data *sz,
gboolean string_ctor)
{
guint i, fr, gr, size;
guint32 simpletype, align;
fr = 0;
gr = 2;
sz->retStruct = 0;
sz->stack_size = S390_MINIMAL_STACK_SIZE;
sz->code_size = (PROLOG_INS + CALL_INS + EPILOG_INS);
sz->local_size = 0;
if (sig->hasthis) {
add_general (&gr, sz, TRUE);
}
/*----------------------------------------------------------*/
/* We determine the size of the return code/stack in case we*/
/* need to reserve a register to be used to address a stack */
/* area that the callee will use. */
/*----------------------------------------------------------*/
if (sig->ret->byref || string_ctor) {
sz->code_size += 8;
} else {
simpletype = sig->ret->type;
enum_retvalue:
switch (simpletype) {
case MONO_TYPE_BOOLEAN:
case MONO_TYPE_I1:
case MONO_TYPE_U1:
case MONO_TYPE_I2:
case MONO_TYPE_U2:
case MONO_TYPE_CHAR:
case MONO_TYPE_I4:
case MONO_TYPE_U4:
case MONO_TYPE_I:
case MONO_TYPE_U:
case MONO_TYPE_CLASS:
case MONO_TYPE_OBJECT:
case MONO_TYPE_R4:
case MONO_TYPE_R8:
case MONO_TYPE_PTR:
case MONO_TYPE_SZARRAY:
case MONO_TYPE_ARRAY:
case MONO_TYPE_STRING:
sz->code_size += 4;
break;
case MONO_TYPE_I8:
sz->code_size += 4;
break;
case MONO_TYPE_VALUETYPE:
if (sig->ret->data.klass->enumtype) {
simpletype = sig->ret->data.klass->enum_basetype->type;
goto enum_retvalue;
}
gr++;
if (sig->pinvoke)
size = mono_class_native_size (sig->ret->data.klass, &align);
else
size = mono_class_value_size (sig->ret->data.klass, &align);
if (align > 1)
sz->code_size += 10;
switch (size) {
/*----------------------------------*/
/* On S/390, structures of size 1, */
/* 2, 4, and 8 bytes are returned */
/* in (a) register(s). */
/*----------------------------------*/
case 1:
case 2:
case 4:
case 8:
sz->code_size += 16;
sz->stack_size += 4;
break;
default:
sz->retStruct = 1;
sz->code_size += 32;
}
break;
case MONO_TYPE_VOID:
break;
default:
g_error ("Can't handle as return value 0x%x", sig->ret->type);
}
}
/*----------------------------------------------------------*/
/* We determine the size of the parameter code and stack */
/* requirements by checking the types and sizes of the */
/* parameters. */
/*----------------------------------------------------------*/
for (i = 0; i < sig->param_count; ++i) {
if (sig->params [i]->byref) {
add_general (&gr, sz, TRUE);
continue;
}
simpletype = sig->params [i]->type;
enum_calc_size:
switch (simpletype) {
case MONO_TYPE_BOOLEAN:
case MONO_TYPE_CHAR:
case MONO_TYPE_I1:
case MONO_TYPE_U1:
case MONO_TYPE_I2:
case MONO_TYPE_U2:
case MONO_TYPE_I4:
case MONO_TYPE_U4:
case MONO_TYPE_I:
case MONO_TYPE_U:
case MONO_TYPE_PTR:
case MONO_TYPE_CLASS:
case MONO_TYPE_OBJECT:
case MONO_TYPE_STRING:
add_general (&gr, sz, TRUE);
break;
case MONO_TYPE_SZARRAY:
add_general (&gr, sz, TRUE);
break;
case MONO_TYPE_VALUETYPE:
if (sig->params [i]->data.klass->enumtype) {
simpletype = sig->params [i]->data.klass->enum_basetype->type;
goto enum_calc_size;
}
if (sig->pinvoke)
size = mono_class_native_size (sig->params [i]->data.klass, &align);
else
size = mono_class_value_size (sig->params [i]->data.klass, &align);
DEBUG(printf("%d typesize: %d (%d)\n",i,size,align));
switch (size) {
/*----------------------------------*/
/* On S/390, structures of size 1, */
/* 2, 4, and 8 bytes are passed in */
/* (a) register(s). */
/*----------------------------------*/
case 0:
case 1:
case 2:
case 4:
add_general(&gr, sz, TRUE);
break;
case 8:
add_general(&gr, sz, FALSE);
break;
default:
sz->local_size += (size + (size % align));
sz->code_size += 40;
}
break;
case MONO_TYPE_I8:
add_general (&gr, sz, FALSE);
break;
case MONO_TYPE_R4:
if (fr < FLOAT_REGS) {
sz->code_size += 4;
fr++;
}
else {
sz->code_size += 4;
sz->stack_size += 8;
}
break;
case MONO_TYPE_R8:
if (fr < FLOAT_REGS) {
sz->code_size += 4;
fr++;
} else {
sz->code_size += 4;
sz->stack_size += 8 + (sz->stack_size % 8);
}
break;
default:
g_error ("Can't trampoline 0x%x", sig->params [i]->type);
}
}
/* align stack size to 8 */
DEBUG (printf (" stack size: %d (%d)\n"
" code size: %d\n"
" local size: %d\n",
(sz->stack_size + 8) & ~8, sz->stack_size,
(sz->code_size),(sz->local_size + 8) & ~8));
sz->stack_size = (sz->stack_size + 8) & ~8;
sz->local_size = (sz->local_size + 8) & ~8;
}
