On Thu, Apr 14, 2011 at 1:11 AM, Aurelien Jarno wrote: > float*_eq functions have a different semantics than other comparison > functions. Fix that by first renaming float*_quiet() into > float*_eq_quiet(). > > Note that it is purely mechanical, and the behaviour should be unchanged. > That said it clearly highlight problems due to this different semantics, > they are fixed later in this patch series. > > Cc: Edgar E. Iglesias > Cc: Alexander Graf > Reviewed-by: Peter Maydell > Signed-off-by: Aurelien Jarno > Looks good to me Acked-by: Edgar E. Iglesias > --- > fpu/softfloat-native.h | 6 +++--- > fpu/softfloat.c | 8 ++++---- > fpu/softfloat.h | 8 ++++---- > linux-user/arm/nwfpe/fpa11_cprt.c | 2 +- > target-alpha/op_helper.c | 4 ++-- > target-i386/ops_sse.h | 8 ++++---- > target-microblaze/op_helper.c | 4 ++-- > target-mips/op_helper.c | 32 ++++++++++++++++---------------- > target-ppc/op_helper.c | 4 ++-- > 9 files changed, 38 insertions(+), 38 deletions(-) > > diff --git a/fpu/softfloat-native.h b/fpu/softfloat-native.h > index 406e180..0c7f48b 100644 > --- a/fpu/softfloat-native.h > +++ b/fpu/softfloat-native.h > @@ -210,7 +210,7 @@ INLINE float32 float32_div( float32 a, float32 b > STATUS_PARAM) > } > float32 float32_rem( float32, float32 STATUS_PARAM); > float32 float32_sqrt( float32 STATUS_PARAM); > -INLINE int float32_eq( float32 a, float32 b STATUS_PARAM) > +INLINE int float32_eq_quiet( float32 a, float32 b STATUS_PARAM) > { > return a == b; > } > @@ -321,7 +321,7 @@ INLINE float64 float64_div( float64 a, float64 b > STATUS_PARAM) > } > float64 float64_rem( float64, float64 STATUS_PARAM ); > float64 float64_sqrt( float64 STATUS_PARAM ); > -INLINE int float64_eq( float64 a, float64 b STATUS_PARAM) > +INLINE int float64_eq_quiet( float64 a, float64 b STATUS_PARAM) > { > return a == b; > } > @@ -428,7 +428,7 @@ INLINE floatx80 floatx80_div( floatx80 a, floatx80 b > STATUS_PARAM) > } > floatx80 floatx80_rem( floatx80, floatx80 STATUS_PARAM ); > floatx80 floatx80_sqrt( floatx80 STATUS_PARAM ); > -INLINE int floatx80_eq( floatx80 a, floatx80 b STATUS_PARAM) > +INLINE int floatx80_eq_quiet( floatx80 a, floatx80 b STATUS_PARAM) > { > return a == b; > } > diff --git a/fpu/softfloat.c b/fpu/softfloat.c > index 11f6584..492ef36 100644 > --- a/fpu/softfloat.c > +++ b/fpu/softfloat.c > @@ -2318,7 +2318,7 @@ float32 float32_log2( float32 a STATUS_PARAM ) > | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. > > *----------------------------------------------------------------------------*/ > > -int float32_eq( float32 a, float32 b STATUS_PARAM ) > +int float32_eq_quiet( float32 a, float32 b STATUS_PARAM ) > { > a = float32_squash_input_denormal(a STATUS_VAR); > b = float32_squash_input_denormal(b STATUS_VAR); > @@ -3582,7 +3582,7 @@ float64 float64_log2( float64 a STATUS_PARAM ) > | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. > > *----------------------------------------------------------------------------*/ > > -int float64_eq( float64 a, float64 b STATUS_PARAM ) > +int float64_eq_quiet( float64 a, float64 b STATUS_PARAM ) > { > uint64_t av, bv; > a = float64_squash_input_denormal(a STATUS_VAR); > @@ -4592,7 +4592,7 @@ floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM ) > | Arithmetic. > > *----------------------------------------------------------------------------*/ > > -int floatx80_eq( floatx80 a, floatx80 b STATUS_PARAM ) > +int floatx80_eq_quiet( floatx80 a, floatx80 b STATUS_PARAM ) > { > > if ( ( ( extractFloatx80Exp( a ) == 0x7FFF ) > @@ -5754,7 +5754,7 @@ float128 float128_sqrt( float128 a STATUS_PARAM ) > | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. > > *----------------------------------------------------------------------------*/ > > -int float128_eq( float128 a, float128 b STATUS_PARAM ) > +int float128_eq_quiet( float128 a, float128 b STATUS_PARAM ) > { > > if ( ( ( extractFloat128Exp( a ) == 0x7FFF ) > diff --git a/fpu/softfloat.h b/fpu/softfloat.h > index 55c0c1c..738a50c 100644 > --- a/fpu/softfloat.h > +++ b/fpu/softfloat.h > @@ -320,7 +320,7 @@ float32 float32_rem( float32, float32 STATUS_PARAM ); > float32 float32_sqrt( float32 STATUS_PARAM ); > float32 float32_exp2( float32 STATUS_PARAM ); > float32 float32_log2( float32 STATUS_PARAM ); > -int float32_eq( float32, float32 STATUS_PARAM ); > +int float32_eq_quiet( float32, float32 STATUS_PARAM ); > int float32_le( float32, float32 STATUS_PARAM ); > int float32_lt( float32, float32 STATUS_PARAM ); > int float32_unordered( float32, float32 STATUS_PARAM ); > @@ -436,7 +436,7 @@ float64 float64_div( float64, float64 STATUS_PARAM ); > float64 float64_rem( float64, float64 STATUS_PARAM ); > float64 float64_sqrt( float64 STATUS_PARAM ); > float64 float64_log2( float64 STATUS_PARAM ); > -int float64_eq( float64, float64 STATUS_PARAM ); > +int float64_eq_quiet( float64, float64 STATUS_PARAM ); > int float64_le( float64, float64 STATUS_PARAM ); > int float64_lt( float64, float64 STATUS_PARAM ); > int float64_unordered( float64, float64 STATUS_PARAM ); > @@ -539,7 +539,7 @@ floatx80 floatx80_mul( floatx80, floatx80 STATUS_PARAM > ); > floatx80 floatx80_div( floatx80, floatx80 STATUS_PARAM ); > floatx80 floatx80_rem( floatx80, floatx80 STATUS_PARAM ); > floatx80 floatx80_sqrt( floatx80 STATUS_PARAM ); > -int floatx80_eq( floatx80, floatx80 STATUS_PARAM ); > +int floatx80_eq_quiet( floatx80, floatx80 STATUS_PARAM ); > int floatx80_le( floatx80, floatx80 STATUS_PARAM ); > int floatx80_lt( floatx80, floatx80 STATUS_PARAM ); > int floatx80_unordered( floatx80, floatx80 STATUS_PARAM ); > @@ -624,7 +624,7 @@ float128 float128_mul( float128, float128 STATUS_PARAM > ); > float128 float128_div( float128, float128 STATUS_PARAM ); > float128 float128_rem( float128, float128 STATUS_PARAM ); > float128 float128_sqrt( float128 STATUS_PARAM ); > -int float128_eq( float128, float128 STATUS_PARAM ); > +int float128_eq_quiet( float128, float128 STATUS_PARAM ); > int float128_le( float128, float128 STATUS_PARAM ); > int float128_lt( float128, float128 STATUS_PARAM ); > int float128_unordered( float128, float128 STATUS_PARAM ); > diff --git a/linux-user/arm/nwfpe/fpa11_cprt.c > b/linux-user/arm/nwfpe/fpa11_cprt.c > index be54e95..8011897 100644 > --- a/linux-user/arm/nwfpe/fpa11_cprt.c > +++ b/linux-user/arm/nwfpe/fpa11_cprt.c > @@ -159,7 +159,7 @@ PerformComparisonOperation(floatx80 Fn, floatx80 Fm) > } > > /* test for equal condition */ > - if (floatx80_eq(Fn,Fm, &fpa11->fp_status)) > + if (floatx80_eq_quiet(Fn,Fm, &fpa11->fp_status)) > { > flags |= CC_ZERO; > } > diff --git a/target-alpha/op_helper.c b/target-alpha/op_helper.c > index 36f4f6d..9f71db4 100644 > --- a/target-alpha/op_helper.c > +++ b/target-alpha/op_helper.c > @@ -918,7 +918,7 @@ uint64_t helper_cmpteq(uint64_t a, uint64_t b) > fa = t_to_float64(a); > fb = t_to_float64(b); > > - if (float64_eq(fa, fb, &FP_STATUS)) > + if (float64_eq_quiet(fa, fb, &FP_STATUS)) > return 0x4000000000000000ULL; > else > return 0; > @@ -957,7 +957,7 @@ uint64_t helper_cmpgeq(uint64_t a, uint64_t b) > fa = g_to_float64(a); > fb = g_to_float64(b); > > - if (float64_eq(fa, fb, &FP_STATUS)) > + if (float64_eq_quiet(fa, fb, &FP_STATUS)) > return 0x4000000000000000ULL; > else > return 0; > diff --git a/target-i386/ops_sse.h b/target-i386/ops_sse.h > index 986cbe3..ac0f150 100644 > --- a/target-i386/ops_sse.h > +++ b/target-i386/ops_sse.h > @@ -921,11 +921,11 @@ void helper_ ## name ## sd (Reg *d, Reg *s)\ > d->XMM_Q(0) = F(64, d->XMM_D(0), s->XMM_D(0));\ > } > > -#define FPU_CMPEQ(size, a, b) float ## size ## _eq(a, b, &env->sse_status) > ? -1 : 0 > +#define FPU_CMPEQ(size, a, b) float ## size ## _eq_quiet(a, b, > &env->sse_status) ? -1 : 0 > #define FPU_CMPLT(size, a, b) float ## size ## _lt(a, b, &env->sse_status) > ? -1 : 0 > #define FPU_CMPLE(size, a, b) float ## size ## _le(a, b, &env->sse_status) > ? -1 : 0 > #define FPU_CMPUNORD(size, a, b) float ## size ## _unordered_quiet(a, b, > &env->sse_status) ? - 1 : 0 > -#define FPU_CMPNEQ(size, a, b) float ## size ## _eq(a, b, > &env->sse_status) ? 0 : -1 > +#define FPU_CMPNEQ(size, a, b) float ## size ## _eq_quiet(a, b, > &env->sse_status) ? 0 : -1 > #define FPU_CMPNLT(size, a, b) float ## size ## _lt(a, b, > &env->sse_status) ? 0 : -1 > #define FPU_CMPNLE(size, a, b) float ## size ## _le(a, b, > &env->sse_status) ? 0 : -1 > #define FPU_CMPORD(size, a, b) float ## size ## _unordered_quiet(a, b, > &env->sse_status) ? 0 : -1 > @@ -1216,8 +1216,8 @@ void helper_pfadd(MMXReg *d, MMXReg *s) > > void helper_pfcmpeq(MMXReg *d, MMXReg *s) > { > - d->MMX_L(0) = float32_eq(d->MMX_S(0), s->MMX_S(0), &env->mmx_status) ? > -1 : 0; > - d->MMX_L(1) = float32_eq(d->MMX_S(1), s->MMX_S(1), &env->mmx_status) ? > -1 : 0; > + d->MMX_L(0) = float32_eq_quiet(d->MMX_S(0), s->MMX_S(0), > &env->mmx_status) ? -1 : 0; > + d->MMX_L(1) = float32_eq_quiet(d->MMX_S(1), s->MMX_S(1), > &env->mmx_status) ? -1 : 0; > } > > void helper_pfcmpge(MMXReg *d, MMXReg *s) > diff --git a/target-microblaze/op_helper.c b/target-microblaze/op_helper.c > index 39b8ec1..b7cd6b2 100644 > --- a/target-microblaze/op_helper.c > +++ b/target-microblaze/op_helper.c > @@ -338,7 +338,7 @@ uint32_t helper_fcmp_eq(uint32_t a, uint32_t b) > set_float_exception_flags(0, &env->fp_status); > fa.l = a; > fb.l = b; > - r = float32_eq(fa.f, fb.f, &env->fp_status); > + r = float32_eq_quiet(fa.f, fb.f, &env->fp_status); > flags = get_float_exception_flags(&env->fp_status); > update_fpu_flags(flags & float_flag_invalid); > > @@ -384,7 +384,7 @@ uint32_t helper_fcmp_ne(uint32_t a, uint32_t b) > fa.l = a; > fb.l = b; > set_float_exception_flags(0, &env->fp_status); > - r = !float32_eq(fa.f, fb.f, &env->fp_status); > + r = !float32_eq_quiet(fa.f, fb.f, &env->fp_status); > flags = get_float_exception_flags(&env->fp_status); > update_fpu_flags(flags & float_flag_invalid); > > diff --git a/target-mips/op_helper.c b/target-mips/op_helper.c > index e9de692..31a19ba 100644 > --- a/target-mips/op_helper.c > +++ b/target-mips/op_helper.c > @@ -2893,8 +2893,8 @@ void helper_cmpabs_d_ ## op (uint64_t fdt0, uint64_t > fdt1, int cc) \ > * but float64_unordered_quiet() is still called. */ > FOP_COND_D(f, (float64_unordered_quiet(fdt1, fdt0, > &env->active_fpu.fp_status), 0)) > FOP_COND_D(un, float64_unordered_quiet(fdt1, fdt0, > &env->active_fpu.fp_status)) > -FOP_COND_D(eq, !float64_unordered_quiet(fdt1, fdt0, > &env->active_fpu.fp_status) && float64_eq(fdt0, fdt1, > &env->active_fpu.fp_status)) > -FOP_COND_D(ueq, float64_unordered_quiet(fdt1, fdt0, > &env->active_fpu.fp_status) || float64_eq(fdt0, fdt1, > &env->active_fpu.fp_status)) > +FOP_COND_D(eq, !float64_unordered_quiet(fdt1, fdt0, > &env->active_fpu.fp_status) && float64_eq_quiet(fdt0, fdt1, > &env->active_fpu.fp_status)) > +FOP_COND_D(ueq, float64_unordered_quiet(fdt1, fdt0, > &env->active_fpu.fp_status) || float64_eq_quiet(fdt0, fdt1, > &env->active_fpu.fp_status)) > FOP_COND_D(olt, !float64_unordered_quiet(fdt1, fdt0, > &env->active_fpu.fp_status) && float64_lt(fdt0, fdt1, > &env->active_fpu.fp_status)) > FOP_COND_D(ult, float64_unordered_quiet(fdt1, fdt0, > &env->active_fpu.fp_status) || float64_lt(fdt0, fdt1, > &env->active_fpu.fp_status)) > FOP_COND_D(ole, !float64_unordered_quiet(fdt1, fdt0, > &env->active_fpu.fp_status) && float64_le(fdt0, fdt1, > &env->active_fpu.fp_status)) > @@ -2903,8 +2903,8 @@ FOP_COND_D(ule, float64_unordered_quiet(fdt1, fdt0, > &env->active_fpu.fp_status) > * but float64_unordered() is still called. */ > FOP_COND_D(sf, (float64_unordered(fdt1, fdt0, > &env->active_fpu.fp_status), 0)) > FOP_COND_D(ngle,float64_unordered(fdt1, fdt0, &env->active_fpu.fp_status)) > -FOP_COND_D(seq, !float64_unordered(fdt1, fdt0, &env->active_fpu.fp_status) > && float64_eq(fdt0, fdt1, &env->active_fpu.fp_status)) > -FOP_COND_D(ngl, float64_unordered(fdt1, fdt0, &env->active_fpu.fp_status) > || float64_eq(fdt0, fdt1, &env->active_fpu.fp_status)) > +FOP_COND_D(seq, !float64_unordered(fdt1, fdt0, &env->active_fpu.fp_status) > && float64_eq_quiet(fdt0, fdt1, &env->active_fpu.fp_status)) > +FOP_COND_D(ngl, float64_unordered(fdt1, fdt0, &env->active_fpu.fp_status) > || float64_eq_quiet(fdt0, fdt1, &env->active_fpu.fp_status)) > FOP_COND_D(lt, !float64_unordered(fdt1, fdt0, &env->active_fpu.fp_status) > && float64_lt(fdt0, fdt1, &env->active_fpu.fp_status)) > FOP_COND_D(nge, float64_unordered(fdt1, fdt0, &env->active_fpu.fp_status) > || float64_lt(fdt0, fdt1, &env->active_fpu.fp_status)) > FOP_COND_D(le, !float64_unordered(fdt1, fdt0, &env->active_fpu.fp_status) > && float64_le(fdt0, fdt1, &env->active_fpu.fp_status)) > @@ -2937,8 +2937,8 @@ void helper_cmpabs_s_ ## op (uint32_t fst0, uint32_t > fst1, int cc) \ > * but float32_unordered_quiet() is still called. */ > FOP_COND_S(f, (float32_unordered_quiet(fst1, fst0, > &env->active_fpu.fp_status), 0)) > FOP_COND_S(un, float32_unordered_quiet(fst1, fst0, > &env->active_fpu.fp_status)) > -FOP_COND_S(eq, !float32_unordered_quiet(fst1, fst0, > &env->active_fpu.fp_status) && float32_eq(fst0, fst1, > &env->active_fpu.fp_status)) > -FOP_COND_S(ueq, float32_unordered_quiet(fst1, fst0, > &env->active_fpu.fp_status) || float32_eq(fst0, fst1, > &env->active_fpu.fp_status)) > +FOP_COND_S(eq, !float32_unordered_quiet(fst1, fst0, > &env->active_fpu.fp_status) && float32_eq_quiet(fst0, fst1, > &env->active_fpu.fp_status)) > +FOP_COND_S(ueq, float32_unordered_quiet(fst1, fst0, > &env->active_fpu.fp_status) || float32_eq_quiet(fst0, fst1, > &env->active_fpu.fp_status)) > FOP_COND_S(olt, !float32_unordered_quiet(fst1, fst0, > &env->active_fpu.fp_status) && float32_lt(fst0, fst1, > &env->active_fpu.fp_status)) > FOP_COND_S(ult, float32_unordered_quiet(fst1, fst0, > &env->active_fpu.fp_status) || float32_lt(fst0, fst1, > &env->active_fpu.fp_status)) > FOP_COND_S(ole, !float32_unordered_quiet(fst1, fst0, > &env->active_fpu.fp_status) && float32_le(fst0, fst1, > &env->active_fpu.fp_status)) > @@ -2947,8 +2947,8 @@ FOP_COND_S(ule, float32_unordered_quiet(fst1, fst0, > &env->active_fpu.fp_status) > * but float32_unordered() is still called. */ > FOP_COND_S(sf, (float32_unordered(fst1, fst0, > &env->active_fpu.fp_status), 0)) > FOP_COND_S(ngle,float32_unordered(fst1, fst0, &env->active_fpu.fp_status)) > -FOP_COND_S(seq, !float32_unordered(fst1, fst0, &env->active_fpu.fp_status) > && float32_eq(fst0, fst1, &env->active_fpu.fp_status)) > -FOP_COND_S(ngl, float32_unordered(fst1, fst0, &env->active_fpu.fp_status) > || float32_eq(fst0, fst1, &env->active_fpu.fp_status)) > +FOP_COND_S(seq, !float32_unordered(fst1, fst0, &env->active_fpu.fp_status) > && float32_eq_quiet(fst0, fst1, &env->active_fpu.fp_status)) > +FOP_COND_S(ngl, float32_unordered(fst1, fst0, &env->active_fpu.fp_status) > || float32_eq_quiet(fst0, fst1, &env->active_fpu.fp_status)) > FOP_COND_S(lt, !float32_unordered(fst1, fst0, &env->active_fpu.fp_status) > && float32_lt(fst0, fst1, &env->active_fpu.fp_status)) > FOP_COND_S(nge, float32_unordered(fst1, fst0, &env->active_fpu.fp_status) > || float32_lt(fst0, fst1, &env->active_fpu.fp_status)) > FOP_COND_S(le, !float32_unordered(fst1, fst0, &env->active_fpu.fp_status) > && float32_le(fst0, fst1, &env->active_fpu.fp_status)) > @@ -3000,10 +3000,10 @@ FOP_COND_PS(f, (float32_unordered_quiet(fst1, > fst0, &env->active_fpu.fp_status > (float32_unordered_quiet(fsth1, fsth0, > &env->active_fpu.fp_status), 0)) > FOP_COND_PS(un, float32_unordered_quiet(fst1, fst0, > &env->active_fpu.fp_status), > float32_unordered_quiet(fsth1, fsth0, > &env->active_fpu.fp_status)) > -FOP_COND_PS(eq, !float32_unordered_quiet(fst1, fst0, > &env->active_fpu.fp_status) && float32_eq(fst0, fst1, > &env->active_fpu.fp_status), > - !float32_unordered_quiet(fsth1, fsth0, > &env->active_fpu.fp_status) && float32_eq(fsth0, fsth1, > &env->active_fpu.fp_status)) > -FOP_COND_PS(ueq, float32_unordered_quiet(fst1, fst0, > &env->active_fpu.fp_status) || float32_eq(fst0, fst1, > &env->active_fpu.fp_status), > - float32_unordered_quiet(fsth1, fsth0, > &env->active_fpu.fp_status) || float32_eq(fsth0, fsth1, > &env->active_fpu.fp_status)) > +FOP_COND_PS(eq, !float32_unordered_quiet(fst1, fst0, > &env->active_fpu.fp_status) && float32_eq_quiet(fst0, fst1, > &env->active_fpu.fp_status), > + !float32_unordered_quiet(fsth1, fsth0, > &env->active_fpu.fp_status) && float32_eq_quiet(fsth0, fsth1, > &env->active_fpu.fp_status)) > +FOP_COND_PS(ueq, float32_unordered_quiet(fst1, fst0, > &env->active_fpu.fp_status) || float32_eq_quiet(fst0, fst1, > &env->active_fpu.fp_status), > + float32_unordered_quiet(fsth1, fsth0, > &env->active_fpu.fp_status) || float32_eq_quiet(fsth0, fsth1, > &env->active_fpu.fp_status)) > FOP_COND_PS(olt, !float32_unordered_quiet(fst1, fst0, > &env->active_fpu.fp_status) && float32_lt(fst0, fst1, > &env->active_fpu.fp_status), > !float32_unordered_quiet(fsth1, fsth0, > &env->active_fpu.fp_status) && float32_lt(fsth0, fsth1, > &env->active_fpu.fp_status)) > FOP_COND_PS(ult, float32_unordered_quiet(fst1, fst0, > &env->active_fpu.fp_status) || float32_lt(fst0, fst1, > &env->active_fpu.fp_status), > @@ -3018,10 +3018,10 @@ FOP_COND_PS(sf, (float32_unordered(fst1, fst0, > &env->active_fpu.fp_status), 0), > (float32_unordered(fsth1, fsth0, > &env->active_fpu.fp_status), 0)) > FOP_COND_PS(ngle,float32_unordered(fst1, fst0, > &env->active_fpu.fp_status), > float32_unordered(fsth1, fsth0, > &env->active_fpu.fp_status)) > -FOP_COND_PS(seq, !float32_unordered(fst1, fst0, > &env->active_fpu.fp_status) && float32_eq(fst0, fst1, > &env->active_fpu.fp_status), > - !float32_unordered(fsth1, fsth0, > &env->active_fpu.fp_status) && float32_eq(fsth0, fsth1, > &env->active_fpu.fp_status)) > -FOP_COND_PS(ngl, float32_unordered(fst1, fst0, &env->active_fpu.fp_status) > || float32_eq(fst0, fst1, &env->active_fpu.fp_status), > - float32_unordered(fsth1, fsth0, > &env->active_fpu.fp_status) || float32_eq(fsth0, fsth1, > &env->active_fpu.fp_status)) > +FOP_COND_PS(seq, !float32_unordered(fst1, fst0, > &env->active_fpu.fp_status) && float32_eq_quiet(fst0, fst1, > &env->active_fpu.fp_status), > + !float32_unordered(fsth1, fsth0, > &env->active_fpu.fp_status) && float32_eq_quiet(fsth0, fsth1, > &env->active_fpu.fp_status)) > +FOP_COND_PS(ngl, float32_unordered(fst1, fst0, &env->active_fpu.fp_status) > || float32_eq_quiet(fst0, fst1, &env->active_fpu.fp_status), > + float32_unordered(fsth1, fsth0, > &env->active_fpu.fp_status) || float32_eq_quiet(fsth0, fsth1, > &env->active_fpu.fp_status)) > FOP_COND_PS(lt, !float32_unordered(fst1, fst0, > &env->active_fpu.fp_status) && float32_lt(fst0, fst1, > &env->active_fpu.fp_status), > !float32_unordered(fsth1, fsth0, > &env->active_fpu.fp_status) && float32_lt(fsth0, fsth1, > &env->active_fpu.fp_status)) > FOP_COND_PS(nge, float32_unordered(fst1, fst0, &env->active_fpu.fp_status) > || float32_lt(fst0, fst1, &env->active_fpu.fp_status), > diff --git a/target-ppc/op_helper.c b/target-ppc/op_helper.c > index 4dae464..f645f57 100644 > --- a/target-ppc/op_helper.c > +++ b/target-ppc/op_helper.c > @@ -3352,7 +3352,7 @@ static inline uint32_t efststeq(uint32_t op1, > uint32_t op2) > CPU_FloatU u1, u2; > u1.l = op1; > u2.l = op2; > - return float32_eq(u1.f, u2.f, &env->vec_status) ? 4 : 0; > + return float32_eq_quiet(u1.f, u2.f, &env->vec_status) ? 4 : 0; > } > > static inline uint32_t efscmplt(uint32_t op1, uint32_t op2) > @@ -3666,7 +3666,7 @@ uint32_t helper_efdtsteq (uint64_t op1, uint64_t op2) > CPU_DoubleU u1, u2; > u1.ll = op1; > u2.ll = op2; > - return float64_eq(u1.d, u2.d, &env->vec_status) ? 4 : 0; > + return float64_eq_quiet(u1.d, u2.d, &env->vec_status) ? 4 : 0; > } > > uint32_t helper_efdcmplt (uint64_t op1, uint64_t op2) > -- > 1.7.2.3 > >