All of lore.kernel.org
 help / color / mirror / Atom feed
From: "Edgar E. Iglesias" <edgar.iglesias@gmail.com>
To: Aurelien Jarno <aurelien@aurel32.net>
Cc: qemu-devel@nongnu.org, Alexander Graf <agraf@suse.de>
Subject: Re: [Qemu-devel] [PATCH v2 11/19] softfloat: rename float*_eq() into float*_eq_quiet()
Date: Thu, 14 Apr 2011 10:54:27 +0200	[thread overview]
Message-ID: <BANLkTikuCNtJxrfQoejh9Ppymv_kiVASzQ@mail.gmail.com> (raw)
In-Reply-To: <1302736274-2908-12-git-send-email-aurelien@aurel32.net>

[-- Attachment #1: Type: text/plain, Size: 20637 bytes --]

On Thu, Apr 14, 2011 at 1:11 AM, Aurelien Jarno <aurelien@aurel32.net>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 <edgar.iglesias@gmail.com>
> Cc: Alexander Graf <agraf@suse.de>
> Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
> Signed-off-by: Aurelien Jarno <aurelien@aurel32.net>
>

Looks good to me
Acked-by: Edgar E. Iglesias <edgar.iglesias@gmail.com>



> ---
>  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
>
>

[-- Attachment #2: Type: text/html, Size: 23429 bytes --]

  reply	other threads:[~2011-04-14  8:54 UTC|newest]

Thread overview: 22+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2011-04-13 23:10 [Qemu-devel] [PATCH v2 00/19] softfloat and FPU fixes/improvements Aurelien Jarno
2011-04-13 23:10 ` [Qemu-devel] [PATCH v2 01/19] softfloat: use GCC builtins to count the leading zeros Aurelien Jarno
2011-04-13 23:10 ` [Qemu-devel] [PATCH v2 02/19] cpu-all.h: define CPU_LDoubleU Aurelien Jarno
2011-04-13 23:10 ` [Qemu-devel] [PATCH v2 03/19] target-i386: use CPU_LDoubleU instead of a private union Aurelien Jarno
2011-04-13 23:10 ` [Qemu-devel] [PATCH v2 04/19] target-i386: use float unions from cpu-all.h Aurelien Jarno
2011-04-13 23:11 ` [Qemu-devel] [PATCH v2 05/19] target-i386: add floatx_{add, mul, sub} and use them Aurelien Jarno
2011-04-13 23:11 ` [Qemu-devel] [PATCH v2 06/19] softfloat: add float*_unordered_{, quiet}() functions Aurelien Jarno
2011-04-13 23:11 ` [Qemu-devel] [PATCH v2 07/19] softfloat-native: add float*_unordered_quiet() functions Aurelien Jarno
2011-04-13 23:11 ` [Qemu-devel] [PATCH v2 08/19] target-alpha: use new float64_unordered_quiet() function Aurelien Jarno
2011-04-14 16:35   ` Richard Henderson
2011-04-13 23:11 ` [Qemu-devel] [PATCH v2 09/19] target-mips: use new float*_unordered*() functions Aurelien Jarno
2011-04-13 23:11 ` [Qemu-devel] [PATCH v2 10/19] target-i386: fix CMPUNORDPS/D and CMPORDPS/D instructions Aurelien Jarno
2011-04-13 23:11 ` [Qemu-devel] [PATCH v2 11/19] softfloat: rename float*_eq() into float*_eq_quiet() Aurelien Jarno
2011-04-14  8:54   ` Edgar E. Iglesias [this message]
2011-04-13 23:11 ` [Qemu-devel] [PATCH v2 12/19] softfloat: rename float*_eq_signaling() into float*_eq() Aurelien Jarno
2011-04-13 23:11 ` [Qemu-devel] [PATCH v2 13/19] softfloat: move float*_eq and float*_eq_quiet Aurelien Jarno
2011-04-13 23:11 ` [Qemu-devel] [PATCH v2 14/19] softfloat: improve description of comparison functions Aurelien Jarno
2011-04-13 23:11 ` [Qemu-devel] [PATCH v2 15/19] target-ppc: fix SPE " Aurelien Jarno
2011-04-13 23:11 ` [Qemu-devel] [PATCH v2 16/19] target-mips: simplify FP comparisons Aurelien Jarno
2011-04-13 23:11 ` [Qemu-devel] [PATCH v2 17/19] target-mips: don't hardcode softfloat exception bits Aurelien Jarno
2011-04-13 23:11 ` [Qemu-devel] [PATCH v2 18/19] target-mips: fix c.ps.* instructions Aurelien Jarno
2011-04-13 23:11 ` [Qemu-devel] [PATCH v2 19/19] target-mips: clear softfpu exception state for comparison instructions Aurelien Jarno

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=BANLkTikuCNtJxrfQoejh9Ppymv_kiVASzQ@mail.gmail.com \
    --to=edgar.iglesias@gmail.com \
    --cc=agraf@suse.de \
    --cc=aurelien@aurel32.net \
    --cc=qemu-devel@nongnu.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body. 
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.