qemu-img: Print error if check failed

[qemu.git] / target-m68k / translate.c

diff --git a/target-m68k/translate.c b/target-m68k/translate.c
index 32b8132da62f45e5854448ce715dcd0bbd96f86a..efd4cfc3c739b43c31a9f2284449ef853ef026fa 100644 (file)
--- a/target-m68k/translate.c
+++ b/target-m68k/translate.c
@@ -22,10 +22,13 @@
 #include "disas/disas.h"
 #include "tcg-op.h"
 #include "qemu/log.h"
 #include "disas/disas.h"
 #include "tcg-op.h"
 #include "qemu/log.h"

+#include "exec/cpu_ldst.h"
+
+#include "exec/helper-proto.h"
+#include "exec/helper-gen.h"
+
+#include "trace-tcg.h"

 
 

-#include "helpers.h"
-#define GEN_HELPER 1
-#include "helpers.h"

 
 //#define DEBUG_DISPATCH 1
 
 
 //#define DEBUG_DISPATCH 1
 


@@ -43,6 +46,7 @@
 #undef DEFF64
 
 static TCGv_i32 cpu_halted;
 #undef DEFF64
 
 static TCGv_i32 cpu_halted;

+static TCGv_i32 cpu_exception_index;

 
 static TCGv_ptr cpu_env;
 
 
 static TCGv_ptr cpu_env;
 


@@ -81,6 +85,10 @@ void m68k_tcg_init(void)
     cpu_halted = tcg_global_mem_new_i32(TCG_AREG0,
                                         -offsetof(M68kCPU, env) +
                                         offsetof(CPUState, halted), "HALTED");
     cpu_halted = tcg_global_mem_new_i32(TCG_AREG0,
                                         -offsetof(M68kCPU, env) +
                                         offsetof(CPUState, halted), "HALTED");

+    cpu_exception_index = tcg_global_mem_new_i32(TCG_AREG0,
+                                                 -offsetof(M68kCPU, env) +
+                                                 offsetof(CPUState, exception_index),
+                                                 "EXCEPTION");

 
     cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");
 
 
     cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");
 


@@ -108,17 +116,6 @@ void m68k_tcg_init(void)
 
     NULL_QREG = tcg_global_mem_new(TCG_AREG0, -4, "NULL");
     store_dummy = tcg_global_mem_new(TCG_AREG0, -8, "NULL");
 
     NULL_QREG = tcg_global_mem_new(TCG_AREG0, -4, "NULL");
     store_dummy = tcg_global_mem_new(TCG_AREG0, -8, "NULL");

-
-#define GEN_HELPER 2
-#include "helpers.h"
-}
-
-static inline void qemu_assert(int cond, const char *msg)
-{
-    if (!cond) {
-        fprintf (stderr, "badness: %s\n", msg);
-        abort();
-    }

 }
 
 /* internal defines */
 }
 
 /* internal defines */


@@ -202,7 +199,7 @@ static inline TCGv gen_load(DisasContext * s, int opsize, TCGv addr, int sign)
         tcg_gen_qemu_ld32u(tmp, addr, index);
         break;
     default:
         tcg_gen_qemu_ld32u(tmp, addr, index);
         break;
     default:

-        qemu_assert(0, "bad load size");
+        g_assert_not_reached();

     }
     gen_throws_exception = gen_last_qop;
     return tmp;
     }
     gen_throws_exception = gen_last_qop;
     return tmp;


@@ -236,7 +233,7 @@ static inline void gen_store(DisasContext *s, int opsize, TCGv addr, TCGv val)
         tcg_gen_qemu_st32(val, addr, index);
         break;
     default:
         tcg_gen_qemu_st32(val, addr, index);
         break;
     default:

-        qemu_assert(0, "bad store size");
+        g_assert_not_reached();

     }
     gen_throws_exception = gen_last_qop;
 }
     }
     gen_throws_exception = gen_last_qop;
 }


@@ -440,8 +437,7 @@ static inline int opsize_bytes(int opsize)
     case OS_SINGLE: return 4;
     case OS_DOUBLE: return 8;
     default:
     case OS_SINGLE: return 4;
     case OS_DOUBLE: return 8;
     default:

-        qemu_assert(0, "bad operand size");
-        return 0;
+        g_assert_not_reached();

     }
 }
 
     }
 }
 


@@ -468,8 +464,7 @@ static void gen_partset_reg(int opsize, TCGv reg, TCGv val)
         tcg_gen_mov_i32(reg, val);
         break;
     default:
         tcg_gen_mov_i32(reg, val);
         break;
     default:

-        qemu_assert(0, "Bad operand size");
-        break;
+        g_assert_not_reached();

     }
 }
 
     }
 }
 


