← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to target-unicore32/op_helper.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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