Philippe Mathieu-Daudé <f4...@amsat.org> writes:
> Hi Alex, Richard,
>
> On 01/09/2018 09:22 AM, Alex Bennée wrote:
>> These structures pave the way for generic softfloat helper routines
>> that will operate on fully decomposed numbers.
>>
>> Signed-off-by: Alex Bennée <alex.ben...@linaro.org>
>> Signed-off-by: Richard Henderson <richard.hender...@linaro.org>
>> ---
>> fpu/softfloat.c | 70
>> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
>> 1 file changed, 69 insertions(+), 1 deletion(-)
>>
>> diff --git a/fpu/softfloat.c b/fpu/softfloat.c
>> index 59afe81d06..fcba28d3f8 100644
>> --- a/fpu/softfloat.c
>> +++ b/fpu/softfloat.c
>> @@ -83,7 +83,7 @@ this code that are retained.
>> * target-dependent and needs the TARGET_* macros.
>> */
>> #include "qemu/osdep.h"
>> -
>> +#include "qemu/bitops.h"
>> #include "fpu/softfloat.h"
>>
>> /* We only need stdlib for abort() */
>> @@ -186,6 +186,74 @@ static inline flag extractFloat64Sign(float64 a)
>> return float64_val(a) >> 63;
>> }
>>
>> +/*----------------------------------------------------------------------------
>> +| Classify a floating point number.
>> +*----------------------------------------------------------------------------*/
>> +
>> +typedef enum {
>> + float_class_unclassified,
>> + float_class_zero,
>> + float_class_normal,
>> + float_class_inf,
>> + float_class_qnan,
>> + float_class_snan,
>> + float_class_dnan,
>> + float_class_msnan, /* maybe silenced */
>> +} float_class;
>> +
>> +/*----------------------------------------------------------------------------
>> +| Structure holding all of the decomposed parts of a float.
>> +| The exponent is unbiased and the fraction is normalized.
>> +*----------------------------------------------------------------------------*/
>> +
>> +typedef struct {
>> + uint64_t frac : 64;
>
> I think this does not work on LLP64/IL32P64 model.
>
> Should we add a check in ./configure and refuse to build on IL32P64
> model? This would be safer IMHO.
>
>> + int exp : 32;
>> + float_class cls : 8;
>> + int : 23;
>> + bool sign : 1;
>
> checking on "ISO/IEC 14882:1998" 9.6 Bit-fields:
>
> Alignment of bit-fields is implementation-defined. Bit-fields are packed
> into some addressable allocation unit. [Note: bit-fields straddle
> allocation units on some machines and not on others. Bit-fields are
> assigned right-to-left on some machines, left-to-right on others. ]
>
> I'd still write it:
>
> int :23, sign :1;
>
>> +} decomposed_parts;
I think rather than stuff it into bit fields we can just leave it up to
the compiler?
>> +
>> +#define DECOMPOSED_BINARY_POINT (64 - 2)
>> +#define DECOMPOSED_IMPLICIT_BIT (1ull << DECOMPOSED_BINARY_POINT)
>> +#define DECOMPOSED_OVERFLOW_BIT (DECOMPOSED_IMPLICIT_BIT << 1)
>> +
>> +/* Structure holding all of the relevant parameters for a format. */
>> +typedef struct {
>> + int exp_bias;
>> + int exp_max;
>> + int frac_shift;
>> + uint64_t frac_lsb;
>> + uint64_t frac_lsbm1;
>> + uint64_t round_mask;
>> + uint64_t roundeven_mask;
>> +} decomposed_params;
>> +
>> +#define FRAC_PARAMS(F) \
>> + .frac_shift = F, \
>> + .frac_lsb = 1ull << (F), \
>> + .frac_lsbm1 = 1ull << ((F) - 1), \
>> + .round_mask = (1ull << (F)) - 1, \
>> + .roundeven_mask = (2ull << (F)) - 1
>> +
>> +static const decomposed_params float16_params = {
>> + .exp_bias = 0x0f,
>> + .exp_max = 0x1f,
>> + FRAC_PARAMS(DECOMPOSED_BINARY_POINT - 10)
>> +};
>> +
>> +static const decomposed_params float32_params = {
>> + .exp_bias = 0x7f,
>> + .exp_max = 0xff,
>> + FRAC_PARAMS(DECOMPOSED_BINARY_POINT - 23)
>> +};
>> +
>> +static const decomposed_params float64_params = {
>> + .exp_bias = 0x3ff,
>> + .exp_max = 0x7ff,
>> + FRAC_PARAMS(DECOMPOSED_BINARY_POINT - 52)
>> +};
>> +
>>
>> /*----------------------------------------------------------------------------
>> | Takes a 64-bit fixed-point value `absZ' with binary point between bits 6
>> | and 7, and returns the properly rounded 32-bit integer corresponding to
>> the
>>
--
Alex Bennée