@@ -498,7 +493,7 @@ static inline TCGv gen_extend(TCGv val, int opsize, int sign)
         tmp = val;
         break;
     default:
         tmp = val;
         break;
     default:

-        qemu_assert(0, "Bad operand size");
+        g_assert_not_reached();

     }
     return tmp;
 }
     }
     return tmp;
 }


@@ -672,7 +667,7 @@ static TCGv gen_ea(CPUM68KState *env, DisasContext *s, uint16_t insn,
                 offset = read_im32(env, s);
                 break;
             default:
                 offset = read_im32(env, s);
                 break;
             default:

-                qemu_assert(0, "Bad immediate operand");
+                g_assert_not_reached();

             }
             return tcg_const_i32(offset);
         default:
             }
             return tcg_const_i32(offset);
         default:


@@ -869,7 +864,7 @@ static void gen_jmp_tb(DisasContext *s, int n, uint32_t dest)
                (s->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) {
         tcg_gen_goto_tb(n);
         tcg_gen_movi_i32(QREG_PC, dest);
                (s->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) {
         tcg_gen_goto_tb(n);
         tcg_gen_movi_i32(QREG_PC, dest);

-        tcg_gen_exit_tb((tcg_target_long)tb + n);
+        tcg_gen_exit_tb((uintptr_t)tb + n);

     } else {
         gen_jmp_im(s, dest);
         tcg_gen_exit_tb(0);
     } else {
         gen_jmp_im(s, dest);
         tcg_gen_exit_tb(0);


@@ -889,8 +884,10 @@ DISAS_INSN(undef_fpu)
 
 DISAS_INSN(undef)
 {
 
 DISAS_INSN(undef)
 {

+    M68kCPU *cpu = m68k_env_get_cpu(env);
+

     gen_exception(s, s->pc - 2, EXCP_UNSUPPORTED);
     gen_exception(s, s->pc - 2, EXCP_UNSUPPORTED);

-    cpu_abort(env, "Illegal instruction: %04x @ %08x", insn, s->pc - 2);
+    cpu_abort(CPU(cpu), "Illegal instruction: %04x @ %08x", insn, s->pc - 2);

 }
 
 DISAS_INSN(mulw)
 }
 
 DISAS_INSN(mulw)


@@ -2090,12 +2087,14 @@ DISAS_INSN(wddata)
 
 DISAS_INSN(wdebug)
 {
 
 DISAS_INSN(wdebug)
 {

+    M68kCPU *cpu = m68k_env_get_cpu(env);
+

     if (IS_USER(s)) {
         gen_exception(s, s->pc - 2, EXCP_PRIVILEGE);
         return;
     }
     /* TODO: Implement wdebug.  */
     if (IS_USER(s)) {
         gen_exception(s, s->pc - 2, EXCP_PRIVILEGE);
         return;
     }
     /* TODO: Implement wdebug.  */

-    qemu_assert(0, "WDEBUG not implemented");
+    cpu_abort(CPU(cpu), "WDEBUG not implemented");

 }
 
 DISAS_INSN(trap)
 }
 
 DISAS_INSN(trap)


@@ -2469,14 +2468,18 @@ DISAS_INSN(fbcc)
 
 DISAS_INSN(frestore)
 {
 
 DISAS_INSN(frestore)
 {

+    M68kCPU *cpu = m68k_env_get_cpu(env);
+

     /* TODO: Implement frestore.  */
     /* TODO: Implement frestore.  */

-    qemu_assert(0, "FRESTORE not implemented");
+    cpu_abort(CPU(cpu), "FRESTORE not implemented");

 }
 
 DISAS_INSN(fsave)
 {
 }
 
 DISAS_INSN(fsave)
 {

+    M68kCPU *cpu = m68k_env_get_cpu(env);
+

     /* TODO: Implement fsave.  */
     /* TODO: Implement fsave.  */

-    qemu_assert(0, "FSAVE not implemented");
+    cpu_abort(CPU(cpu), "FSAVE not implemented");

 }
 
 static inline TCGv gen_mac_extract_word(DisasContext *s, TCGv val, int upper)
 }
 
 static inline TCGv gen_mac_extract_word(DisasContext *s, TCGv val, int upper)


@@ -2971,9 +2974,11 @@ static void disas_m68k_insn(CPUM68KState * env, DisasContext *s)
 
 /* generate intermediate code for basic block 'tb'.  */
 static inline void
 
 /* generate intermediate code for basic block 'tb'.  */
 static inline void

-gen_intermediate_code_internal(CPUM68KState *env, TranslationBlock *tb,
-                               int search_pc)
+gen_intermediate_code_internal(M68kCPU *cpu, TranslationBlock *tb,
+                               bool search_pc)

 {
 {

+    CPUState *cs = CPU(cpu);
+    CPUM68KState *env = &cpu->env;

     DisasContext dc1, *dc = &dc1;
     uint16_t *gen_opc_end;
     CPUBreakpoint *bp;
     DisasContext dc1, *dc = &dc1;
     uint16_t *gen_opc_end;
     CPUBreakpoint *bp;


@@ -2994,7 +2999,7 @@ gen_intermediate_code_internal(CPUM68KState *env, TranslationBlock *tb,
     dc->is_jmp = DISAS_NEXT;
     dc->pc = pc_start;
     dc->cc_op = CC_OP_DYNAMIC;
     dc->is_jmp = DISAS_NEXT;
     dc->pc = pc_start;
     dc->cc_op = CC_OP_DYNAMIC;

-    dc->singlestep_enabled = env->singlestep_enabled;
+    dc->singlestep_enabled = cs->singlestep_enabled;

     dc->fpcr = env->fpcr;
     dc->user = (env->sr & SR_S) == 0;
     dc->is_mem = 0;
     dc->fpcr = env->fpcr;
     dc->user = (env->sr & SR_S) == 0;
     dc->is_mem = 0;


@@ -3009,8 +3014,8 @@ gen_intermediate_code_internal(CPUM68KState *env, TranslationBlock *tb,
     do {
         pc_offset = dc->pc - pc_start;
         gen_throws_exception = NULL;
     do {
         pc_offset = dc->pc - pc_start;
         gen_throws_exception = NULL;

-        if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
-            QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
+        if (unlikely(!QTAILQ_EMPTY(&cs->breakpoints))) {
+            QTAILQ_FOREACH(bp, &cs->breakpoints, entry) {

                 if (bp->pc == dc->pc) {
                     gen_exception(dc, dc->pc, EXCP_DEBUG);
                     dc->is_jmp = DISAS_JUMP;
                 if (bp->pc == dc->pc) {
                     gen_exception(dc, dc->pc, EXCP_DEBUG);
                     dc->is_jmp = DISAS_JUMP;


@@ -3037,14 +3042,14 @@ gen_intermediate_code_internal(CPUM68KState *env, TranslationBlock *tb,
        disas_m68k_insn(env, dc);
         num_insns++;
     } while (!dc->is_jmp && tcg_ctx.gen_opc_ptr < gen_opc_end &&
        disas_m68k_insn(env, dc);
         num_insns++;
     } while (!dc->is_jmp && tcg_ctx.gen_opc_ptr < gen_opc_end &&

-             !env->singlestep_enabled &&
+             !cs->singlestep_enabled &&

              !singlestep &&
              (pc_offset) < (TARGET_PAGE_SIZE - 32) &&
              num_insns < max_insns);
 
     if (tb->cflags & CF_LAST_IO)
         gen_io_end();
              !singlestep &&
              (pc_offset) < (TARGET_PAGE_SIZE - 32) &&
              num_insns < max_insns);
 
     if (tb->cflags & CF_LAST_IO)
         gen_io_end();

-    if (unlikely(env->singlestep_enabled)) {
+    if (unlikely(cs->singlestep_enabled)) {

         /* Make sure the pc is updated, and raise a debug exception.  */
         if (!dc->is_jmp) {
             gen_flush_cc_op(dc);
         /* Make sure the pc is updated, and raise a debug exception.  */
         if (!dc->is_jmp) {
             gen_flush_cc_op(dc);


@@ -3096,17 +3101,19 @@ gen_intermediate_code_internal(CPUM68KState *env, TranslationBlock *tb,
 
 void gen_intermediate_code(CPUM68KState *env, TranslationBlock *tb)
 {
 
 void gen_intermediate_code(CPUM68KState *env, TranslationBlock *tb)
 {

-    gen_intermediate_code_internal(env, tb, 0);
+    gen_intermediate_code_internal(m68k_env_get_cpu(env), tb, false);

 }
 
 void gen_intermediate_code_pc(CPUM68KState *env, TranslationBlock *tb)
 {
 }
 
 void gen_intermediate_code_pc(CPUM68KState *env, TranslationBlock *tb)
 {

-    gen_intermediate_code_internal(env, tb, 1);
+    gen_intermediate_code_internal(m68k_env_get_cpu(env), tb, true);

 }
 
 }
 

-void cpu_dump_state(CPUM68KState *env, FILE *f, fprintf_function cpu_fprintf,
-                    int flags)
+void m68k_cpu_dump_state(CPUState *cs, FILE *f, fprintf_function cpu_fprintf,
+                         int flags)

 {
 {

+    M68kCPU *cpu = M68K_CPU(cs);
+    CPUM68KState *env = &cpu->env;

     int i;
     uint16_t sr;
     CPU_DoubleU u;
     int i;
     uint16_t sr;
     CPU_DoubleU u;