Merge remote-tracking branch 'remotes/borntraeger/tags/s390x-20150310' into staging

[qemu.git] / target-sparc / cpu.c

diff --git a/target-sparc/cpu.c b/target-sparc/cpu.c
index 5806e59af374f3d10242494a00cced9a0b8bfbd4..a9520970964bb1672c08ff7f7fddfa7281b0d907 100644 (file)
--- a/target-sparc/cpu.c
+++ b/target-sparc/cpu.c
@@ -18,6 +18,7 @@
  */
 
 #include "cpu.h"
  */
 
 #include "cpu.h"

+#include "qemu/error-report.h"

 
 //#define DEBUG_FEATURES
 
 
 //#define DEBUG_FEATURES
 


@@ -32,8 +33,8 @@ static void sparc_cpu_reset(CPUState *s)
 
     scc->parent_reset(s);
 
 
     scc->parent_reset(s);
 

-    memset(env, 0, offsetof(CPUSPARCState, breakpoints));
-    tlb_flush(env, 1);
+    memset(env, 0, offsetof(CPUSPARCState, version));
+    tlb_flush(s, 1);

     env->cwp = 0;
 #ifndef TARGET_SPARC64
     env->wim = 1;
     env->cwp = 0;
 #ifndef TARGET_SPARC64
     env->wim = 1;


@@ -69,21 +70,51 @@ static void sparc_cpu_reset(CPUState *s)
     env->cache_control = 0;
 }
 
     env->cache_control = 0;
 }
 

