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 #include "fpu/softfloat.h" 24 25 #define QUIET_NAN 0x7fc00000 26 #define ADD_NAN 0x7fc00001 27 #define DIV_NAN 0x7fc00008 28 #define MUL_NAN 0x7fc00002 29 #define FPU_FS PSW_USB_C 30 #define FPU_FI PSW_USB_V 31 #define FPU_FV PSW_USB_SV 32 #define FPU_FZ PSW_USB_AV 33 #define FPU_FU PSW_USB_SAV 34 35 /* we don't care about input_denormal */ 36 static inline uint8_t f_get_excp_flags(CPUTriCoreState *env) 37 { 38 return get_float_exception_flags(&env->fp_status) 39 & (float_flag_invalid 40 | float_flag_overflow 41 | float_flag_underflow 42 | float_flag_output_denormal 43 | float_flag_divbyzero 44 | float_flag_inexact); 45 } 46 47 static inline bool f_is_denormal(float32 arg) 48 { 49 return float32_is_zero_or_denormal(arg) && !float32_is_zero(arg); 50 } 51 52 static inline float32 f_maddsub_nan_result(float32 arg1, float32 arg2, 53 float32 arg3, float32 result, 54 uint32_t muladd_negate_c) 55 { 56 uint32_t aSign, bSign, cSign; 57 uint32_t aExp, bExp, cExp; 58 59 if (float32_is_any_nan(arg1) || float32_is_any_nan(arg2) || 60 float32_is_any_nan(arg3)) { 61 return QUIET_NAN; 62 } else if (float32_is_infinity(arg1) && float32_is_zero(arg2)) { 63 return MUL_NAN; 64 } else if (float32_is_zero(arg1) && float32_is_infinity(arg2)) { 65 return MUL_NAN; 66 } else { 67 aSign = arg1 >> 31; 68 bSign = arg2 >> 31; 69 cSign = arg3 >> 31; 70 71 aExp = (arg1 >> 23) & 0xff; 72 bExp = (arg2 >> 23) & 0xff; 73 cExp = (arg3 >> 23) & 0xff; 74 75 if (muladd_negate_c) { 76 cSign ^= 1; 77 } 78 if (((aExp == 0xff) || (bExp == 0xff)) && (cExp == 0xff)) { 79 if (aSign ^ bSign ^ cSign) { 80 return ADD_NAN; 81 } 82 } 83 } 84 85 return result; 86 } 87 88 static void f_update_psw_flags(CPUTriCoreState *env, uint8_t flags) 89 { 90 uint8_t some_excp = 0; 91 set_float_exception_flags(0, &env->fp_status); 92 93 if (flags & float_flag_invalid) { 94 env->FPU_FI = 1 << 31; 95 some_excp = 1; 96 } 97 98 if (flags & float_flag_overflow) { 99 env->FPU_FV = 1 << 31; 100 some_excp = 1; 101 } 102 103 if (flags & float_flag_underflow || flags & float_flag_output_denormal) { 104 env->FPU_FU = 1 << 31; 105 some_excp = 1; 106 } 107 108 if (flags & float_flag_divbyzero) { 109 env->FPU_FZ = 1 << 31; 110 some_excp = 1; 111 } 112 113 if (flags & float_flag_inexact || flags & float_flag_output_denormal) { 114 env->PSW |= 1 << 26; 115 some_excp = 1; 116 } 117 118 env->FPU_FS = some_excp; 119 } 120 121 #define FADD_SUB(op) \ 122 uint32_t helper_f##op(CPUTriCoreState *env, uint32_t r1, uint32_t r2) \ 123 { \ 124 float32 arg1 = make_float32(r1); \ 125 float32 arg2 = make_float32(r2); \ 126 uint32_t flags; \ 127 float32 f_result; \ 128 \ 129 f_result = float32_##op(arg2, arg1, &env->fp_status); \ 130 flags = f_get_excp_flags(env); \ 131 if (flags) { \ 132 /* If the output is a NaN, but the inputs aren't, \ 133 we return a unique value. */ \ 134 if ((flags & float_flag_invalid) \ 135 && !float32_is_any_nan(arg1) \ 136 && !float32_is_any_nan(arg2)) { \ 137 f_result = ADD_NAN; \ 138 } \ 139 f_update_psw_flags(env, flags); \ 140 } else { \ 141 env->FPU_FS = 0; \ 142 } \ 143 return (uint32_t)f_result; \ 144 } 145 FADD_SUB(add) 146 FADD_SUB(sub) 147 148 uint32_t helper_fmul(CPUTriCoreState *env, uint32_t r1, uint32_t r2) 149 { 150 uint32_t flags; 151 float32 arg1 = make_float32(r1); 152 float32 arg2 = make_float32(r2); 153 float32 f_result; 154 155 f_result = float32_mul(arg1, arg2, &env->fp_status); 156 157 flags = f_get_excp_flags(env); 158 if (flags) { 159 /* If the output is a NaN, but the inputs aren't, 160 we return a unique value. */ 161 if ((flags & float_flag_invalid) 162 && !float32_is_any_nan(arg1) 163 && !float32_is_any_nan(arg2)) { 164 f_result = MUL_NAN; 165 } 166 f_update_psw_flags(env, flags); 167 } else { 168 env->FPU_FS = 0; 169 } 170 return (uint32_t)f_result; 171 172 } 173 174 uint32_t helper_fdiv(CPUTriCoreState *env, uint32_t r1, uint32_t r2) 175 { 176 uint32_t flags; 177 float32 arg1 = make_float32(r1); 178 float32 arg2 = make_float32(r2); 179 float32 f_result; 180 181 f_result = float32_div(arg1, arg2 , &env->fp_status); 182 183 flags = f_get_excp_flags(env); 184 if (flags) { 185 /* If the output is a NaN, but the inputs aren't, 186 we return a unique value. */ 187 if ((flags & float_flag_invalid) 188 && !float32_is_any_nan(arg1) 189 && !float32_is_any_nan(arg2)) { 190 f_result = DIV_NAN; 191 } 192 f_update_psw_flags(env, flags); 193 } else { 194 env->FPU_FS = 0; 195 } 196 197 return (uint32_t)f_result; 198 } 199 200 uint32_t helper_fmadd(CPUTriCoreState *env, uint32_t r1, 201 uint32_t r2, uint32_t r3) 202 { 203 uint32_t flags; 204 float32 arg1 = make_float32(r1); 205 float32 arg2 = make_float32(r2); 206 float32 arg3 = make_float32(r3); 207 float32 f_result; 208 209 f_result = float32_muladd(arg1, arg2, arg3, 0, &env->fp_status); 210 211 flags = f_get_excp_flags(env); 212 if (flags) { 213 if (flags & float_flag_invalid) { 214 arg1 = float32_squash_input_denormal(arg1, &env->fp_status); 215 arg2 = float32_squash_input_denormal(arg2, &env->fp_status); 216 arg3 = float32_squash_input_denormal(arg3, &env->fp_status); 217 f_result = f_maddsub_nan_result(arg1, arg2, arg3, f_result, 0); 218 } 219 f_update_psw_flags(env, flags); 220 } else { 221 env->FPU_FS = 0; 222 } 223 return (uint32_t)f_result; 224 } 225 226 uint32_t helper_fmsub(CPUTriCoreState *env, uint32_t r1, 227 uint32_t r2, uint32_t r3) 228 { 229 uint32_t flags; 230 float32 arg1 = make_float32(r1); 231 float32 arg2 = make_float32(r2); 232 float32 arg3 = make_float32(r3); 233 float32 f_result; 234 235 f_result = float32_muladd(arg1, arg2, arg3, float_muladd_negate_product, 236 &env->fp_status); 237 238 flags = f_get_excp_flags(env); 239 if (flags) { 240 if (flags & float_flag_invalid) { 241 arg1 = float32_squash_input_denormal(arg1, &env->fp_status); 242 arg2 = float32_squash_input_denormal(arg2, &env->fp_status); 243 arg3 = float32_squash_input_denormal(arg3, &env->fp_status); 244 245 f_result = f_maddsub_nan_result(arg1, arg2, arg3, f_result, 1); 246 } 247 f_update_psw_flags(env, flags); 248 } else { 249 env->FPU_FS = 0; 250 } 251 return (uint32_t)f_result; 252 } 253 254 uint32_t helper_fcmp(CPUTriCoreState *env, uint32_t r1, uint32_t r2) 255 { 256 uint32_t result, flags; 257 float32 arg1 = make_float32(r1); 258 float32 arg2 = make_float32(r2); 259 260 set_flush_inputs_to_zero(0, &env->fp_status); 261 262 result = 1 << (float32_compare_quiet(arg1, arg2, &env->fp_status) + 1); 263 result |= f_is_denormal(arg1) << 4; 264 result |= f_is_denormal(arg2) << 5; 265 266 flags = f_get_excp_flags(env); 267 if (flags) { 268 f_update_psw_flags(env, flags); 269 } else { 270 env->FPU_FS = 0; 271 } 272 273 set_flush_inputs_to_zero(1, &env->fp_status); 274 return result; 275 } 276 277 uint32_t helper_ftoi(CPUTriCoreState *env, uint32_t arg) 278 { 279 float32 f_arg = make_float32(arg); 280 int32_t result, flags; 281 282 result = float32_to_int32(f_arg, &env->fp_status); 283 284 flags = f_get_excp_flags(env); 285 if (flags) { 286 if (float32_is_any_nan(f_arg)) { 287 result = 0; 288 } 289 f_update_psw_flags(env, flags); 290 } else { 291 env->FPU_FS = 0; 292 } 293 return (uint32_t)result; 294 } 295 296 uint32_t helper_itof(CPUTriCoreState *env, uint32_t arg) 297 { 298 float32 f_result; 299 uint32_t flags; 300 f_result = int32_to_float32(arg, &env->fp_status); 301 302 flags = f_get_excp_flags(env); 303 if (flags) { 304 f_update_psw_flags(env, flags); 305 } else { 306 env->FPU_FS = 0; 307 } 308 return (uint32_t)f_result; 309 } 310 311 uint32_t helper_ftouz(CPUTriCoreState *env, uint32_t arg) 312 { 313 float32 f_arg = make_float32(arg); 314 uint32_t result; 315 int32_t flags; 316 317 result = float32_to_uint32_round_to_zero(f_arg, &env->fp_status); 318 319 flags = f_get_excp_flags(env); 320 if (flags & float_flag_invalid) { 321 flags &= ~float_flag_inexact; 322 if (float32_is_any_nan(f_arg)) { 323 result = 0; 324 } 325 } else if (float32_lt_quiet(f_arg, 0, &env->fp_status)) { 326 flags = float_flag_invalid; 327 result = 0; 328 } 329 330 if (flags) { 331 f_update_psw_flags(env, flags); 332 } else { 333 env->FPU_FS = 0; 334 } 335 return result; 336 } 337 338 void helper_updfl(CPUTriCoreState *env, uint32_t arg) 339 { 340 env->FPU_FS = extract32(arg, 7, 1) & extract32(arg, 15, 1); 341 env->FPU_FI = (extract32(arg, 6, 1) & extract32(arg, 14, 1)) << 31; 342 env->FPU_FV = (extract32(arg, 5, 1) & extract32(arg, 13, 1)) << 31; 343 env->FPU_FZ = (extract32(arg, 4, 1) & extract32(arg, 12, 1)) << 31; 344 env->FPU_FU = (extract32(arg, 3, 1) & extract32(arg, 11, 1)) << 31; 345 /* clear FX and RM */ 346 env->PSW &= ~(extract32(arg, 10, 1) << 26); 347 env->PSW |= (extract32(arg, 2, 1) & extract32(arg, 10, 1)) << 26; 348 349 fpu_set_state(env); 350 } 351