Merge pull request #3262 from lindenlab/add_continuations_test

[mono.git] / mono / mini / mini-sparc.c

diff --git a/mono/mini/mini-sparc.c b/mono/mini/mini-sparc.c
index af0805adf29335282fcb7eae617ff1304bd07317..022f8a5e790b8ea9334d4fa61bb7f92c99229c9f 100644 (file)
--- a/mono/mini/mini-sparc.c
+++ b/mono/mini/mini-sparc.c
@@ -801,8 +801,8 @@ mono_arch_allocate_vars (MonoCompile *cfg)
                case ArgInIRegPair: {
                        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;
@@ -943,8 +943,8 @@ mono_arch_allocate_vars (MonoCompile *cfg)
                                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;
@@ -1032,8 +1032,8 @@ mono_arch_create_vars (MonoCompile *cfg)
        }
 
        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;
@@ -1090,16 +1090,16 @@ emit_pass_long (MonoCompile *cfg, MonoCallInst *call, ArgInfo *ainfo, MonoInst *
 
        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 ();
@@ -1347,8 +1347,8 @@ mono_arch_emit_setret (MonoCompile *cfg, MonoMethod *method, MonoInst *val)
                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:
@@ -1561,6 +1561,7 @@ else { \
 static guint32*
 emit_call (MonoCompile *cfg, guint32 *code, guint32 patch_type, gconstpointer data)
 {
+       MonoError error;
        gpointer target;
 
        /* FIXME: This only works if the target method is already compiled */
@@ -1570,7 +1571,8 @@ emit_call (MonoCompile *cfg, guint32 *code, guint32 patch_type, gconstpointer da
                patch_info.type = patch_type;
                patch_info.data.target = data;
 
-               target = mono_resolve_patch_target (cfg->method, cfg->domain, NULL, &patch_info, FALSE);
+               target = mono_resolve_patch_target (cfg->method, cfg->domain, NULL, &patch_info, FALSE, &error);
+               mono_error_raise_exception (&error); /* FIXME: don't raise here */
 
                /* FIXME: Add optimizations if the target is close enough */
                sparc_set (code, target, sparc_o7);
@@ -1822,8 +1824,8 @@ mono_arch_decompose_long_opts (MonoCompile *cfg, MonoInst *ins)
 {
        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:
@@ -3624,7 +3626,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
                        sparc_srl_imm (code, sparc_o7, 4, sparc_o7);
                        sparc_and_imm (code, FALSE, sparc_o7, 2047, sparc_o7);
                        sparc_cmp_imm (code, sparc_o7, 2047);
-                       EMIT_COND_SYSTEM_EXCEPTION (ins, sparc_be, "ArithmeticException");
+                       EMIT_COND_SYSTEM_EXCEPTION (ins, sparc_be, "OverflowException");
 #ifdef SPARCV9
                        sparc_fmovd (code, ins->sreg1, ins->dreg);
 #else
@@ -3670,16 +3672,19 @@ mono_arch_register_lowlevel_calls (void)
 }
 
 void
-mono_arch_patch_code (MonoCompile *cfg, MonoMethod *method, MonoDomain *domain, guint8 *code, MonoJumpInfo *ji, gboolean run_cctors)
+mono_arch_patch_code (MonoCompile *cfg, MonoMethod *method, MonoDomain *domain, guint8 *code, MonoJumpInfo *ji, gboolean run_cctors, MonoError *error)
 {
        MonoJumpInfo *patch_info;
 
+       mono_error_init (error);
+
        /* FIXME: Move part of this to arch independent code */
        for (patch_info = ji; patch_info; patch_info = patch_info->next) {
                unsigned char *ip = patch_info->ip.i + code;
                gpointer target;
 
-               target = mono_resolve_patch_target (method, domain, code, patch_info, run_cctors);
+               target = mono_resolve_patch_target (method, domain, code, patch_info, run_cctors, error);
+               return_if_nok (error);
 
                switch (patch_info->type) {
                case MONO_PATCH_INFO_NONE:
@@ -4204,8 +4209,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
 
                        sparc_patch ((guint32*)(cfg->native_code + patch_info->ip.i), code);
 
-                       exc_class = mono_class_from_name (mono_defaults.corlib, "System", patch_info->data.name);
-                       g_assert (exc_class);
+                       exc_class = mono_class_load_from_name (mono_defaults.corlib, "System", patch_info->data.name);
                        type_idx = exc_class->type_token - MONO_TOKEN_TYPE_DEF;
                        throw_ip = patch_info->ip.i;