-static int cpu_sparc_register(CPUSPARCState *env, const char *cpu_model)
+static bool sparc_cpu_exec_interrupt(CPUState *cs, int interrupt_request)

 {
 {

+    if (interrupt_request & CPU_INTERRUPT_HARD) {
+        SPARCCPU *cpu = SPARC_CPU(cs);
+        CPUSPARCState *env = &cpu->env;
+
+        if (cpu_interrupts_enabled(env) && env->interrupt_index > 0) {
+            int pil = env->interrupt_index & 0xf;
+            int type = env->interrupt_index & 0xf0;
+
+            if (type != TT_EXTINT || cpu_pil_allowed(env, pil)) {
+                cs->exception_index = env->interrupt_index;
+                sparc_cpu_do_interrupt(cs);
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+static int cpu_sparc_register(SPARCCPU *cpu, const char *cpu_model)
+{
+    CPUClass *cc = CPU_GET_CLASS(cpu);
+    CPUSPARCState *env = &cpu->env;
+    char *s = g_strdup(cpu_model);
+    char *featurestr, *name = strtok(s, ",");

     sparc_def_t def1, *def = &def1;
     sparc_def_t def1, *def = &def1;

+    Error *err = NULL;

 
 

-    if (cpu_sparc_find_by_name(def, cpu_model) < 0) {
+    if (cpu_sparc_find_by_name(def, name) < 0) {
+        g_free(s);

         return -1;
     }
 
     env->def = g_new0(sparc_def_t, 1);
     memcpy(env->def, def, sizeof(*def));
         return -1;
     }
 
     env->def = g_new0(sparc_def_t, 1);
     memcpy(env->def, def, sizeof(*def));

-#if defined(CONFIG_USER_ONLY)
-    if ((env->def->features & CPU_FEATURE_FLOAT)) {
-        env->def->features |= CPU_FEATURE_FLOAT128;
+
+    featurestr = strtok(NULL, ",");
+    cc->parse_features(CPU(cpu), featurestr, &err);
+    g_free(s);
+    if (err) {
+        error_report_err(err);
+        return -1;

     }
     }

-#endif
+

     env->version = def->iu_version;
     env->fsr = def->fpu_version;
     env->nwindows = def->nwindows;
     env->version = def->iu_version;
     env->fsr = def->fpu_version;
     env->nwindows = def->nwindows;


@@ -103,12 +134,10 @@ static int cpu_sparc_register(CPUSPARCState *env, const char *cpu_model)
 SPARCCPU *cpu_sparc_init(const char *cpu_model)
 {
     SPARCCPU *cpu;
 SPARCCPU *cpu_sparc_init(const char *cpu_model)
 {
     SPARCCPU *cpu;

-    CPUSPARCState *env;

 
     cpu = SPARC_CPU(object_new(TYPE_SPARC_CPU));
 
     cpu = SPARC_CPU(object_new(TYPE_SPARC_CPU));

-    env = &cpu->env;

 
 

-    if (cpu_sparc_register(env, cpu_model) < 0) {
+    if (cpu_sparc_register(cpu, cpu_model) < 0) {

         object_unref(OBJECT(cpu));
         return NULL;
     }
         object_unref(OBJECT(cpu));
         return NULL;
     }


@@ -506,19 +535,13 @@ static void add_flagname_to_bitmaps(const char *flagname, uint32_t *features)
             return;
         }
     }
             return;
         }
     }

-    fprintf(stderr, "CPU feature %s not found\n", flagname);
+    error_report("CPU feature %s not found", flagname);

 }
 
 }
 

-static int cpu_sparc_find_by_name(sparc_def_t *cpu_def, const char *cpu_model)
+static int cpu_sparc_find_by_name(sparc_def_t *cpu_def, const char *name)

 {
     unsigned int i;
     const sparc_def_t *def = NULL;
 {
     unsigned int i;
     const sparc_def_t *def = NULL;

-    char *s = g_strdup(cpu_model);
-    char *featurestr, *name = strtok(s, ",");
-    uint32_t plus_features = 0;
-    uint32_t minus_features = 0;
-    uint64_t iu_version;
-    uint32_t fpu_version, mmu_version, nwindows;

 
     for (i = 0; i < ARRAY_SIZE(sparc_defs); i++) {
         if (strcasecmp(name, sparc_defs[i].name) == 0) {
 
     for (i = 0; i < ARRAY_SIZE(sparc_defs); i++) {
         if (strcasecmp(name, sparc_defs[i].name) == 0) {


@@ -526,11 +549,24 @@ static int cpu_sparc_find_by_name(sparc_def_t *cpu_def, const char *cpu_model)
         }
     }
     if (!def) {
         }
     }
     if (!def) {

-        goto error;
+        return -1;

     }
     memcpy(cpu_def, def, sizeof(*def));
     }
     memcpy(cpu_def, def, sizeof(*def));

+    return 0;
+}

 
 

-    featurestr = strtok(NULL, ",");
+static void sparc_cpu_parse_features(CPUState *cs, char *features,
+                                     Error **errp)
+{
+    SPARCCPU *cpu = SPARC_CPU(cs);
+    sparc_def_t *cpu_def = cpu->env.def;
+    char *featurestr;
+    uint32_t plus_features = 0;
+    uint32_t minus_features = 0;
+    uint64_t iu_version;
+    uint32_t fpu_version, mmu_version, nwindows;
+
+    featurestr = features ? strtok(features, ",") : NULL;

     while (featurestr) {
         char *val;
 
     while (featurestr) {
         char *val;
 


@@ -545,8 +581,8 @@ static int cpu_sparc_find_by_name(sparc_def_t *cpu_def, const char *cpu_model)
 
                 iu_version = strtoll(val, &err, 0);
                 if (!*val || *err) {
 
                 iu_version = strtoll(val, &err, 0);
                 if (!*val || *err) {

-                    fprintf(stderr, "bad numerical value %s\n", val);
-                    goto error;
+                    error_setg(errp, "bad numerical value %s", val);
+                    return;

                 }
                 cpu_def->iu_version = iu_version;
 #ifdef DEBUG_FEATURES
                 }
                 cpu_def->iu_version = iu_version;
 #ifdef DEBUG_FEATURES


@@ -557,8 +593,8 @@ static int cpu_sparc_find_by_name(sparc_def_t *cpu_def, const char *cpu_model)
 
                 fpu_version = strtol(val, &err, 0);
                 if (!*val || *err) {
 
                 fpu_version = strtol(val, &err, 0);
                 if (!*val || *err) {

-                    fprintf(stderr, "bad numerical value %s\n", val);
-                    goto error;
+                    error_setg(errp, "bad numerical value %s", val);
+                    return;

                 }
                 cpu_def->fpu_version = fpu_version;
 #ifdef DEBUG_FEATURES
                 }
                 cpu_def->fpu_version = fpu_version;
 #ifdef DEBUG_FEATURES


@@ -569,8 +605,8 @@ static int cpu_sparc_find_by_name(sparc_def_t *cpu_def, const char *cpu_model)
 
                 mmu_version = strtol(val, &err, 0);
                 if (!*val || *err) {
 
                 mmu_version = strtol(val, &err, 0);
                 if (!*val || *err) {

-                    fprintf(stderr, "bad numerical value %s\n", val);
-                    goto error;
+                    error_setg(errp, "bad numerical value %s", val);
+                    return;

                 }
                 cpu_def->mmu_version = mmu_version;
 #ifdef DEBUG_FEATURES
                 }
                 cpu_def->mmu_version = mmu_version;
 #ifdef DEBUG_FEATURES


@@ -582,21 +618,21 @@ static int cpu_sparc_find_by_name(sparc_def_t *cpu_def, const char *cpu_model)
                 nwindows = strtol(val, &err, 0);
                 if (!*val || *err || nwindows > MAX_NWINDOWS ||
                     nwindows < MIN_NWINDOWS) {
                 nwindows = strtol(val, &err, 0);
                 if (!*val || *err || nwindows > MAX_NWINDOWS ||
                     nwindows < MIN_NWINDOWS) {

-                    fprintf(stderr, "bad numerical value %s\n", val);
-                    goto error;
+                    error_setg(errp, "bad numerical value %s", val);
+                    return;

                 }
                 cpu_def->nwindows = nwindows;
 #ifdef DEBUG_FEATURES
                 fprintf(stderr, "nwindows %d\n", nwindows);
 #endif
             } else {
                 }
                 cpu_def->nwindows = nwindows;
 #ifdef DEBUG_FEATURES
                 fprintf(stderr, "nwindows %d\n", nwindows);
 #endif
             } else {

-                fprintf(stderr, "unrecognized feature %s\n", featurestr);
-                goto error;
+                error_setg(errp, "unrecognized feature %s", featurestr);
+                return;

             }
         } else {
             }
         } else {

-            fprintf(stderr, "feature string `%s' not in format "
-                    "(+feature|-feature|feature=xyz)\n", featurestr);
-            goto error;
+            error_setg(errp, "feature string `%s' not in format "
+                             "(+feature|-feature|feature=xyz)", featurestr);
+            return;

         }
         featurestr = strtok(NULL, ",");
     }
         }
         featurestr = strtok(NULL, ",");
     }


