linux-user/sparc/cpu_loop.c

   1 /*
   2  *  qemu user cpu loop
   3  *
   4  *  Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "qemu/osdep.h"
  21 #include "qemu.h"
  22 #include "user-internals.h"
  23 #include "cpu_loop-common.h"
  24 #include "signal-common.h"
  25
  26 #define SPARC64_STACK_BIAS 2047
  27
  28 //#define DEBUG_WIN
  29
  30 /* WARNING: dealing with register windows _is_ complicated. More info
  31    can be found at http://www.sics.se/~psm/sparcstack.html */
  32 static inline int get_reg_index(CPUSPARCState *env, int cwp, int index)
  33 {
  34     index = (index + cwp * 16) % (16 * env->nwindows);
  35     /* wrap handling : if cwp is on the last window, then we use the
  36        registers 'after' the end */
  37     if (index < 8 && env->cwp == env->nwindows - 1)
  38         index += 16 * env->nwindows;
  39     return index;
  40 }
  41
  42 /* save the register window 'cwp1' */
  43 static inline void save_window_offset(CPUSPARCState *env, int cwp1)
  44 {
  45     unsigned int i;
  46     abi_ulong sp_ptr;
  47
  48     sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
  49 #ifdef TARGET_SPARC64
  50     if (sp_ptr & 3)
  51         sp_ptr += SPARC64_STACK_BIAS;
  52 #endif
  53 #if defined(DEBUG_WIN)
  54     printf("win_overflow: sp_ptr=0x" TARGET_ABI_FMT_lx " save_cwp=%d\n",
  55            sp_ptr, cwp1);
  56 #endif
  57     for(i = 0; i < 16; i++) {
  58         /* FIXME - what to do if put_user() fails? */
  59         put_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr);
  60         sp_ptr += sizeof(abi_ulong);
  61     }
  62 }
  63
  64 static void save_window(CPUSPARCState *env)
  65 {
  66 #ifndef TARGET_SPARC64
  67     unsigned int new_wim;
  68     new_wim = ((env->wim >> 1) | (env->wim << (env->nwindows - 1))) &
  69         ((1LL << env->nwindows) - 1);
  70     save_window_offset(env, cpu_cwp_dec(env, env->cwp - 2));
  71     env->wim = new_wim;
  72 #else
  73     /*
  74      * cansave is zero if the spill trap handler is triggered by `save` and
  75      * nonzero if triggered by a `flushw`
  76      */
  77     save_window_offset(env, cpu_cwp_dec(env, env->cwp - env->cansave - 2));
  78     env->cansave++;
  79     env->canrestore--;
  80 #endif
  81 }
  82
  83 static void restore_window(CPUSPARCState *env)
  84 {
  85 #ifndef TARGET_SPARC64
  86     unsigned int new_wim;
  87 #endif
  88     unsigned int i, cwp1;
  89     abi_ulong sp_ptr;
  90
  91 #ifndef TARGET_SPARC64
  92     new_wim = ((env->wim << 1) | (env->wim >> (env->nwindows - 1))) &
  93         ((1LL << env->nwindows) - 1);
  94 #endif
  95
  96     /* restore the invalid window */
  97     cwp1 = cpu_cwp_inc(env, env->cwp + 1);
  98     sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
  99 #ifdef TARGET_SPARC64
 100     if (sp_ptr & 3)
 101         sp_ptr += SPARC64_STACK_BIAS;
 102 #endif
 103 #if defined(DEBUG_WIN)
 104     printf("win_underflow: sp_ptr=0x" TARGET_ABI_FMT_lx " load_cwp=%d\n",
 105            sp_ptr, cwp1);
 106 #endif
 107     for(i = 0; i < 16; i++) {
 108         /* FIXME - what to do if get_user() fails? */
 109         get_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr);
 110         sp_ptr += sizeof(abi_ulong);
 111     }
 112 #ifdef TARGET_SPARC64
 113     env->canrestore++;
 114     if (env->cleanwin < env->nwindows - 1)
 115         env->cleanwin++;
 116     env->cansave--;
 117 #else
 118     env->wim = new_wim;
 119 #endif
 120 }
 121
 122 static void flush_windows(CPUSPARCState *env)
 123 {
 124     int offset, cwp1;
 125
 126     offset = 1;
 127     for(;;) {
 128         /* if restore would invoke restore_window(), then we can stop */
 129         cwp1 = cpu_cwp_inc(env, env->cwp + offset);
 130 #ifndef TARGET_SPARC64
 131         if (env->wim & (1 << cwp1))
 132             break;
 133 #else
 134         if (env->canrestore == 0)
 135             break;
 136         env->cansave++;
 137         env->canrestore--;
 138 #endif
 139         save_window_offset(env, cwp1);
 140         offset++;
 141     }
 142     cwp1 = cpu_cwp_inc(env, env->cwp + 1);
 143 #ifndef TARGET_SPARC64
 144     /* set wim so that restore will reload the registers */
 145     env->wim = 1 << cwp1;
 146 #endif
 147 #if defined(DEBUG_WIN)
 148     printf("flush_windows: nb=%d\n", offset - 1);
 149 #endif
 150 }
 151
 152 /* Avoid ifdefs below for the abi32 and abi64 paths. */
 153 #ifdef TARGET_ABI32
 154 #define TARGET_TT_SYSCALL  (TT_TRAP + 0x10) /* t_linux */
 155 #define syscall_cc         psr
 156 #else
 157 #define TARGET_TT_SYSCALL  (TT_TRAP + 0x6d) /* tl0_linux64 */
 158 #define syscall_cc         xcc
 159 #endif
 160
 161 /* Avoid ifdefs below for the v9 and pre-v9 hw traps. */
 162 #ifdef TARGET_SPARC64
 163 #define TARGET_TT_SPILL  TT_SPILL
 164 #define TARGET_TT_FILL   TT_FILL
 165 #else
 166 #define TARGET_TT_SPILL  TT_WIN_OVF
 167 #define TARGET_TT_FILL   TT_WIN_UNF
 168 #endif
 169
 170 void cpu_loop (CPUSPARCState *env)
 171 {
 172     CPUState *cs = env_cpu(env);
 173     int trapnr;
 174     abi_long ret;
 175
 176     while (1) {
 177         cpu_exec_start(cs);
 178         trapnr = cpu_exec(cs);
 179         cpu_exec_end(cs);
 180         process_queued_cpu_work(cs);
 181
 182         /* Compute PSR before exposing state.  */
 183         if (env->cc_op != CC_OP_FLAGS) {
 184             cpu_get_psr(env);
 185         }
 186
 187         switch (trapnr) {
 188         case TARGET_TT_SYSCALL:
 189             ret = do_syscall (env, env->gregs[1],
 190                               env->regwptr[0], env->regwptr[1],
 191                               env->regwptr[2], env->regwptr[3],
 192                               env->regwptr[4], env->regwptr[5],
 193                               0, 0);
 194             if (ret == -QEMU_ERESTARTSYS || ret == -QEMU_ESIGRETURN) {
 195                 break;
 196             }
 197             if ((abi_ulong)ret >= (abi_ulong)(-515)) {
 198                 env->syscall_cc |= PSR_CARRY;
 199                 ret = -ret;
 200             } else {
 201                 env->syscall_cc &= ~PSR_CARRY;
 202             }
 203             env->regwptr[0] = ret;
 204             /* next instruction */
 205             env->pc = env->npc;
 206             env->npc = env->npc + 4;
 207             break;
 208
 209         case TT_TRAP + 0x03: /* flush windows */
 210             flush_windows(env);
 211             /* next instruction */
 212             env->pc = env->npc;
 213             env->npc = env->npc + 4;
 214             break;
 215
 216         case TARGET_TT_SPILL: /* window overflow */
 217             save_window(env);
 218             break;
 219         case TARGET_TT_FILL:  /* window underflow */
 220             restore_window(env);
 221             break;
 222
 223 #ifdef TARGET_SPARC64
 224 #ifndef TARGET_ABI32
 225         case 0x16e:
 226             flush_windows(env);
 227             sparc64_get_context(env);
 228             break;
 229         case 0x16f:
 230             flush_windows(env);
 231             sparc64_set_context(env);
 232             break;
 233 #endif
 234 #endif
 235         case EXCP_INTERRUPT:
 236             /* just indicate that signals should be handled asap */
 237             break;
 238         case TT_ILL_INSN:
 239             force_sig_fault(TARGET_SIGILL, TARGET_ILL_ILLOPC, env->pc);
 240             break;
 241         case EXCP_DEBUG:
 242             force_sig_fault(TARGET_SIGTRAP, TARGET_TRAP_BRKPT, env->pc);
 243             break;
 244         case EXCP_ATOMIC:
 245             cpu_exec_step_atomic(cs);
 246             break;
 247         default:
 248             /*
 249              * Most software trap numbers vector to BAD_TRAP.
 250              * Handle anything not explicitly matched above.
 251              */
 252             if (trapnr >= TT_TRAP && trapnr <= TT_TRAP + 0x7f) {
 253                 force_sig_fault(TARGET_SIGILL, ILL_ILLTRP, env->pc);
 254                 break;
 255             }
 256             fprintf(stderr, "Unhandled trap: 0x%x\n", trapnr);
 257             cpu_dump_state(cs, stderr, 0);
 258             exit(EXIT_FAILURE);
 259         }
 260         process_pending_signals (env);
 261     }
 262 }
 263
 264 void target_cpu_copy_regs(CPUArchState *env, struct target_pt_regs *regs)
 265 {
 266     int i;
 267     env->pc = regs->pc;
 268     env->npc = regs->npc;
 269     env->y = regs->y;
 270     for(i = 0; i < 8; i++)
 271         env->gregs[i] = regs->u_regs[i];
 272     for(i = 0; i < 8; i++)
 273         env->regwptr[i] = regs->u_regs[i + 8];
 274 }