guint32 stack_size = 0;
CallInfo *cinfo;
MonoType *ret_type;
- MonoGenericSharingContext *gsctx = cfg ? cfg->generic_sharing_context : NULL;
cinfo = g_malloc0 (sizeof (CallInfo) + (sizeof (ArgInfo) * n));
add_general (&gr, &stack_size, ainfo, FALSE);
continue;
}
- ptype = mono_type_get_underlying_type (sig->params [i]);
- ptype = mini_get_basic_type_from_generic (gsctx, ptype);
+ ptype = mini_get_underlying_type (sig->params [i]);
switch (ptype->type) {
case MONO_TYPE_BOOLEAN:
case MONO_TYPE_I1:
}
/* return value */
- ret_type = mono_type_get_underlying_type (sig->ret);
- ret_type = mini_get_basic_type_from_generic (gsctx, ret_type);
+ ret_type = mini_get_underlying_type (sig->ret);
switch (ret_type->type) {
case MONO_TYPE_BOOLEAN:
case MONO_TYPE_I1:
cfg->ret->inst_c0 = cinfo->ret.reg;
break;
case ArgInIRegPair: {
- MonoType *t = mono_type_get_underlying_type (sig->ret);
+ MonoType *t = mini_get_underlying_type (sig->ret);
if (((t->type == MONO_TYPE_I8) || (t->type == MONO_TYPE_U8))) {
- MonoInst *low = get_vreg_to_inst (cfg, cfg->ret->dreg + 1);
- MonoInst *high = get_vreg_to_inst (cfg, cfg->ret->dreg + 2);
+ MonoInst *low = get_vreg_to_inst (cfg, MONO_LVREG_LS (cfg->ret->dreg));
+ MonoInst *high = get_vreg_to_inst (cfg, MONO_LVREG_MS (cfg->ret->dreg));
low->opcode = OP_REGVAR;
low->dreg = cinfo->ret.reg + 1;
if (inst->backend.is_pinvoke && MONO_TYPE_ISSTRUCT (inst->inst_vtype) && inst->inst_vtype->type != MONO_TYPE_TYPEDBYREF)
size = mono_class_native_size (mono_class_from_mono_type (inst->inst_vtype), &align);
else
- size = mini_type_stack_size (cfg->generic_sharing_context, inst->inst_vtype, &align);
+ size = mini_type_stack_size (inst->inst_vtype, &align);
/*
* This is needed since structures containing doubles must be doubleword
break;
case ArgInIRegPair:
if (inst->type == STACK_I8) {
- MonoInst *low = get_vreg_to_inst (cfg, inst->dreg + 1);
- MonoInst *high = get_vreg_to_inst (cfg, inst->dreg + 2);
+ MonoInst *low = get_vreg_to_inst (cfg, MONO_LVREG_LS (inst->dreg));
+ MonoInst *high = get_vreg_to_inst (cfg, MONO_LVREG_MS (inst->dreg));
low->opcode = OP_REGVAR;
low->dreg = sparc_i0 + ainfo->reg + 1;
}
if (!sig->ret->byref && (sig->ret->type == MONO_TYPE_I8 || sig->ret->type == MONO_TYPE_U8)) {
- MonoInst *low = get_vreg_to_inst (cfg, cfg->ret->dreg + 1);
- MonoInst *high = get_vreg_to_inst (cfg, cfg->ret->dreg + 2);
+ MonoInst *low = get_vreg_to_inst (cfg, MONO_LVREG_LS (cfg->ret->dreg));
+ MonoInst *high = get_vreg_to_inst (cfg, MONO_LVREG_MS (cfg->ret->dreg));
low->flags |= MONO_INST_VOLATILE;
high->flags |= MONO_INST_VOLATILE;
switch (ainfo->storage) {
case ArgInIRegPair:
- add_outarg_reg (cfg, call, ArgInIReg, sparc_o0 + ainfo->reg + 1, in->dreg + 1);
- add_outarg_reg (cfg, call, ArgInIReg, sparc_o0 + ainfo->reg, in->dreg + 2);
+ add_outarg_reg (cfg, call, ArgInIReg, sparc_o0 + ainfo->reg + 1, MONO_LVREG_LS (in->dreg));
+ add_outarg_reg (cfg, call, ArgInIReg, sparc_o0 + ainfo->reg, MONO_LVREG_MS (in->dreg));
break;
case ArgOnStackPair:
- MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, sparc_sp, offset, in->dreg + 2);
- MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, sparc_sp, offset + 4, in->dreg + 1);
+ MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, sparc_sp, offset, MONO_LVREG_MS (in->dreg));
+ MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, sparc_sp, offset + 4, MONO_LVREG_LS (in->dreg));
break;
case ArgInSplitRegStack:
- add_outarg_reg (cfg, call, ArgInIReg, sparc_o0 + ainfo->reg, in->dreg + 2);
- MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, sparc_sp, offset + 4, in->dreg + 1);
+ add_outarg_reg (cfg, call, ArgInIReg, sparc_o0 + ainfo->reg, MONO_LVREG_MS (in->dreg));
+ MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, sparc_sp, offset + 4, MONO_LVREG_LS (in->dreg));
break;
default:
g_assert_not_reached ();
else
arg_type = sig->params [i - sig->hasthis];
- arg_type = mono_type_get_underlying_type (arg_type);
+ arg_type = mini_get_underlying_type (arg_type);
if ((i >= sig->hasthis) && (MONO_TYPE_ISSTRUCT(sig->params [i - sig->hasthis])))
emit_pass_vtype (cfg, call, cinfo, ainfo, arg_type, in, sig->pinvoke);
else if (!arg_type->byref && ((arg_type->type == MONO_TYPE_I8) || (arg_type->type == MONO_TYPE_U8)))
mono_arch_emit_setret (MonoCompile *cfg, MonoMethod *method, MonoInst *val)
{
CallInfo *cinfo = get_call_info (cfg, mono_method_signature (method), FALSE);
- MonoType *ret = mini_type_get_underlying_type (cfg->generic_sharing_context, mono_method_signature (method)->ret);
+ MonoType *ret = mini_get_underlying_type (mono_method_signature (method)->ret);
switch (cinfo->ret.storage) {
case ArgInIReg:
if (ret->type == MONO_TYPE_I8 || ret->type == MONO_TYPE_U8) {
MONO_EMIT_NEW_UNALU (cfg, OP_LMOVE, cfg->ret->dreg, val->dreg);
} else {
- MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, cfg->ret->dreg + 2, val->dreg + 2);
- MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, cfg->ret->dreg + 1, val->dreg + 1);
+ MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, MONO_LVREG_MS (cfg->ret->dreg), MONO_LVREG_MS (val->dreg));
+ MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, MONO_LVREG_LS (cfg->ret->dreg), MONO_LVREG_LS (val->dreg));
}
break;
case ArgInFReg:
{
switch (ins->opcode) {
case OP_LNEG:
- MONO_EMIT_NEW_BIALU (cfg, OP_SUBCC, ins->dreg + 1, 0, ins->sreg1 + 1);
- MONO_EMIT_NEW_BIALU (cfg, OP_SBB, ins->dreg + 2, 0, ins->sreg1 + 2);
+ MONO_EMIT_NEW_BIALU (cfg, OP_SUBCC, MONO_LVREG_LS (ins->dreg), 0, MONO_LVREG_LS (ins->sreg1));
+ MONO_EMIT_NEW_BIALU (cfg, OP_SBB, MONO_LVREG_MS (ins->dreg), 0, MONO_LVREG_MS (ins->sreg1));
NULLIFY_INS (ins);
break;
default:
}
static guint32*
-emit_vret_token (MonoGenericSharingContext *gsctx, MonoInst *ins, guint32 *code)
+emit_vret_token (MonoInst *ins, guint32 *code)
{
MonoCallInst *call = (MonoCallInst*)ins;
guint32 size;
*/
if (call->signature->pinvoke && MONO_TYPE_ISSTRUCT(call->signature->ret)) {
if (call->signature->ret->type == MONO_TYPE_TYPEDBYREF)
- size = mini_type_stack_size (gsctx, call->signature->ret, NULL);
+ size = mini_type_stack_size (call->signature->ret, NULL);
else
size = mono_class_native_size (call->signature->ret->data.klass, NULL);
sparc_unimp (code, size & 0xfff);
mono_stats.imt_thunks_size += (code - start) * 4;
g_assert (code - start <= size);
+
+ mono_tramp_info_register (mono_tramp_info_create (NULL, start, code - start, NULL, NULL), domain);
+
return start;
}
else
code = emit_call (cfg, code, MONO_PATCH_INFO_ABS, call->fptr);
- code = emit_vret_token (cfg->generic_sharing_context, ins, code);
+ code = emit_vret_token (ins, code);
code = emit_move_return_value (ins, code);
break;
case OP_FCALL_REG:
else
sparc_nop (code);
- code = emit_vret_token (cfg->generic_sharing_context, ins, code);
+ code = emit_vret_token (ins, code);
code = emit_move_return_value (ins, code);
break;
case OP_FCALL_MEMBASE:
else
sparc_nop (code);
- code = emit_vret_token (cfg->generic_sharing_context, ins, code);
+ code = emit_vret_token (ins, code);
code = emit_move_return_value (ins, code);
break;
case OP_SETFRET:
case OP_MEMORY_BARRIER:
sparc_membar (code, sparc_membar_all);
break;
+ case OP_GC_SAFE_POINT:
+ break;
default:
#ifdef __GNUC__
}
void
-mono_arch_patch_code (MonoMethod *method, MonoDomain *domain, guint8 *code, MonoJumpInfo *ji, MonoCodeManager *dyn_code_mp, gboolean run_cctors)
+mono_arch_patch_code (MonoCompile *cfg, MonoMethod *method, MonoDomain *domain, guint8 *code, MonoJumpInfo *ji, gboolean run_cctors)
{
MonoJumpInfo *patch_info;
switch (patch_info->type) {
case MONO_PATCH_INFO_NONE:
continue;
- case MONO_PATCH_INFO_CLASS_INIT: {
- guint32 *ip2 = (guint32*)ip;
- /* Might already been changed to a nop */
-#ifdef SPARCV9
- sparc_set_template (ip2, sparc_o7);
- sparc_jmpl (ip2, sparc_o7, sparc_g0, sparc_o7);
-#else
- sparc_call_simple (ip2, 0);
-#endif
- break;
- }
case MONO_PATCH_INFO_METHOD_JUMP: {
guint32 *ip2 = (guint32*)ip;
/* Might already been patched */
int save_mode = SAVE_NONE;
MonoMethod *method = cfg->method;
- switch (mono_type_get_underlying_type (mono_method_signature (method)->ret)->type) {
+ switch (mini_get_underlying_type (mono_method_signature (method)->ret)->type) {
case MONO_TYPE_VOID:
/* special case string .ctor icall */
if (strcmp (".ctor", method->name) && method->klass == mono_defaults.string_class)
}
- jit_tls = pthread_getspecific (mono_get_jit_tls_key ());
+ jit_tls = mono_get_jit_tls ();
#ifdef MONO_SPARC_THR_TLS
thr_setspecific (lmf_addr_key, &jit_tls->lmf);
* Returns the size of the activation frame.
*/
int
-mono_arch_get_argument_info (MonoGenericSharingContext *gsctx, MonoMethodSignature *csig, int param_count, MonoJitArgumentInfo *arg_info)
+mono_arch_get_argument_info (MonoMethodSignature *csig, int param_count, MonoJitArgumentInfo *arg_info)
{
int k, align;
CallInfo *cinfo;
/* FIXME: implement */
g_assert_not_reached ();
}
+
+gboolean
+mono_arch_opcode_supported (int opcode)
+{
+ return FALSE;
+}