Rearrange PCI host emulation code.

[qemu] / monitor.c

diff --git a/monitor.c b/monitor.c
index 2f0e84d..d9257ff 100644 (file)
--- a/monitor.c
+++ b/monitor.c
@@ -259,6 +259,10 @@ static void do_info_cpus(void)
         term_printf(" nip=0x" TARGET_FMT_lx, env->nip);
         if (env->halted)
             term_printf(" (halted)");
+#elif defined(TARGET_SPARC)
+        term_printf(" pc=0x" TARGET_FMT_lx " npc=0x" TARGET_FMT_lx, env->pc, env->npc);
+        if (env->halted)
+            term_printf(" (halted)");
 #endif
         term_printf("\n");
     }
@@ -292,9 +296,6 @@ static void do_info_history (void)
 
 static void do_quit(void)
 {
-#ifdef USE_KQEMU
-    kqemu_record_dump();
-#endif
     exit(0);
 }
 
@@ -355,7 +356,7 @@ static void do_change(const char *device, const char *filename)
 
 static void do_screen_dump(const char *filename)
 {
-    vga_screen_dump(filename);
+    vga_hw_screen_dump(filename);
 }
 
 static void do_log(const char *items)
@@ -456,10 +457,18 @@ static void memory_dump(int count, int format, int wsize,
         } else if (wsize == 4) {
             flags = 0;
         } else {
-                /* as default we use the current CS size */
+            /* as default we use the current CS size */
             flags = 0;
-            if (env && !(env->segs[R_CS].flags & DESC_B_MASK))
-                flags = 1;
+            if (env) {
+#ifdef TARGET_X86_64
+                if ((env->efer & MSR_EFER_LMA) && 
+                    (env->segs[R_CS].flags & DESC_L_MASK))
+                    flags = 2;
+                else
+#endif
+                if (!(env->segs[R_CS].flags & DESC_B_MASK))
+                    flags = 1;
+            }
         }
 #endif
         monitor_disas(env, addr, count, is_physical, flags);
@@ -657,6 +666,8 @@ static const KeyDef key_defs[] = {
     { 0x09, "8" },
     { 0x0a, "9" },
     { 0x0b, "0" },
+    { 0x0c, "minus" },
+    { 0x0d, "equal" },
     { 0x0e, "backspace" },
 
     { 0x0f, "tab" },
@@ -706,6 +717,24 @@ static const KeyDef key_defs[] = {
     { 0x45, "num_lock" },
     { 0x46, "scroll_lock" },
 
+    { 0xb5, "kp_divide" },
+    { 0x37, "kp_multiply" },
+    { 0x4a, "kp_substract" },
+    { 0x4e, "kp_add" },
+    { 0x9c, "kp_enter" },
+    { 0x53, "kp_decimal" },
+
+    { 0x52, "kp_0" },
+    { 0x4f, "kp_1" },
+    { 0x50, "kp_2" },
+    { 0x51, "kp_3" },
+    { 0x4b, "kp_4" },
+    { 0x4c, "kp_5" },
+    { 0x4d, "kp_6" },
+    { 0x47, "kp_7" },
+    { 0x48, "kp_8" },
+    { 0x49, "kp_9" },
+    
     { 0x56, "<" },
 
     { 0x57, "f11" },
@@ -731,11 +760,18 @@ static const KeyDef key_defs[] = {
 static int get_keycode(const char *key)
 {
     const KeyDef *p;
+    char *endp;
+    int ret;
 
     for(p = key_defs; p->name != NULL; p++) {
         if (!strcmp(key, p->name))
             return p->keycode;
     }
+    if (strstart(key, "0x", NULL)) {
+        ret = strtoul(key, &endp, 0);
+        if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
+            return ret;
+    }
     return -1;
 }
 
@@ -956,12 +992,69 @@ static void do_info_kqemu(void)
         return;
     }
     val = env->kqemu_enabled;
-    term_printf("kqemu is %s\n", val ? "enabled" : "disabled");
+    term_printf("kqemu support: ");
+    switch(val) {
+    default:
+    case 0:
+        term_printf("disabled\n");
+        break;
+    case 1:
+        term_printf("enabled for user code\n");
+        break;
+    case 2:
+        term_printf("enabled for user and kernel code\n");
+        break;
+    }
 #else
-    term_printf("kqemu support is not compiled\n");
+    term_printf("kqemu support: not compiled\n");
 #endif
 } 
 
+#ifdef CONFIG_PROFILER
+
+int64_t kqemu_time;
+int64_t qemu_time;
+int64_t kqemu_exec_count;
+int64_t dev_time;
+int64_t kqemu_ret_int_count;
+int64_t kqemu_ret_excp_count;
+int64_t kqemu_ret_intr_count;
+
+static void do_info_profile(void)
+{
+    int64_t total;
+    total = qemu_time;
+    if (total == 0)
+        total = 1;
+    term_printf("async time  %lld (%0.3f)\n",
+                dev_time, dev_time / (double)ticks_per_sec);
+    term_printf("qemu time   %lld (%0.3f)\n",
+                qemu_time, qemu_time / (double)ticks_per_sec);
+    term_printf("kqemu time  %lld (%0.3f %0.1f%%) count=%lld int=%lld excp=%lld intr=%lld\n",
+                kqemu_time, kqemu_time / (double)ticks_per_sec,
+                kqemu_time / (double)total * 100.0,
+                kqemu_exec_count,
+                kqemu_ret_int_count,
+                kqemu_ret_excp_count,
+                kqemu_ret_intr_count);
+    qemu_time = 0;
+    kqemu_time = 0;
+    kqemu_exec_count = 0;
+    dev_time = 0;
+    kqemu_ret_int_count = 0;
+    kqemu_ret_excp_count = 0;
+    kqemu_ret_intr_count = 0;
+#ifdef USE_KQEMU
+    kqemu_record_dump();
+#endif
+}
+#else
+static void do_info_profile(void)
+{
+    term_printf("Internal profiler not compiled\n");
+}
+#endif
+
 static term_cmd_t term_cmds[] = {
     { "help|?", "s?", do_help, 
       "[cmd]", "show the help" },
@@ -1050,6 +1143,8 @@ static term_cmd_t info_cmds[] = {
       "", "show guest USB devices", },
     { "usbhost", "", usb_host_info,
       "", "show host USB devices", },
+    { "profile", "", do_info_profile,
+      "", "show profiling information", },
     { NULL, NULL, },
 };
 
@@ -1489,6 +1584,7 @@ static target_long expr_unary(void)
         n = 0;
         break;
     default:
+        /* XXX: 64 bit version */
         n = strtoul(pch, &p, 0);
         if (pch == p) {
             expr_error("invalid char in expression");
@@ -2083,6 +2179,7 @@ void readline_find_completion(const char *cmdline)
     int nb_args, i, len;
     const char *ptype, *str;
     term_cmd_t *cmd;
+    const KeyDef *key;
 
     parse_cmdline(cmdline, &nb_args, args);
 #ifdef DEBUG_COMPLETION
@@ -2144,6 +2241,11 @@ void readline_find_completion(const char *cmdline)
                 for(cmd = info_cmds; cmd->name != NULL; cmd++) {
                     cmd_completion(str, cmd->name);
                 }
+            } else if (!strcmp(cmd->name, "sendkey")) {
+                completion_index = strlen(str);
+                for(key = key_defs; key->name != NULL; key++) {
+                    cmd_completion(str, key->name);
+                }
             }
             break;
         default: