Subversion Repositories HelenOS-historic

Rev

Rev 1031 | Rev 1657 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (C) 2005 Josef Cejka
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  *
  9.  * - Redistributions of source code must retain the above copyright
  10.  *   notice, this list of conditions and the following disclaimer.
  11.  * - Redistributions in binary form must reproduce the above copyright
  12.  *   notice, this list of conditions and the following disclaimer in the
  13.  *   documentation and/or other materials provided with the distribution.
  14.  * - The name of the author may not be used to endorse or promote products
  15.  *   derived from this software without specific prior written permission.
  16.  *
  17.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27.  */
  28.  
  29. #include<sftypes.h>
  30. #include<common.h>
  31.  
  32. /* Table for fast leading zeroes counting */
  33. char zeroTable[256] = {
  34.     8, 7, 7, 6, 6, 6, 6, 4, 4, 4, 4, 4, 4, 4, 4, \
  35.     3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, \
  36.     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \
  37.     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \
  38.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
  39.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
  40.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
  41.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
  42.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
  43.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
  44.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
  45.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
  46.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
  47.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
  48.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
  49.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  50. };
  51.  
  52.  
  53.  
  54. /** Take fraction shifted by 10 bits to left, round it, normalize it and detect exceptions
  55.  * @param cexp exponent with bias
  56.  * @param cfrac fraction shifted 10 places left with added hidden bit
  57.  * @param sign
  58.  * @return valied float64
  59.  */
  60. float64 finishFloat64(int32_t cexp, uint64_t cfrac, char sign)
  61. {
  62.     float64 result;
  63.  
  64.     result.parts.sign = sign;
  65.  
  66.     /* find first nonzero digit and shift result and detect possibly underflow */
  67.     while ((cexp > 0) && (cfrac) && (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1 ) )))) {
  68.         cexp--;
  69.         cfrac <<= 1;
  70.             /* TODO: fix underflow */
  71.     };
  72.    
  73.     if ((cexp < 0) || ( cexp == 0 && (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))))) {
  74.         /* FIXME: underflow */
  75.         result.parts.exp = 0;
  76.         if ((cexp + FLOAT64_FRACTION_SIZE + 1) < 0) { /* +1 is place for rounding */
  77.             result.parts.fraction = 0;
  78.             return result;
  79.         }
  80.        
  81.         while (cexp < 0) {
  82.             cexp++;
  83.             cfrac >>= 1;
  84.         }
  85.    
  86.         cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3));
  87.        
  88.         if (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))) {
  89.            
  90.             result.parts.fraction = ((cfrac >>(64 - FLOAT64_FRACTION_SIZE - 2) ) & (~FLOAT64_HIDDEN_BIT_MASK));
  91.             return result;
  92.         }  
  93.     } else {
  94.         cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3));
  95.     }
  96.    
  97.     ++cexp;
  98.  
  99.     if (cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1 ))) {
  100.         ++cexp;
  101.         cfrac >>= 1;
  102.     }  
  103.  
  104.     /* check overflow */
  105.     if (cexp >= FLOAT64_MAX_EXPONENT ) {
  106.         /* FIXME: overflow, return infinity */
  107.         result.parts.exp = FLOAT64_MAX_EXPONENT;
  108.         result.parts.fraction = 0;
  109.         return result;
  110.     }
  111.  
  112.     result.parts.exp = (uint32_t)cexp;
  113.    
  114.     result.parts.fraction = ((cfrac >>(64 - FLOAT64_FRACTION_SIZE - 2 ) ) & (~FLOAT64_HIDDEN_BIT_MASK));
  115.    
  116.     return result; 
  117. }
  118.  
  119. /** Counts leading zeroes in 64bit unsigned integer
  120.  * @param i
  121.  */
  122. int countZeroes64(uint64_t i)
  123. {
  124.     int j;
  125.     for (j =0; j < 64; j += 8) {
  126.         if ( i & (0xFFll << (56 - j))) {
  127.             return (j + countZeroes8(i >> (56 - j)));
  128.         }
  129.     }
  130.  
  131.     return 64;
  132. }
  133.  
  134. /** Counts leading zeroes in 32bit unsigned integer
  135.  * @param i
  136.  */
  137. int countZeroes32(uint32_t i)
  138. {
  139.     int j;
  140.     for (j =0; j < 32; j += 8) {
  141.         if ( i & (0xFF << (24 - j))) {
  142.             return (j + countZeroes8(i >> (24 - j)));
  143.         }
  144.     }
  145.  
  146.     return 32;
  147. }
  148.  
  149. /** Counts leading zeroes in byte
  150.  * @param i
  151.  */
  152. int countZeroes8(uint8_t i)
  153. {
  154.     return zeroTable[i];
  155. }
  156.  
  157. /** Round and normalize number expressed by exponent and fraction with first bit (equal to hidden bit) at 30. bit
  158.  * @param exp exponent
  159.  * @param fraction part with hidden bit shifted to 30. bit
  160.  */
  161. void roundFloat32(int32_t *exp, uint32_t *fraction)
  162. {
  163.     /* rounding - if first bit after fraction is set then round up */
  164.     (*fraction) += (0x1 << 6);
  165.    
  166.     if ((*fraction) & (FLOAT32_HIDDEN_BIT_MASK << 8)) {
  167.         /* rounding overflow */
  168.         ++(*exp);
  169.         (*fraction) >>= 1;
  170.     };
  171.    
  172.     if (((*exp) >= FLOAT32_MAX_EXPONENT ) || ((*exp) < 0)) {
  173.         /* overflow - set infinity as result */
  174.         (*exp) = FLOAT32_MAX_EXPONENT;
  175.         (*fraction) = 0;
  176.         return;
  177.     }
  178.  
  179.     return;
  180. }
  181.  
  182. /** Round and normalize number expressed by exponent and fraction with first bit (equal to hidden bit) at 62. bit
  183.  * @param exp exponent
  184.  * @param fraction part with hidden bit shifted to 62. bit
  185.  */
  186. void roundFloat64(int32_t *exp, uint64_t *fraction)
  187. {
  188.     /* rounding - if first bit after fraction is set then round up */
  189.     (*fraction) += (0x1 << 9);
  190.    
  191.     if ((*fraction) & (FLOAT64_HIDDEN_BIT_MASK << 11)) {
  192.         /* rounding overflow */
  193.         ++(*exp);
  194.         (*fraction) >>= 1;
  195.     };
  196.    
  197.     if (((*exp) >= FLOAT64_MAX_EXPONENT ) || ((*exp) < 0)) {
  198.         /* overflow - set infinity as result */
  199.         (*exp) = FLOAT64_MAX_EXPONENT;
  200.         (*fraction) = 0;
  201.         return;
  202.     }
  203.  
  204.     return;
  205. }
  206.  
  207.