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