target-unicore32/op_helper.c

   1 /*
   2  *  UniCore32 helper routines
   3  *
   4  * Copyright (C) 2010-2012 Guan Xuetao
   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 version 2 as
   8  * published by the Free Software Foundation, or (at your option) any
   9  * later version. See the COPYING file in the top-level directory.
  10  */
  11 #include "qemu/osdep.h"
  12 #include "cpu.h"
  13 #include "exec/helper-proto.h"
  14 #include "exec/exec-all.h"
  15 #include "exec/cpu_ldst.h"
  16
  17 #define SIGNBIT (uint32_t)0x80000000
  18 #define SIGNBIT64 ((uint64_t)1 << 63)
  19
  20 void HELPER(exception)(CPUUniCore32State *env, uint32_t excp)
  21 {
  22     CPUState *cs = CPU(uc32_env_get_cpu(env));
  23
  24     cs->exception_index = excp;
  25     cpu_loop_exit(cs);
  26 }
  27
  28 static target_ulong asr_read(CPUUniCore32State *env)
  29 {
  30     int ZF;
  31     ZF = (env->ZF == 0);
  32     return env->uncached_asr | (env->NF & 0x80000000) | (ZF << 30) |
  33         (env->CF << 29) | ((env->VF & 0x80000000) >> 3);
  34 }
  35
  36 target_ulong cpu_asr_read(CPUUniCore32State *env)
  37 {
  38     return asr_read(env);
  39 }
  40
  41 target_ulong HELPER(asr_read)(CPUUniCore32State *env)
  42 {
  43     return asr_read(env);
  44 }
  45
  46 static void asr_write(CPUUniCore32State *env, target_ulong val,
  47                       target_ulong mask)
  48 {
  49     if (mask & ASR_NZCV) {
  50         env->ZF = (~val) & ASR_Z;
  51         env->NF = val;
  52         env->CF = (val >> 29) & 1;
  53         env->VF = (val << 3) & 0x80000000;
  54     }
  55
  56     if ((env->uncached_asr ^ val) & mask & ASR_M) {
  57         switch_mode(env, val & ASR_M);
  58     }
  59     mask &= ~ASR_NZCV;
  60     env->uncached_asr = (env->uncached_asr & ~mask) | (val & mask);
  61 }
  62
  63 void cpu_asr_write(CPUUniCore32State *env, target_ulong val, target_ulong mask)
  64 {
  65     asr_write(env, val, mask);
  66 }
  67
  68 void HELPER(asr_write)(CPUUniCore32State *env, target_ulong val,
  69                        target_ulong mask)
  70 {
  71     asr_write(env, val, mask);
  72 }
  73
  74 /* Access to user mode registers from privileged modes.  */
  75 uint32_t HELPER(get_user_reg)(CPUUniCore32State *env, uint32_t regno)
  76 {
  77     uint32_t val;
  78
  79     if (regno == 29) {
  80         val = env->banked_r29[0];
  81     } else if (regno == 30) {
  82         val = env->banked_r30[0];
  83     } else {
  84         val = env->regs[regno];
  85     }
  86     return val;
  87 }
  88
  89 void HELPER(set_user_reg)(CPUUniCore32State *env, uint32_t regno, uint32_t val)
  90 {
  91     if (regno == 29) {
  92         env->banked_r29[0] = val;
  93     } else if (regno == 30) {
  94         env->banked_r30[0] = val;
  95     } else {
  96         env->regs[regno] = val;
  97     }
  98 }
  99
 100 /* ??? Flag setting arithmetic is awkward because we need to do comparisons.
 101    The only way to do that in TCG is a conditional branch, which clobbers
 102    all our temporaries.  For now implement these as helper functions.  */
 103
 104 uint32_t HELPER(add_cc)(CPUUniCore32State *env, uint32_t a, uint32_t b)
 105 {
 106     uint32_t result;
 107     result = a + b;
 108     env->NF = env->ZF = result;
 109     env->CF = result < a;
 110     env->VF = (a ^ b ^ -1) & (a ^ result);
 111     return result;
 112 }
 113
 114 uint32_t HELPER(adc_cc)(CPUUniCore32State *env, uint32_t a, uint32_t b)
 115 {
 116     uint32_t result;
 117     if (!env->CF) {
 118         result = a + b;
 119         env->CF = result < a;
 120     } else {
 121         result = a + b + 1;
 122         env->CF = result <= a;
 123     }
 124     env->VF = (a ^ b ^ -1) & (a ^ result);
 125     env->NF = env->ZF = result;
 126     return result;
 127 }
 128
 129 uint32_t HELPER(sub_cc)(CPUUniCore32State *env, uint32_t a, uint32_t b)
 130 {
 131     uint32_t result;
 132     result = a - b;
 133     env->NF = env->ZF = result;
 134     env->CF = a >= b;
 135     env->VF = (a ^ b) & (a ^ result);
 136     return result;
 137 }
 138
 139 uint32_t HELPER(sbc_cc)(CPUUniCore32State *env, uint32_t a, uint32_t b)
 140 {
 141     uint32_t result;
 142     if (!env->CF) {
 143         result = a - b - 1;
 144         env->CF = a > b;
 145     } else {
 146         result = a - b;
 147         env->CF = a >= b;
 148     }
 149     env->VF = (a ^ b) & (a ^ result);
 150     env->NF = env->ZF = result;
 151     return result;
 152 }
 153
 154 /* Similarly for variable shift instructions.  */
 155
 156 uint32_t HELPER(shl)(uint32_t x, uint32_t i)
 157 {
 158     int shift = i & 0xff;
 159     if (shift >= 32) {
 160         return 0;
 161     }
 162     return x << shift;
 163 }
 164
 165 uint32_t HELPER(shr)(uint32_t x, uint32_t i)
 166 {
 167     int shift = i & 0xff;
 168     if (shift >= 32) {
 169         return 0;
 170     }
 171     return (uint32_t)x >> shift;
 172 }
 173
 174 uint32_t HELPER(sar)(uint32_t x, uint32_t i)
 175 {
 176     int shift = i & 0xff;
 177     if (shift >= 32) {
 178         shift = 31;
 179     }
 180     return (int32_t)x >> shift;
 181 }
 182
 183 uint32_t HELPER(shl_cc)(CPUUniCore32State *env, uint32_t x, uint32_t i)
 184 {
 185     int shift = i & 0xff;
 186     if (shift >= 32) {
 187         if (shift == 32) {
 188             env->CF = x & 1;
 189         } else {
 190             env->CF = 0;
 191         }
 192         return 0;
 193     } else if (shift != 0) {
 194         env->CF = (x >> (32 - shift)) & 1;
 195         return x << shift;
 196     }
 197     return x;
 198 }
 199
 200 uint32_t HELPER(shr_cc)(CPUUniCore32State *env, uint32_t x, uint32_t i)
 201 {
 202     int shift = i & 0xff;
 203     if (shift >= 32) {
 204         if (shift == 32) {
 205             env->CF = (x >> 31) & 1;
 206         } else {
 207             env->CF = 0;
 208         }
 209         return 0;
 210     } else if (shift != 0) {
 211         env->CF = (x >> (shift - 1)) & 1;
 212         return x >> shift;
 213     }
 214     return x;
 215 }
 216
 217 uint32_t HELPER(sar_cc)(CPUUniCore32State *env, uint32_t x, uint32_t i)
 218 {
 219     int shift = i & 0xff;
 220     if (shift >= 32) {
 221         env->CF = (x >> 31) & 1;
 222         return (int32_t)x >> 31;
 223     } else if (shift != 0) {
 224         env->CF = (x >> (shift - 1)) & 1;
 225         return (int32_t)x >> shift;
 226     }
 227     return x;
 228 }
 229
 230 uint32_t HELPER(ror_cc)(CPUUniCore32State *env, uint32_t x, uint32_t i)
 231 {
 232     int shift1, shift;
 233     shift1 = i & 0xff;
 234     shift = shift1 & 0x1f;
 235     if (shift == 0) {
 236         if (shift1 != 0) {
 237             env->CF = (x >> 31) & 1;
 238         }
 239         return x;
 240     } else {
 241         env->CF = (x >> (shift - 1)) & 1;
 242         return ((uint32_t)x >> shift) | (x << (32 - shift));
 243     }
 244 }
 245
 246 #ifndef CONFIG_USER_ONLY
 247 void tlb_fill(CPUState *cs, target_ulong addr, MMUAccessType access_type,
 248               int mmu_idx, uintptr_t retaddr)
 249 {
 250     int ret;
 251
 252     ret = uc32_cpu_handle_mmu_fault(cs, addr, access_type, mmu_idx);
 253     if (unlikely(ret)) {
 254         if (retaddr) {
 255             /* now we have a real cpu fault */
 256             cpu_restore_state(cs, retaddr);
 257         }
 258         cpu_loop_exit(cs);
 259     }
 260 }
 261 #endif