@@ -605,12 +641,6 @@ static int cpu_sparc_find_by_name(sparc_def_t *cpu_def, const char *cpu_model)
 #ifdef DEBUG_FEATURES
     print_features(stderr, fprintf, cpu_def->features, NULL);
 #endif
 #ifdef DEBUG_FEATURES
     print_features(stderr, fprintf, cpu_def->features, NULL);
 #endif

-    g_free(s);
-    return 0;
-
- error:
-    g_free(s);
-    return -1;

 }
 
 void sparc_cpu_list(FILE *f, fprintf_function cpu_fprintf)
 }
 
 void sparc_cpu_list(FILE *f, fprintf_function cpu_fprintf)


@@ -739,9 +769,26 @@ static void sparc_cpu_synchronize_from_tb(CPUState *cs, TranslationBlock *tb)
     cpu->env.npc = tb->cs_base;
 }
 
     cpu->env.npc = tb->cs_base;
 }
 

+static bool sparc_cpu_has_work(CPUState *cs)
+{
+    SPARCCPU *cpu = SPARC_CPU(cs);
+    CPUSPARCState *env = &cpu->env;
+
+    return (cs->interrupt_request & CPU_INTERRUPT_HARD) &&
+           cpu_interrupts_enabled(env);
+}
+

 static void sparc_cpu_realizefn(DeviceState *dev, Error **errp)
 {
     SPARCCPUClass *scc = SPARC_CPU_GET_CLASS(dev);
 static void sparc_cpu_realizefn(DeviceState *dev, Error **errp)
 {
     SPARCCPUClass *scc = SPARC_CPU_GET_CLASS(dev);

+#if defined(CONFIG_USER_ONLY)
+    SPARCCPU *cpu = SPARC_CPU(dev);
+    CPUSPARCState *env = &cpu->env;
+
+    if ((env->def->features & CPU_FEATURE_FLOAT)) {
+        env->def->features |= CPU_FEATURE_FLOAT128;
+    }
+#endif

 
     qemu_init_vcpu(CPU(dev));
 
 
     qemu_init_vcpu(CPU(dev));
 


@@ -782,7 +829,10 @@ static void sparc_cpu_class_init(ObjectClass *oc, void *data)
     scc->parent_reset = cc->reset;
     cc->reset = sparc_cpu_reset;
 
     scc->parent_reset = cc->reset;
     cc->reset = sparc_cpu_reset;
 

+    cc->parse_features = sparc_cpu_parse_features;
+    cc->has_work = sparc_cpu_has_work;

     cc->do_interrupt = sparc_cpu_do_interrupt;
     cc->do_interrupt = sparc_cpu_do_interrupt;

+    cc->cpu_exec_interrupt = sparc_cpu_exec_interrupt;

     cc->dump_state = sparc_cpu_dump_state;
 #if !defined(TARGET_SPARC64) && !defined(CONFIG_USER_ONLY)
     cc->memory_rw_debug = sparc_cpu_memory_rw_debug;
     cc->dump_state = sparc_cpu_dump_state;
 #if !defined(TARGET_SPARC64) && !defined(CONFIG_USER_ONLY)
     cc->memory_rw_debug = sparc_cpu_memory_rw_debug;


@@ -791,8 +841,11 @@ static void sparc_cpu_class_init(ObjectClass *oc, void *data)
     cc->synchronize_from_tb = sparc_cpu_synchronize_from_tb;
     cc->gdb_read_register = sparc_cpu_gdb_read_register;
     cc->gdb_write_register = sparc_cpu_gdb_write_register;
     cc->synchronize_from_tb = sparc_cpu_synchronize_from_tb;
     cc->gdb_read_register = sparc_cpu_gdb_read_register;
     cc->gdb_write_register = sparc_cpu_gdb_write_register;

-#ifndef CONFIG_USER_ONLY
+#ifdef CONFIG_USER_ONLY
+    cc->handle_mmu_fault = sparc_cpu_handle_mmu_fault;
+#else

     cc->do_unassigned_access = sparc_cpu_unassigned_access;
     cc->do_unassigned_access = sparc_cpu_unassigned_access;

+    cc->do_unaligned_access = sparc_cpu_do_unaligned_access;

     cc->get_phys_page_debug = sparc_cpu_get_phys_page_debug;
 #endif
 
     cc->get_phys_page_debug = sparc_cpu_get_phys_page_debug;
 #endif