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 void cpu_loop (CPUSPARCState *env)
 162 {
 163     CPUState *cs = env_cpu(env);
 164     int trapnr;
 165     abi_long ret;
 166
 167     while (1) {
 168         cpu_exec_start(cs);
 169         trapnr = cpu_exec(cs);
 170         cpu_exec_end(cs);
 171         process_queued_cpu_work(cs);
 172
 173         /* Compute PSR before exposing state.  */
 174         if (env->cc_op != CC_OP_FLAGS) {
 175             cpu_get_psr(env);
 176         }
 177
 178         switch (trapnr) {
 179         case TARGET_TT_SYSCALL:
 180             ret = do_syscall (env, env->gregs[1],
 181                               env->regwptr[0], env->regwptr[1],
 182                               env->regwptr[2], env->regwptr[3],
 183                               env->regwptr[4], env->regwptr[5],
 184                               0, 0);
 185             if (ret == -QEMU_ERESTARTSYS || ret == -QEMU_ESIGRETURN) {
 186                 break;
 187             }
 188             if ((abi_ulong)ret >= (abi_ulong)(-515)) {
 189                 env->syscall_cc |= PSR_CARRY;
 190                 ret = -ret;
 191             } else {
 192                 env->syscall_cc &= ~PSR_CARRY;
 193             }
 194             env->regwptr[0] = ret;
 195             /* next instruction */
 196             env->pc = env->npc;
 197             env->npc = env->npc + 4;
 198             break;
 199         case 0x83: /* flush windows */
 200 #ifdef TARGET_ABI32
 201         case 0x103:
 202 #endif
 203             flush_windows(env);
 204             /* next instruction */
 205             env->pc = env->npc;
 206             env->npc = env->npc + 4;
 207             break;
 208 #ifndef TARGET_SPARC64
 209         case TT_WIN_OVF: /* window overflow */
 210             save_window(env);
 211             break;
 212         case TT_WIN_UNF: /* window underflow */
 213             restore_window(env);
 214             break;
 215 #else
 216         case TT_SPILL: /* window overflow */
 217             save_window(env);
 218             break;
 219         case TT_FILL: /* window underflow */
 220             restore_window(env);
 221             break;
 222 #ifndef TARGET_ABI32
 223         case 0x16e:
 224             flush_windows(env);
 225             sparc64_get_context(env);
 226             break;
 227         case 0x16f:
 228             flush_windows(env);
 229             sparc64_set_context(env);
 230             break;
 231 #endif
 232 #endif
 233         case EXCP_INTERRUPT:
 234             /* just indicate that signals should be handled asap */
 235             break;
 236         case TT_ILL_INSN:
 237             force_sig_fault(TARGET_SIGILL, TARGET_ILL_ILLOPC, env->pc);
 238             break;
 239         case EXCP_DEBUG:
 240             force_sig_fault(TARGET_SIGTRAP, TARGET_TRAP_BRKPT, env->pc);
 241             break;
 242         case EXCP_ATOMIC:
 243             cpu_exec_step_atomic(cs);
 244             break;
 245         default:
 246             /*
 247              * Most software trap numbers vector to BAD_TRAP.
 248              * Handle anything not explicitly matched above.
 249              */
 250             if (trapnr >= TT_TRAP && trapnr <= TT_TRAP + 0x7f) {
 251                 force_sig_fault(TARGET_SIGILL, ILL_ILLTRP, env->pc);
 252                 break;
 253             }
 254             fprintf(stderr, "Unhandled trap: 0x%x\n", trapnr);
 255             cpu_dump_state(cs, stderr, 0);
 256             exit(EXIT_FAILURE);
 257         }
 258         process_pending_signals (env);
 259     }
 260 }
 261
 262 void target_cpu_copy_regs(CPUArchState *env, struct target_pt_regs *regs)
 263 {
 264     int i;
 265     env->pc = regs->pc;
 266     env->npc = regs->npc;
 267     env->y = regs->y;
 268     for(i = 0; i < 8; i++)
 269         env->gregs[i] = regs->u_regs[i];
 270     for(i = 0; i < 8; i++)
 271         env->regwptr[i] = regs->u_regs[i + 8];
 272 }