===================================================================
@@ -35,10 +35,16 @@ these four paragraphs for those parts of
=============================================================================*/
-#if defined(TARGET_MIPS) || defined(TARGET_SH4) || defined(TARGET_UNICORE32)
-#define SNAN_BIT_IS_ONE 1
+#if defined(TARGET_MIPS)
+/* Has to be decided dynamically. */
+#define SNAN_BIT_IS_VARIABLE 1
+#define SNAN_BIT_IS_ONE 0
+#elif defined(TARGET_SH4) || defined(TARGET_UNICORE32)
+#define SNAN_BIT_IS_VARIABLE 0
+#define SNAN_BIT_IS_ONE 1
#else
-#define SNAN_BIT_IS_ONE 0
+#define SNAN_BIT_IS_VARIABLE 0
+#define SNAN_BIT_IS_ONE 0
#endif
#if defined(TARGET_XTENSA)
@@ -55,6 +61,10 @@ inline float16 float16_default_nan(STATU
{
#if defined(TARGET_ARM)
return const_float16(0x7E00);
+#elif SNAN_BIT_IS_VARIABLE
+ return STATUS(nan2008_mode)
+ ? const_float16(0x7E00)
+ : const_float16(0x7DFF);
#elif SNAN_BIT_IS_ONE
return const_float16(0x7DFF);
#else
@@ -72,6 +82,10 @@ inline float32 float32_default_nan(STATU
#elif defined(TARGET_PPC) || defined(TARGET_ARM) || defined(TARGET_ALPHA) || \
defined(TARGET_XTENSA)
return const_float32(0x7FC00000);
+#elif SNAN_BIT_IS_VARIABLE
+ return STATUS(nan2008_mode)
+ ? const_float32(0x7FC00000)
+ : const_float32(0x7FBFFFFF);
#elif SNAN_BIT_IS_ONE
return const_float32(0x7FBFFFFF);
#else
@@ -88,6 +102,10 @@ inline float64 float64_default_nan(STATU
return const_float64(LIT64(0x7FFFFFFFFFFFFFFF));
#elif defined(TARGET_PPC) || defined(TARGET_ARM) || defined(TARGET_ALPHA)
return const_float64(LIT64(0x7FF8000000000000));
+#elif SNAN_BIT_IS_VARIABLE
+ return STATUS(nan2008_mode)
+ ? const_float64(LIT64(0x7FF8000000000000))
+ : const_float64(LIT64(0x7FF7FFFFFFFFFFFF));
#elif SNAN_BIT_IS_ONE
return const_float64(LIT64(0x7FF7FFFFFFFFFFFF));
#else
@@ -100,7 +118,11 @@ inline float64 float64_default_nan(STATU
*----------------------------------------------------------------------------*/
inline floatx80 floatx80_default_nan(STATUS_PARAM_ONLY)
{
-#if SNAN_BIT_IS_ONE
+#if SNAN_BIT_IS_VARIABLE
+ return STATUS(nan2008_mode)
+ ? make_floatx80(0xFFFF, LIT64(0xC000000000000000))
+ : make_floatx80(0x7FFF, LIT64(0xBFFFFFFFFFFFFFFF));
+#elif SNAN_BIT_IS_ONE
return make_floatx80(0x7FFF, LIT64(0xBFFFFFFFFFFFFFFF));
#else
return make_floatx80(0xFFFF, LIT64(0xC000000000000000));
@@ -113,7 +135,13 @@ inline floatx80 floatx80_default_nan(STA
*----------------------------------------------------------------------------*/
inline float128 float128_default_nan(STATUS_PARAM_ONLY)
{
-#if SNAN_BIT_IS_ONE
+#if SNAN_BIT_IS_VARIABLE
+ return STATUS(nan2008_mode)
+ ? make_float128(LIT64(0x7FFF800000000000),
+ LIT64(0x0000000000000000))
+ : make_float128(LIT64(0x7FFF7FFFFFFFFFFF),
+ LIT64(0xFFFFFFFFFFFFFFFF));
+#elif SNAN_BIT_IS_ONE
return make_float128(LIT64(0x7FFF7FFFFFFFFFFF), LIT64(0xFFFFFFFFFFFFFFFF));
#else
return make_float128(LIT64(0xFFFF800000000000), LIT64(0x0000000000000000));
@@ -162,7 +190,9 @@ int float16_is_quiet_nan(float16 a_ STAT
int __attribute__ ((unused)) x, y;
x = (((a >> 9) & 0x3F) == 0x3E) && (a & 0x1FF);
y = (a & ~0x8000) >= 0x7c80;
-#if SNAN_BIT_IS_ONE
+#if SNAN_BIT_IS_VARIABLE
+ return STATUS(nan2008_mode) ? y : x;
+#elif SNAN_BIT_IS_ONE
return x;
#else
return y;
@@ -180,7 +210,9 @@ int float16_is_signaling_nan(float16 a_
int __attribute__ ((unused)) x, y;
x = (a & ~0x8000) >= 0x7c80;
y = (((a >> 9) & 0x3F) == 0x3E) && (a & 0x1FF);
-#if SNAN_BIT_IS_ONE
+#if SNAN_BIT_IS_VARIABLE
+ return STATUS(nan2008_mode) ? y : x;
+#elif SNAN_BIT_IS_ONE
return x;
#else
return y;
@@ -195,8 +227,10 @@ int float16_is_signaling_nan(float16 a_
float16 float16_maybe_silence_nan(float16 a_ STATUS_PARAM)
{
if (float16_is_signaling_nan(a_ STATUS_VAR)) {
-#if SNAN_BIT_IS_ONE
-# if defined(TARGET_MIPS) || defined(TARGET_SH4) || defined(TARGET_UNICORE32)
+#if SNAN_BIT_IS_VARIABLE
+ return float16_default_nan(status);
+#elif SNAN_BIT_IS_ONE
+# if defined(TARGET_SH4) || defined(TARGET_UNICORE32)
return float16_default_nan(status);
# else
# error Rules for silencing a signaling NaN are target-specific
@@ -272,7 +306,9 @@ int float32_is_quiet_nan(float32 a_ STAT
int __attribute__ ((unused)) x, y;
x = (((a >> 22) & 0x1FF) == 0x1FE) && (a & 0x003FFFFF);
y = 0xFF800000 <= (uint32_t) (a << 1);
-#if SNAN_BIT_IS_ONE
+#if SNAN_BIT_IS_VARIABLE
+ return STATUS(nan2008_mode) ? y : x;
+#elif SNAN_BIT_IS_ONE
return x;
#else
return y;
@@ -290,7 +326,9 @@ int float32_is_signaling_nan(float32 a_
int __attribute__ ((unused)) x, y;
x = 0xFF800000 <= (uint32_t) (a << 1);
y = (((a >> 22) & 0x1FF) == 0x1FE) && (a & 0x003FFFFF);
-#if SNAN_BIT_IS_ONE
+#if SNAN_BIT_IS_VARIABLE
+ return STATUS(nan2008_mode) ? y : x;
+#elif SNAN_BIT_IS_ONE
return x;
#else
return y;
@@ -306,8 +344,10 @@ int float32_is_signaling_nan(float32 a_
float32 float32_maybe_silence_nan(float32 a_ STATUS_PARAM)
{
if (float32_is_signaling_nan(a_ STATUS_VAR)) {
-#if SNAN_BIT_IS_ONE
-# if defined(TARGET_MIPS) || defined(TARGET_SH4) || defined(TARGET_UNICORE32)
+#if SNAN_BIT_IS_VARIABLE
+ return float32_default_nan(status);
+#elif SNAN_BIT_IS_ONE
+# if defined(TARGET_SH4) || defined(TARGET_UNICORE32)
return float32_default_nan(status);
# else
# error Rules for silencing a signaling NaN are target-specific
@@ -688,7 +728,9 @@ int float64_is_quiet_nan(float64 a_ STAT
int __attribute__ ((unused)) x, y;
x = (((a >> 51) & 0xFFF) == 0xFFE) && (a & LIT64(0x0007FFFFFFFFFFFF));
y = LIT64(0xFFF0000000000000) <= (uint64_t) (a << 1);
-#if SNAN_BIT_IS_ONE
+#if SNAN_BIT_IS_VARIABLE
+ return STATUS(nan2008_mode) ? y : x;
+#elif SNAN_BIT_IS_ONE
return x;
#else
return y;
@@ -706,7 +748,9 @@ int float64_is_signaling_nan(float64 a_
int __attribute__ ((unused)) x, y;
x = LIT64(0xFFF0000000000000) <= (uint64_t) (a << 1);
y = (((a >> 51) & 0xFFF) == 0xFFE) && (a & LIT64(0x0007FFFFFFFFFFFF));
-#if SNAN_BIT_IS_ONE
+#if SNAN_BIT_IS_VARIABLE
+ return STATUS(nan2008_mode) ? y : x;
+#elif SNAN_BIT_IS_ONE
return x;
#else
return y;
@@ -722,8 +766,10 @@ int float64_is_signaling_nan(float64 a_
float64 float64_maybe_silence_nan(float64 a_ STATUS_PARAM)
{
if (float64_is_signaling_nan(a_ STATUS_VAR)) {
-#if SNAN_BIT_IS_ONE
-# if defined(TARGET_MIPS) || defined(TARGET_SH4) || defined(TARGET_UNICORE32)
+#if SNAN_BIT_IS_VARIABLE
+ return float64_default_nan(status);
+#elif SNAN_BIT_IS_ONE
+# if defined(TARGET_SH4) || defined(TARGET_UNICORE32)
return float64_default_nan(status);
# else
# error Rules for silencing a signaling NaN are target-specific
@@ -896,7 +942,9 @@ int floatx80_is_quiet_nan(floatx80 a STA
&& (a.low == aLow));
y = (((a.high & 0x7FFF) == 0x7FFF)
&& (LIT64(0x8000000000000000) <= ((uint64_t) (a.low << 1))));
-#if SNAN_BIT_IS_ONE
+#if SNAN_BIT_IS_VARIABLE
+ return STATUS(nan2008_mode) ? y : x;
+#elif SNAN_BIT_IS_ONE
return x;
#else
return y;
@@ -919,7 +967,9 @@ int floatx80_is_signaling_nan(floatx80 a
y = (((a.high & 0x7FFF) == 0x7FFF)
&& (uint64_t) (aLow << 1)
&& (a.low == aLow));
-#if SNAN_BIT_IS_ONE
+#if SNAN_BIT_IS_VARIABLE
+ return STATUS(nan2008_mode) ? y : x;
+#elif SNAN_BIT_IS_ONE
return x;
#else
return y;
@@ -935,8 +985,10 @@ int floatx80_is_signaling_nan(floatx80 a
floatx80 floatx80_maybe_silence_nan(floatx80 a STATUS_PARAM)
{
if (floatx80_is_signaling_nan(a STATUS_VAR)) {
-#if SNAN_BIT_IS_ONE
-# if defined(TARGET_MIPS) || defined(TARGET_SH4) || defined(TARGET_UNICORE32)
+#if SNAN_BIT_IS_VARIABLE
+ a = floatx80_default_nan(status);
+#elif SNAN_BIT_IS_ONE
+# if defined(TARGET_SH4) || defined(TARGET_UNICORE32)
a = floatx80_default_nan(status);
# else
# error Rules for silencing a signaling NaN are target-specific
@@ -1056,7 +1108,9 @@ int float128_is_quiet_nan(float128 a STA
&& (a.low || (a.high & LIT64(0x00007FFFFFFFFFFF))));
y = ((LIT64(0xFFFE000000000000) <= (uint64_t) (a.high << 1))
&& (a.low || (a.high & LIT64(0x0000FFFFFFFFFFFF))));
-#if SNAN_BIT_IS_ONE
+#if SNAN_BIT_IS_VARIABLE
+ return STATUS(nan2008_mode) ? y : x;
+#elif SNAN_BIT_IS_ONE
return x;
#else
return y;
@@ -1075,7 +1129,9 @@ int float128_is_signaling_nan(float128 a
&& (a.low || (a.high & LIT64(0x0000FFFFFFFFFFFF))));
y = ((((a.high >> 47) & 0xFFFF) == 0xFFFE)
&& (a.low || (a.high & LIT64(0x00007FFFFFFFFFFF))));
-#if SNAN_BIT_IS_ONE
+#if SNAN_BIT_IS_VARIABLE
+ return STATUS(nan2008_mode) ? y : x;
+#elif SNAN_BIT_IS_ONE
return x;
#else
return y;
@@ -1091,8 +1147,10 @@ int float128_is_signaling_nan(float128 a
float128 float128_maybe_silence_nan(float128 a STATUS_PARAM)
{
if (float128_is_signaling_nan(a STATUS_VAR)) {
-#if SNAN_BIT_IS_ONE
-# if defined(TARGET_MIPS) || defined(TARGET_SH4) || defined(TARGET_UNICORE32)
+#if SNAN_BIT_IS_VARIABLE
+ a = float128_default_nan(status);
+#elif SNAN_BIT_IS_ONE
+# if defined(TARGET_SH4) || defined(TARGET_UNICORE32)
a = float128_default_nan(status);
# else
# error Rules for silencing a signaling NaN are target-specific
===================================================================
@@ -179,6 +179,7 @@ typedef struct float_status {
/* should denormalised inputs go to zero and set the input_denormal flag? */
flag flush_inputs_to_zero;
flag default_nan_mode;
+ flag nan2008_mode;
} float_status;
static inline void set_float_detect_tininess(int val STATUS_PARAM)
@@ -209,6 +210,10 @@ static inline void set_default_nan_mode(
{
STATUS(default_nan_mode) = val;
}
+static inline void set_nan2008_mode(flag val STATUS_PARAM)
+{
+ STATUS(nan2008_mode) = val;
+}
static inline int get_float_detect_tininess(float_status *status)
{
return STATUS(float_detect_tininess);
===================================================================
@@ -615,7 +615,11 @@ void mips_cpu_list (FILE *f, fprintf_fun
extern void cpu_wrdsp(uint32_t rs, uint32_t mask_num, CPUMIPSState *env);
extern uint32_t cpu_rddsp(uint32_t mask_num, CPUMIPSState *env);
-#define CPU_SAVE_VERSION 7
+#define CPU_SAVE_VERSION 8
+/* We preserve compatibility with rev. 7 images. */
+#define CPU_SAVE_VERSION_OLDEST_SUPPORTED 7
+/* Rev. 8 added 2008 NaN support. */
+#define CPU_SAVE_VERSION_2008_NAN 8
/* MMU modes definitions. We carefully match the indices with our
hflags layout. */
===================================================================
@@ -39,6 +39,7 @@ static void save_fpu(QEMUFile *f, CPUMIP
for(i = 0; i < 32; i++)
qemu_put_be64s(f, &fpu->fpr[i].d);
qemu_put_8s(f, &fpu->fp_status.flush_to_zero);
+ qemu_put_8s(f, &fpu->fp_status.nan2008_mode);
qemu_put_s8s(f, &fpu->fp_status.float_rounding_mode);
qemu_put_s8s(f, &fpu->fp_status.float_exception_flags);
qemu_put_be32s(f, &fpu->fcr0);
@@ -195,13 +196,18 @@ static void load_tc(QEMUFile *f, TCState
qemu_get_8s(f, &tc->msa_fp_status.flush_inputs_to_zero);
}
-static void load_fpu(QEMUFile *f, CPUMIPSFPUContext *fpu)
+static void load_fpu(QEMUFile *f, CPUMIPSFPUContext *fpu, int version_id)
{
int i;
for(i = 0; i < 32; i++)
qemu_get_be64s(f, &fpu->fpr[i].d);
qemu_get_8s(f, &fpu->fp_status.flush_to_zero);
+ if (version_id >= CPU_SAVE_VERSION_2008_NAN) {
+ qemu_get_8s(f, &fpu->fp_status.nan2008_mode);
+ } else {
+ fpu->fp_status.nan2008_mode = 0;
+ }
qemu_get_s8s(f, &fpu->fp_status.float_rounding_mode);
qemu_get_s8s(f, &fpu->fp_status.float_exception_flags);
qemu_get_be32s(f, &fpu->fcr0);
@@ -214,7 +220,7 @@ int cpu_load(QEMUFile *f, void *opaque,
MIPSCPU *cpu = mips_env_get_cpu(env);
int i;
- if (version_id != CPU_SAVE_VERSION) {
+ if (version_id < CPU_SAVE_VERSION_OLDEST_SUPPORTED) {
return -EINVAL;
}
@@ -222,7 +228,7 @@ int cpu_load(QEMUFile *f, void *opaque,
load_tc(f, &env->active_tc);
/* Load active FPU */
- load_fpu(f, &env->active_fpu);
+ load_fpu(f, &env->active_fpu, version_id);
/* Load MVP */
qemu_get_sbe32s(f, &env->mvp->CP0_MVPControl);
@@ -336,8 +342,9 @@ int cpu_load(QEMUFile *f, void *opaque,
for (i = 0; i < MIPS_SHADOW_SET_MAX; i++) {
load_tc(f, &env->tcs[i]);
}
- for (i = 0; i < MIPS_FPU_MAX; i++)
- load_fpu(f, &env->fpus[i]);
+ for (i = 0; i < MIPS_FPU_MAX; i++) {
+ load_fpu(f, &env->fpus[i], version_id);
+ }
/* XXX: ensure compatibility for halted bit ? */
tlb_flush(CPU(cpu), 1);