target/sparc/helper.c

   1 /*
   2  *  Misc Sparc helpers
   3  *
   4  *  Copyright (c) 2003-2005 Fabrice Bellard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library 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 GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "qemu/osdep.h"
  21 #include "cpu.h"
  22 #include "exec/exec-all.h"
  23 #include "qemu/timer.h"
  24 #include "qemu/host-utils.h"
  25 #include "exec/helper-proto.h"
  26
  27 void cpu_raise_exception_ra(CPUSPARCState *env, int tt, uintptr_t ra)
  28 {
  29     CPUState *cs = env_cpu(env);
  30
  31     cs->exception_index = tt;
  32     cpu_loop_exit_restore(cs, ra);
  33 }
  34
  35 void helper_raise_exception(CPUSPARCState *env, int tt)
  36 {
  37     CPUState *cs = env_cpu(env);
  38
  39     cs->exception_index = tt;
  40     cpu_loop_exit(cs);
  41 }
  42
  43 void helper_debug(CPUSPARCState *env)
  44 {
  45     CPUState *cs = env_cpu(env);
  46
  47     cs->exception_index = EXCP_DEBUG;
  48     cpu_loop_exit(cs);
  49 }
  50
  51 #ifdef TARGET_SPARC64
  52 void helper_tick_set_count(void *opaque, uint64_t count)
  53 {
  54 #if !defined(CONFIG_USER_ONLY)
  55     cpu_tick_set_count(opaque, count);
  56 #endif
  57 }
  58
  59 uint64_t helper_tick_get_count(CPUSPARCState *env, void *opaque, int mem_idx)
  60 {
  61 #if !defined(CONFIG_USER_ONLY)
  62     CPUTimer *timer = opaque;
  63
  64     if (timer->npt && mem_idx < MMU_KERNEL_IDX) {
  65         cpu_raise_exception_ra(env, TT_PRIV_INSN, GETPC());
  66     }
  67
  68     return cpu_tick_get_count(timer);
  69 #else
  70     /* In user-mode, QEMU_CLOCK_VIRTUAL doesn't exist.
  71        Just pass through the host cpu clock ticks.  */
  72     return cpu_get_host_ticks();
  73 #endif
  74 }
  75
  76 void helper_tick_set_limit(void *opaque, uint64_t limit)
  77 {
  78 #if !defined(CONFIG_USER_ONLY)
  79     cpu_tick_set_limit(opaque, limit);
  80 #endif
  81 }
  82 #endif
  83
  84 static target_ulong do_udiv(CPUSPARCState *env, target_ulong a,
  85                             target_ulong b, int cc, uintptr_t ra)
  86 {
  87     int overflow = 0;
  88     uint64_t x0;
  89     uint32_t x1;
  90
  91     x0 = (a & 0xffffffff) | ((int64_t) (env->y) << 32);
  92     x1 = (b & 0xffffffff);
  93
  94     if (x1 == 0) {
  95         cpu_raise_exception_ra(env, TT_DIV_ZERO, ra);
  96     }
  97
  98     x0 = x0 / x1;
  99     if (x0 > UINT32_MAX) {
 100         x0 = UINT32_MAX;
 101         overflow = 1;
 102     }
 103
 104     if (cc) {
 105         env->cc_src2 = overflow;
 106     }
 107     return x0;
 108 }
 109
 110 target_ulong helper_udiv(CPUSPARCState *env, target_ulong a, target_ulong b)
 111 {
 112     return do_udiv(env, a, b, 0, GETPC());
 113 }
 114
 115 target_ulong helper_udiv_cc(CPUSPARCState *env, target_ulong a, target_ulong b)
 116 {
 117     return do_udiv(env, a, b, 1, GETPC());
 118 }
 119
 120 static target_ulong do_sdiv(CPUSPARCState *env, target_ulong a,
 121                             target_ulong b, int cc, uintptr_t ra)
 122 {
 123     int overflow = 0;
 124     int64_t x0;
 125     int32_t x1;
 126
 127     x0 = (a & 0xffffffff) | ((int64_t) (env->y) << 32);
 128     x1 = (b & 0xffffffff);
 129
 130     if (x1 == 0) {
 131         cpu_raise_exception_ra(env, TT_DIV_ZERO, ra);
 132     } else if (x1 == -1 && x0 == INT64_MIN) {
 133         x0 = INT32_MAX;
 134         overflow = 1;
 135     } else {
 136         x0 = x0 / x1;
 137         if ((int32_t) x0 != x0) {
 138             x0 = x0 < 0 ? INT32_MIN : INT32_MAX;
 139             overflow = 1;
 140         }
 141     }
 142
 143     if (cc) {
 144         env->cc_src2 = overflow;
 145     }
 146     return x0;
 147 }
 148
 149 target_ulong helper_sdiv(CPUSPARCState *env, target_ulong a, target_ulong b)
 150 {
 151     return do_sdiv(env, a, b, 0, GETPC());
 152 }
 153
 154 target_ulong helper_sdiv_cc(CPUSPARCState *env, target_ulong a, target_ulong b)
 155 {
 156     return do_sdiv(env, a, b, 1, GETPC());
 157 }
 158
 159 #ifdef TARGET_SPARC64
 160 int64_t helper_sdivx(CPUSPARCState *env, int64_t a, int64_t b)
 161 {
 162     if (b == 0) {
 163         /* Raise divide by zero trap.  */
 164         cpu_raise_exception_ra(env, TT_DIV_ZERO, GETPC());
 165     } else if (b == -1) {
 166         /* Avoid overflow trap with i386 divide insn.  */
 167         return -a;
 168     } else {
 169         return a / b;
 170     }
 171 }
 172
 173 uint64_t helper_udivx(CPUSPARCState *env, uint64_t a, uint64_t b)
 174 {
 175     if (b == 0) {
 176         /* Raise divide by zero trap.  */
 177         cpu_raise_exception_ra(env, TT_DIV_ZERO, GETPC());
 178     }
 179     return a / b;
 180 }
 181 #endif
 182
 183 target_ulong helper_taddcctv(CPUSPARCState *env, target_ulong src1,
 184                              target_ulong src2)
 185 {
 186     target_ulong dst;
 187
 188     /* Tag overflow occurs if either input has bits 0 or 1 set.  */
 189     if ((src1 | src2) & 3) {
 190         goto tag_overflow;
 191     }
 192
 193     dst = src1 + src2;
 194
 195     /* Tag overflow occurs if the addition overflows.  */
 196     if (~(src1 ^ src2) & (src1 ^ dst) & (1u << 31)) {
 197         goto tag_overflow;
 198     }
 199
 200     /* Only modify the CC after any exceptions have been generated.  */
 201     env->cc_src = src1;
 202     env->cc_src2 = src2;
 203     return dst;
 204
 205  tag_overflow:
 206     cpu_raise_exception_ra(env, TT_TOVF, GETPC());
 207 }
 208
 209 target_ulong helper_tsubcctv(CPUSPARCState *env, target_ulong src1,
 210                              target_ulong src2)
 211 {
 212     target_ulong dst;
 213
 214     /* Tag overflow occurs if either input has bits 0 or 1 set.  */
 215     if ((src1 | src2) & 3) {
 216         goto tag_overflow;
 217     }
 218
 219     dst = src1 - src2;
 220
 221     /* Tag overflow occurs if the subtraction overflows.  */
 222     if ((src1 ^ src2) & (src1 ^ dst) & (1u << 31)) {
 223         goto tag_overflow;
 224     }
 225
 226     /* Only modify the CC after any exceptions have been generated.  */
 227     env->cc_src = src1;
 228     env->cc_src2 = src2;
 229     return dst;
 230
 231  tag_overflow:
 232     cpu_raise_exception_ra(env, TT_TOVF, GETPC());
 233 }
 234
 235 #ifndef TARGET_SPARC64
 236 void helper_power_down(CPUSPARCState *env)
 237 {
 238     CPUState *cs = env_cpu(env);
 239
 240     cs->halted = 1;
 241     cs->exception_index = EXCP_HLT;
 242     env->pc = env->npc;
 243     env->npc = env->pc + 4;
 244     cpu_loop_exit(cs);
 245 }
 246 #endif