scsi: pvscsi: check command descriptor ring buffer size (CVE-2016-4952)
[qemu.git] / target-tricore / fpu_helper.c
1 /*
2 * TriCore emulation for qemu: fpu helper.
3 *
4 * Copyright (c) 2016 Bastian Koppelmann University of Paderborn
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/helper-proto.h"
23
24 #define ADD_NAN 0x7cf00001
25 #define DIV_NAN 0x7fc00008
26 #define MUL_NAN 0x7fc00002
27 #define FPU_FS PSW_USB_C
28 #define FPU_FI PSW_USB_V
29 #define FPU_FV PSW_USB_SV
30 #define FPU_FZ PSW_USB_AV
31 #define FPU_FU PSW_USB_SAV
32
33 /* we don't care about input_denormal */
34 static inline uint8_t f_get_excp_flags(CPUTriCoreState *env)
35 {
36 return get_float_exception_flags(&env->fp_status)
37 & (float_flag_invalid
38 | float_flag_overflow
39 | float_flag_underflow
40 | float_flag_output_denormal
41 | float_flag_divbyzero
42 | float_flag_inexact);
43 }
44
45 static inline bool f_is_denormal(float32 arg)
46 {
47 return float32_is_zero_or_denormal(arg) && !float32_is_zero(arg);
48 }
49
50 static void f_update_psw_flags(CPUTriCoreState *env, uint8_t flags)
51 {
52 uint8_t some_excp = 0;
53 set_float_exception_flags(0, &env->fp_status);
54
55 if (flags & float_flag_invalid) {
56 env->FPU_FI = 1 << 31;
57 some_excp = 1;
58 }
59
60 if (flags & float_flag_overflow) {
61 env->FPU_FV = 1 << 31;
62 some_excp = 1;
63 }
64
65 if (flags & float_flag_underflow || flags & float_flag_output_denormal) {
66 env->FPU_FU = 1 << 31;
67 some_excp = 1;
68 }
69
70 if (flags & float_flag_divbyzero) {
71 env->FPU_FZ = 1 << 31;
72 some_excp = 1;
73 }
74
75 if (flags & float_flag_inexact || flags & float_flag_output_denormal) {
76 env->PSW |= 1 << 26;
77 some_excp = 1;
78 }
79
80 env->FPU_FS = some_excp;
81 }
82
83 #define FADD_SUB(op) \
84 uint32_t helper_f##op(CPUTriCoreState *env, uint32_t r1, uint32_t r2) \
85 { \
86 float32 arg1 = make_float32(r1); \
87 float32 arg2 = make_float32(r2); \
88 uint32_t flags; \
89 float32 f_result; \
90 \
91 f_result = float32_##op(arg2, arg1, &env->fp_status); \
92 flags = f_get_excp_flags(env); \
93 if (flags) { \
94 /* If the output is a NaN, but the inputs aren't, \
95 we return a unique value. */ \
96 if ((flags & float_flag_invalid) \
97 && !float32_is_any_nan(arg1) \
98 && !float32_is_any_nan(arg2)) { \
99 f_result = ADD_NAN; \
100 } \
101 f_update_psw_flags(env, flags); \
102 } else { \
103 env->FPU_FS = 0; \
104 } \
105 return (uint32_t)f_result; \
106 }
107 FADD_SUB(add)
108 FADD_SUB(sub)
109
110 uint32_t helper_fmul(CPUTriCoreState *env, uint32_t r1, uint32_t r2)
111 {
112 uint32_t flags;
113 float32 arg1 = make_float32(r1);
114 float32 arg2 = make_float32(r2);
115 float32 f_result;
116
117 f_result = float32_mul(arg1, arg2, &env->fp_status);
118
119 flags = f_get_excp_flags(env);
120 if (flags) {
121 /* If the output is a NaN, but the inputs aren't,
122 we return a unique value. */
123 if ((flags & float_flag_invalid)
124 && !float32_is_any_nan(arg1)
125 && !float32_is_any_nan(arg2)) {
126 f_result = MUL_NAN;
127 }
128 f_update_psw_flags(env, flags);
129 } else {
130 env->FPU_FS = 0;
131 }
132 return (uint32_t)f_result;
133
134 }
135
136 uint32_t helper_fdiv(CPUTriCoreState *env, uint32_t r1, uint32_t r2)
137 {
138 uint32_t flags;
139 float32 arg1 = make_float32(r1);
140 float32 arg2 = make_float32(r2);
141 float32 f_result;
142
143 f_result = float32_div(arg1, arg2 , &env->fp_status);
144
145 flags = f_get_excp_flags(env);
146 if (flags) {
147 /* If the output is a NaN, but the inputs aren't,
148 we return a unique value. */
149 if ((flags & float_flag_invalid)
150 && !float32_is_any_nan(arg1)
151 && !float32_is_any_nan(arg2)) {
152 f_result = DIV_NAN;
153 }
154 f_update_psw_flags(env, flags);
155 } else {
156 env->FPU_FS = 0;
157 }
158
159 return (uint32_t)f_result;
160 }
161
162 uint32_t helper_fcmp(CPUTriCoreState *env, uint32_t r1, uint32_t r2)
163 {
164 uint32_t result, flags;
165 float32 arg1 = make_float32(r1);
166 float32 arg2 = make_float32(r2);
167
168 set_flush_inputs_to_zero(0, &env->fp_status);
169
170 result = 1 << (float32_compare_quiet(arg1, arg2, &env->fp_status) + 1);
171 result |= f_is_denormal(arg1) << 4;
172 result |= f_is_denormal(arg2) << 5;
173
174 flags = f_get_excp_flags(env);
175 if (flags) {
176 f_update_psw_flags(env, flags);
177 } else {
178 env->FPU_FS = 0;
179 }
180
181 set_flush_inputs_to_zero(1, &env->fp_status);
182 return result;
183 }
184
185 uint32_t helper_ftoi(CPUTriCoreState *env, uint32_t arg)
186 {
187 float32 f_arg = make_float32(arg);
188 int32_t result, flags;
189
190 result = float32_to_int32(f_arg, &env->fp_status);
191
192 flags = f_get_excp_flags(env);
193 if (flags) {
194 if (float32_is_any_nan(f_arg)) {
195 result = 0;
196 }
197 f_update_psw_flags(env, flags);
198 } else {
199 env->FPU_FS = 0;
200 }
201 return (uint32_t)result;
202 }
203
204 uint32_t helper_itof(CPUTriCoreState *env, uint32_t arg)
205 {
206 float32 f_result;
207 uint32_t flags;
208 f_result = int32_to_float32(arg, &env->fp_status);
209
210 flags = f_get_excp_flags(env);
211 if (flags) {
212 f_update_psw_flags(env, flags);
213 } else {
214 env->FPU_FS = 0;
215 }
216 return (uint32_t)f_result;
217 }