scsi: esp: check buffer length before reading scsi command
[qemu.git] / target-alpha / vax_helper.c
1 /*
2 * Helpers for vax floating point instructions.
3 *
4 * Copyright (c) 2007 Jocelyn Mayer
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 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 "exec/helper-proto.h"
24 #include "fpu/softfloat.h"
25
26 #define FP_STATUS (env->fp_status)
27
28
29 /* F floating (VAX) */
30 static uint64_t float32_to_f(float32 fa)
31 {
32 uint64_t r, exp, mant, sig;
33 CPU_FloatU a;
34
35 a.f = fa;
36 sig = ((uint64_t)a.l & 0x80000000) << 32;
37 exp = (a.l >> 23) & 0xff;
38 mant = ((uint64_t)a.l & 0x007fffff) << 29;
39
40 if (exp == 255) {
41 /* NaN or infinity */
42 r = 1; /* VAX dirty zero */
43 } else if (exp == 0) {
44 if (mant == 0) {
45 /* Zero */
46 r = 0;
47 } else {
48 /* Denormalized */
49 r = sig | ((exp + 1) << 52) | mant;
50 }
51 } else {
52 if (exp >= 253) {
53 /* Overflow */
54 r = 1; /* VAX dirty zero */
55 } else {
56 r = sig | ((exp + 2) << 52);
57 }
58 }
59
60 return r;
61 }
62
63 static float32 f_to_float32(CPUAlphaState *env, uintptr_t retaddr, uint64_t a)
64 {
65 uint32_t exp, mant_sig;
66 CPU_FloatU r;
67
68 exp = ((a >> 55) & 0x80) | ((a >> 52) & 0x7f);
69 mant_sig = ((a >> 32) & 0x80000000) | ((a >> 29) & 0x007fffff);
70
71 if (unlikely(!exp && mant_sig)) {
72 /* Reserved operands / Dirty zero */
73 dynamic_excp(env, retaddr, EXCP_OPCDEC, 0);
74 }
75
76 if (exp < 3) {
77 /* Underflow */
78 r.l = 0;
79 } else {
80 r.l = ((exp - 2) << 23) | mant_sig;
81 }
82
83 return r.f;
84 }
85
86 uint32_t helper_f_to_memory(uint64_t a)
87 {
88 uint32_t r;
89 r = (a & 0x00001fffe0000000ull) >> 13;
90 r |= (a & 0x07ffe00000000000ull) >> 45;
91 r |= (a & 0xc000000000000000ull) >> 48;
92 return r;
93 }
94
95 uint64_t helper_memory_to_f(uint32_t a)
96 {
97 uint64_t r;
98 r = ((uint64_t)(a & 0x0000c000)) << 48;
99 r |= ((uint64_t)(a & 0x003fffff)) << 45;
100 r |= ((uint64_t)(a & 0xffff0000)) << 13;
101 if (!(a & 0x00004000)) {
102 r |= 0x7ll << 59;
103 }
104 return r;
105 }
106
107 /* ??? Emulating VAX arithmetic with IEEE arithmetic is wrong. We should
108 either implement VAX arithmetic properly or just signal invalid opcode. */
109
110 uint64_t helper_addf(CPUAlphaState *env, uint64_t a, uint64_t b)
111 {
112 float32 fa, fb, fr;
113
114 fa = f_to_float32(env, GETPC(), a);
115 fb = f_to_float32(env, GETPC(), b);
116 fr = float32_add(fa, fb, &FP_STATUS);
117 return float32_to_f(fr);
118 }
119
120 uint64_t helper_subf(CPUAlphaState *env, uint64_t a, uint64_t b)
121 {
122 float32 fa, fb, fr;
123
124 fa = f_to_float32(env, GETPC(), a);
125 fb = f_to_float32(env, GETPC(), b);
126 fr = float32_sub(fa, fb, &FP_STATUS);
127 return float32_to_f(fr);
128 }
129
130 uint64_t helper_mulf(CPUAlphaState *env, uint64_t a, uint64_t b)
131 {
132 float32 fa, fb, fr;
133
134 fa = f_to_float32(env, GETPC(), a);
135 fb = f_to_float32(env, GETPC(), b);
136 fr = float32_mul(fa, fb, &FP_STATUS);
137 return float32_to_f(fr);
138 }
139
140 uint64_t helper_divf(CPUAlphaState *env, uint64_t a, uint64_t b)
141 {
142 float32 fa, fb, fr;
143
144 fa = f_to_float32(env, GETPC(), a);
145 fb = f_to_float32(env, GETPC(), b);
146 fr = float32_div(fa, fb, &FP_STATUS);
147 return float32_to_f(fr);
148 }
149
150 uint64_t helper_sqrtf(CPUAlphaState *env, uint64_t t)
151 {
152 float32 ft, fr;
153
154 ft = f_to_float32(env, GETPC(), t);
155 fr = float32_sqrt(ft, &FP_STATUS);
156 return float32_to_f(fr);
157 }
158
159
160 /* G floating (VAX) */
161 static uint64_t float64_to_g(float64 fa)
162 {
163 uint64_t r, exp, mant, sig;
164 CPU_DoubleU a;
165
166 a.d = fa;
167 sig = a.ll & 0x8000000000000000ull;
168 exp = (a.ll >> 52) & 0x7ff;
169 mant = a.ll & 0x000fffffffffffffull;
170
171 if (exp == 2047) {
172 /* NaN or infinity */
173 r = 1; /* VAX dirty zero */
174 } else if (exp == 0) {
175 if (mant == 0) {
176 /* Zero */
177 r = 0;
178 } else {
179 /* Denormalized */
180 r = sig | ((exp + 1) << 52) | mant;
181 }
182 } else {
183 if (exp >= 2045) {
184 /* Overflow */
185 r = 1; /* VAX dirty zero */
186 } else {
187 r = sig | ((exp + 2) << 52);
188 }
189 }
190
191 return r;
192 }
193
194 static float64 g_to_float64(CPUAlphaState *env, uintptr_t retaddr, uint64_t a)
195 {
196 uint64_t exp, mant_sig;
197 CPU_DoubleU r;
198
199 exp = (a >> 52) & 0x7ff;
200 mant_sig = a & 0x800fffffffffffffull;
201
202 if (!exp && mant_sig) {
203 /* Reserved operands / Dirty zero */
204 dynamic_excp(env, retaddr, EXCP_OPCDEC, 0);
205 }
206
207 if (exp < 3) {
208 /* Underflow */
209 r.ll = 0;
210 } else {
211 r.ll = ((exp - 2) << 52) | mant_sig;
212 }
213
214 return r.d;
215 }
216
217 uint64_t helper_g_to_memory(uint64_t a)
218 {
219 uint64_t r;
220 r = (a & 0x000000000000ffffull) << 48;
221 r |= (a & 0x00000000ffff0000ull) << 16;
222 r |= (a & 0x0000ffff00000000ull) >> 16;
223 r |= (a & 0xffff000000000000ull) >> 48;
224 return r;
225 }
226
227 uint64_t helper_memory_to_g(uint64_t a)
228 {
229 uint64_t r;
230 r = (a & 0x000000000000ffffull) << 48;
231 r |= (a & 0x00000000ffff0000ull) << 16;
232 r |= (a & 0x0000ffff00000000ull) >> 16;
233 r |= (a & 0xffff000000000000ull) >> 48;
234 return r;
235 }
236
237 uint64_t helper_addg(CPUAlphaState *env, uint64_t a, uint64_t b)
238 {
239 float64 fa, fb, fr;
240
241 fa = g_to_float64(env, GETPC(), a);
242 fb = g_to_float64(env, GETPC(), b);
243 fr = float64_add(fa, fb, &FP_STATUS);
244 return float64_to_g(fr);
245 }
246
247 uint64_t helper_subg(CPUAlphaState *env, uint64_t a, uint64_t b)
248 {
249 float64 fa, fb, fr;
250
251 fa = g_to_float64(env, GETPC(), a);
252 fb = g_to_float64(env, GETPC(), b);
253 fr = float64_sub(fa, fb, &FP_STATUS);
254 return float64_to_g(fr);
255 }
256
257 uint64_t helper_mulg(CPUAlphaState *env, uint64_t a, uint64_t b)
258 {
259 float64 fa, fb, fr;
260
261 fa = g_to_float64(env, GETPC(), a);
262 fb = g_to_float64(env, GETPC(), b);
263 fr = float64_mul(fa, fb, &FP_STATUS);
264 return float64_to_g(fr);
265 }
266
267 uint64_t helper_divg(CPUAlphaState *env, uint64_t a, uint64_t b)
268 {
269 float64 fa, fb, fr;
270
271 fa = g_to_float64(env, GETPC(), a);
272 fb = g_to_float64(env, GETPC(), b);
273 fr = float64_div(fa, fb, &FP_STATUS);
274 return float64_to_g(fr);
275 }
276
277 uint64_t helper_sqrtg(CPUAlphaState *env, uint64_t a)
278 {
279 float64 fa, fr;
280
281 fa = g_to_float64(env, GETPC(), a);
282 fr = float64_sqrt(fa, &FP_STATUS);
283 return float64_to_g(fr);
284 }
285
286 uint64_t helper_cmpgeq(CPUAlphaState *env, uint64_t a, uint64_t b)
287 {
288 float64 fa, fb;
289
290 fa = g_to_float64(env, GETPC(), a);
291 fb = g_to_float64(env, GETPC(), b);
292
293 if (float64_eq_quiet(fa, fb, &FP_STATUS)) {
294 return 0x4000000000000000ULL;
295 } else {
296 return 0;
297 }
298 }
299
300 uint64_t helper_cmpgle(CPUAlphaState *env, uint64_t a, uint64_t b)
301 {
302 float64 fa, fb;
303
304 fa = g_to_float64(env, GETPC(), a);
305 fb = g_to_float64(env, GETPC(), b);
306
307 if (float64_le(fa, fb, &FP_STATUS)) {
308 return 0x4000000000000000ULL;
309 } else {
310 return 0;
311 }
312 }
313
314 uint64_t helper_cmpglt(CPUAlphaState *env, uint64_t a, uint64_t b)
315 {
316 float64 fa, fb;
317
318 fa = g_to_float64(env, GETPC(), a);
319 fb = g_to_float64(env, GETPC(), b);
320
321 if (float64_lt(fa, fb, &FP_STATUS)) {
322 return 0x4000000000000000ULL;
323 } else {
324 return 0;
325 }
326 }
327
328 uint64_t helper_cvtqf(CPUAlphaState *env, uint64_t a)
329 {
330 float32 fr = int64_to_float32(a, &FP_STATUS);
331 return float32_to_f(fr);
332 }
333
334 uint64_t helper_cvtgf(CPUAlphaState *env, uint64_t a)
335 {
336 float64 fa;
337 float32 fr;
338
339 fa = g_to_float64(env, GETPC(), a);
340 fr = float64_to_float32(fa, &FP_STATUS);
341 return float32_to_f(fr);
342 }
343
344 uint64_t helper_cvtgq(CPUAlphaState *env, uint64_t a)
345 {
346 float64 fa = g_to_float64(env, GETPC(), a);
347 return float64_to_int64_round_to_zero(fa, &FP_STATUS);
348 }
349
350 uint64_t helper_cvtqg(CPUAlphaState *env, uint64_t a)
351 {
352 float64 fr;
353 fr = int64_to_float64(a, &FP_STATUS);
354 return float64_to_g(fr);
355 }