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