Subversion Repositories pentevo

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /* necfloat.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS                                                                        */
  6. /*                                                                           */
  7. /* NEC<->IEEE Floating Point Conversion on host                              */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include <math.h>
  13. #include <errno.h>
  14. #include <string.h>
  15.  
  16. #include "as_float.h"
  17. #include "necfloat.h"
  18.  
  19. /*!------------------------------------------------------------------------
  20.  * \fn     as_float_2_nec_4(as_float_t inp, LongWord *p_dest)
  21.  * \brief  convert from host to NEC 4 byte float format
  22.  * \param  inp value to dispose
  23.  * \param  p_dest where to dispose
  24.  * \return >0 for number of words used (1) or <0 for error code
  25.  * ------------------------------------------------------------------------ */
  26.  
  27. int as_float_2_nec_4(as_float_t inp, LongWord *p_dest)
  28. {
  29.   Boolean round_up;
  30.   as_float_dissect_t dissect;
  31.   LongWord mantissa;
  32.  
  33.   /* Dissect */
  34.  
  35.   as_float_dissect(&dissect, inp);
  36.  
  37.   /* Inf/NaN cannot be represented in target format: */
  38.  
  39.   if ((dissect.fp_class != AS_FP_NORMAL)
  40.    && (dissect.fp_class != AS_FP_SUBNORMAL))
  41.     return -EINVAL;
  42.  
  43.   /* For NEC float, Mantissa is in range 0.5...1.0, instead of 1.0...2.0: */
  44.  
  45.   dissect.exponent++;
  46.  
  47.   /* (3) Denormalize small numbers: */
  48.  
  49.   while ((dissect.exponent < -128) && !as_float_mantissa_is_zero(&dissect))
  50.   {
  51.     dissect.exponent++;
  52.     as_float_mantissa_shift_right(dissect.mantissa, 0, dissect.mantissa_bits);
  53.   }
  54.  
  55.   /* Build Two's complement.  Note the sign becomes part of the
  56.      mantissa, which is afterwards one bit longer: */
  57.  
  58.   as_float_mantissa_twos_complement(&dissect);
  59.  
  60.   /* Normalize, so that topmost bits of mantissa are unequal.  This happens
  61.      for powers of two, after negating: */
  62.  
  63.   switch (as_float_mantissa_extract(&dissect, 0, 2))
  64.   {
  65.     case 0:
  66.     case 3:
  67.       if (dissect.exponent > -128)
  68.       {
  69.         dissect.exponent--;
  70.         as_float_mantissa_shift_left(dissect.mantissa, 0, dissect.mantissa_bits);
  71.       }
  72.       break;
  73.   }
  74.  
  75.   /* (4) Round mantissa.  We will use 24 of them.  So the "half LSB" bit
  76.          to look at is bit 24, seen from left: */
  77.  
  78.   if (as_float_get_mantissa_bit(dissect.mantissa, dissect.mantissa_bits, 24))
  79.   {
  80.     if (!as_float_mantissa_is_zero_from(&dissect, 25)) /* > 0.5 */
  81.       round_up = True;
  82.     else /* == 0.5 */
  83.       round_up = as_float_get_mantissa_bit(dissect.mantissa, dissect.mantissa_bits, 23);
  84.   }
  85.   else /* < 0.5 */
  86.     round_up = False;
  87.  
  88.   if (round_up)
  89.   {
  90.     as_float_mant_t round_sum;
  91.  
  92.     (void)as_float_mantissa_add_bit(round_sum, dissect.mantissa, 24, dissect.mantissa_bits);
  93.  
  94.     /* overflow during round-up? */
  95.  
  96.     if ((round_sum[0] ^ dissect.mantissa[0]) & 0x80000000ul)
  97.     {
  98.       dissect.exponent++;
  99.       /* Arithmetic right shift of signed number to preserve sign: */
  100.       as_float_mantissa_shift_right(round_sum, as_float_get_mantissa_bit(dissect.mantissa, dissect.mantissa_bits, 0), dissect.mantissa_bits);
  101.     }
  102.  
  103.     memcpy(dissect.mantissa, round_sum, sizeof(dissect.mantissa));
  104.   }
  105.  
  106.   /* After knowing final exponent, check for overflow: */
  107.  
  108.   if (dissect.exponent > 127)
  109.     return -E2BIG;
  110.  
  111.   /* (5) Mantissa zero means exponent is minimum value */
  112.  
  113.   if (as_float_mantissa_is_zero(&dissect))
  114.     dissect.exponent = -128;
  115.  
  116.   /* (6) NEC documentation does not use mantissa value 0x800000 (-1.0) unless
  117.          absolutely necessary? */
  118.  
  119.   mantissa = as_float_mantissa_extract(&dissect, 0, 24);
  120.   if ((mantissa == 0x800000) && (dissect.exponent < 127))
  121.   {
  122.     mantissa = 0xc00000;
  123.     dissect.exponent++;
  124.   }
  125.  
  126.   /* (7) Assemble: */
  127.  
  128.   *p_dest = dissect.exponent & 0xff;
  129.   *p_dest = (*p_dest << 24) | mantissa;
  130.  
  131.   return 1;
  132. }
  133.