/ - Diff - qemu - Greek Research and Technology Network's projects

     static const char *get_elf_platform(void)
+    {
         static char elf_platform[] = "i386";
         int family = (thread_env->cpuid_version >> 8) & 0xff;
         int family = object_property_get_int(OBJECT(thread_cpu), "family", NULL);
         if (family > 6)
             family = 6;
         if (family >= 3)
-...
     static uint32_t get_elf_hwcap(void)
+    {
         return thread_env->features[FEAT_1_EDX];
         X86CPU *cpu = X86_CPU(thread_cpu);
         return cpu->env.features[FEAT_1_EDX];
+    }
     #ifdef TARGET_X86_64
-...
     static uint32_t get_elf_hwcap(void)
+    {
         CPUARMState *e = thread_env;
         ARMCPU *cpu = ARM_CPU(thread_cpu);
         uint32_t hwcaps = 0;
         hwcaps |= ARM_HWCAP_ARM_SWP;
-...
         /* probe for the extra features */
     #define GET_FEATURE(feat, hwcap) \
         do {if (arm_feature(e, feat)) { hwcaps |= hwcap; } } while (0)
         do { if (arm_feature(&cpu->env, feat)) { hwcaps |= hwcap; } } while (0)
         GET_FEATURE(ARM_FEATURE_VFP, ARM_HWCAP_ARM_VFP);
         GET_FEATURE(ARM_FEATURE_IWMMXT, ARM_HWCAP_ARM_IWMMXT);
         GET_FEATURE(ARM_FEATURE_THUMB2EE, ARM_HWCAP_ARM_THUMBEE);
-...
     static uint32_t get_elf_hwcap(void)
+    {
         CPUPPCState *e = thread_env;
         PowerPCCPU *cpu = POWERPC_CPU(thread_cpu);
         uint32_t features = 0;
         /* We don't have to be terribly complete here; the high points are
            Altivec/FP/SPE support.  Anything else is just a bonus.  */
     #define GET_FEATURE(flag, feature)                                      \
         do {if (e->insns_flags & flag) features |= feature; } while(0)
         do { if (cpu->env.insns_flags & flag) { features |= feature; } } while (0)
         GET_FEATURE(PPC_64B, QEMU_PPC_FEATURE_64);
         GET_FEATURE(PPC_FLOAT, QEMU_PPC_FEATURE_HAS_FPU);
         GET_FEATURE(PPC_ALTIVEC, QEMU_PPC_FEATURE_HAS_ALTIVEC);
-...
         /* read and fill status of all threads */
         cpu_list_lock();
         for (cpu = first_cpu; cpu != NULL; cpu = cpu->next_cpu) {
             if (cpu == ENV_GET_CPU(thread_env)) {
             if (cpu == thread_cpu) {
                 continue;
+            }
             fill_thread_info(info, (CPUArchState *)cpu->env_ptr);

     abi_ulong loader_build_argptr(int envc, int argc, abi_ulong sp,
                                   abi_ulong stringp, int push_ptr)
+    {
         TaskState *ts = (TaskState *)thread_env->opaque;
         CPUArchState *env = thread_cpu->env_ptr;
         TaskState *ts = (TaskState *)env->opaque;
         int n = sizeof(abi_ulong);
         abi_ulong envp;
         abi_ulong argv;

         if (child) {
             /* Child processes created by fork() only have a single thread.
                Discard information about the parent threads.  */
             first_cpu = ENV_GET_CPU(thread_env);
             first_cpu = thread_cpu;
             first_cpu->next_cpu = NULL;
             pending_cpus = 0;
             pthread_mutex_init(&exclusive_lock, NULL);
-...
             pthread_cond_init(&exclusive_cond, NULL);
             pthread_cond_init(&exclusive_resume, NULL);
             pthread_mutex_init(&tcg_ctx.tb_ctx.tb_lock, NULL);
             gdbserver_fork(thread_env);
             gdbserver_fork((CPUArchState *)thread_cpu->env_ptr);
         } else {
             pthread_mutex_unlock(&exclusive_lock);
             pthread_mutex_unlock(&tcg_ctx.tb_ctx.tb_lock);
-...
     void fork_end(int child)
+    {
         if (child) {
             gdbserver_fork(thread_env);
             gdbserver_fork((CPUArchState *)thread_cpu->env_ptr);
+        }
+    }
-...
     #endif /* TARGET_S390X */
     THREAD CPUArchState *thread_env;
     THREAD CPUState *thread_cpu;
     void task_settid(TaskState *ts)
+    {
-...
         cpu_reset(ENV_GET_CPU(env));
     #endif
         thread_env = env;
         thread_cpu = ENV_GET_CPU(env);
         if (getenv("QEMU_STRACE")) {
             do_strace = 1;

                         abi_long arg5, abi_long arg6, abi_long arg7,
                         abi_long arg8);
     void gemu_log(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
     extern THREAD CPUArchState *thread_env;
     extern THREAD CPUState *thread_cpu;
     void cpu_loop(CPUArchState *env);
     char *target_strerror(int err);
     int get_osversion(void);

     /* abort execution with signal */
     static void QEMU_NORETURN force_sig(int target_sig)
+    {
         TaskState *ts = (TaskState *)thread_env->opaque;
         CPUArchState *env = thread_cpu->env_ptr;
         TaskState *ts = (TaskState *)env->opaque;
         int host_sig, core_dumped = 0;
         struct sigaction act;
         host_sig = target_to_host_signal(target_sig);
         gdb_signalled(thread_env, target_sig);
         gdb_signalled(env, target_sig);
         /* dump core if supported by target binary format */
         if (core_dump_signal(target_sig) && (ts->bprm->core_dump != NULL)) {
             stop_all_tasks();
             core_dumped =
                 ((*ts->bprm->core_dump)(target_sig, thread_env) == 0);
                 ((*ts->bprm->core_dump)(target_sig, env) == 0);
+        }
         if (core_dumped) {
             /* we already dumped the core of target process, we don't want
-...
     static void host_signal_handler(int host_signum, siginfo_t *info,
                                     void *puc)
+    {
         CPUArchState *env = thread_cpu->env_ptr;
         int sig;
         target_siginfo_t tinfo;
-...
         fprintf(stderr, "qemu: got signal %d\n", sig);
     #endif
         host_to_target_siginfo_noswap(&tinfo, info);
         if (queue_signal(thread_env, sig, &tinfo) == 1) {
         if (queue_signal(env, sig, &tinfo) == 1) {
             /* interrupt the virtual CPU as soon as possible */
             cpu_exit(ENV_GET_CPU(thread_env));
             cpu_exit(thread_cpu);
+        }
+    }

         env = info->env;
         cpu = ENV_GET_CPU(env);
         thread_env = env;
         ts = (TaskState *)thread_env->opaque;
         thread_cpu = cpu;
         ts = (TaskState *)env->opaque;
         info->tid = gettid();
         cpu->host_tid = info->tid;
         task_settid(ts);
-...
                     sys_futex(g2h(ts->child_tidptr), FUTEX_WAKE, INT_MAX,
                               NULL, NULL, 0);
+                }
                 thread_env = NULL;
                 thread_cpu = NULL;
                 object_unref(OBJECT(ENV_GET_CPU(cpu_env)));
                 g_free(ts);
                 pthread_exit(NULL);

Archipelago » qemu

Revision a2247f8e