Subversion Repositories HelenOS-historic

Rev

Rev 688 | Rev 698 | 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<softfloat.h>
  30. #include<sftypes.h>
  31. #include<arithmetic.h>
  32. #include<conversion.h>
  33. #include<comparison.h>
  34. #include<other.h>
  35.  
  36. /* Arithmetic functions */
  37.  
  38. float __addsf3(float a, float b)
  39. {
  40.     float32 fa, fb;
  41.     fa.f=a;
  42.     fb.f=b;
  43.     if (fa.parts.sign!=fb.parts.sign) {
  44.         if (fa.parts.sign) {
  45.             fa.parts.sign=0;
  46.             return subFloat32(fb,fa).f;
  47.         };
  48.         fb.parts.sign=0;
  49.         return subFloat32(fa,fb).f;
  50.     }
  51.     return addFloat32(fa,fb).f;
  52. };
  53.  
  54. float __subsf3(float a, float b)
  55. {
  56.     float32 fa, fb;
  57.     fa.f=a;
  58.     fb.f=b;
  59.     if (fa.parts.sign!=fb.parts.sign) {
  60.         fb.parts.sign=!fb.parts.sign;
  61.         return addFloat32(fa,fb).f;
  62.     }
  63.     return subFloat32(fa,fb).f;
  64. };
  65.  
  66. float __mulsf3(float a, float b)
  67. {
  68.     float32 fa, fb;
  69.     fa.f=a;
  70.     fb.f=b;
  71.     return  mulFloat32(fa, fb).f;
  72. }
  73.  
  74. float __divsf3(float a, float b)
  75. {
  76.     float32 fa, fb;
  77.     fa.f=a;
  78.     fb.f=b;
  79. //  return  divFloat32(fa, fb).f;
  80. };
  81.  
  82. float __negsf2(float a)
  83. {
  84.     float32 fa;
  85.     fa.f=a;
  86.     fa.parts.sign=!fa.parts.sign;
  87.     return fa.f;
  88. };
  89.  
  90. double __negdf2(double a)
  91. {
  92.     float64 fa;
  93.     fa.d=a;
  94.     fa.parts.sign=!fa.parts.sign;
  95.     return fa.d;
  96. };
  97.  
  98. /* Conversion functions */
  99.  
  100. double __extendsfdf2(float a)
  101. {
  102.     float32 fa;
  103.     fa.f = a;
  104.     return convertFloat32ToFloat64(fa).d;
  105. };
  106.  
  107. float __truncdfsf2(double a)
  108. {
  109.     float64 da;
  110.     da.d = a;
  111.     return convertFloat64ToFloat32(da).f;
  112. }
  113. /* Comparison functions */
  114.  
  115. /* a<b .. -1
  116.  * a=b ..  0
  117.  * a>b ..  1
  118.  * */
  119.  
  120. int __cmpsf2(float a, float b)
  121. {
  122.     float32 fa,fb;
  123.     fa.f=a;
  124.     fb.f=b;
  125.     if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
  126.         return 1; /* no special constant for unordered - maybe signaled? */
  127.     };
  128.  
  129.    
  130.     if (isFloat32eq(fa,fb)) {
  131.         return 0;
  132.     };
  133.    
  134.     if (isFloat32lt(fa,fb)) {
  135.         return -1;
  136.         };
  137.     return 1;
  138. }
  139.  
  140. int __unordsf2(float a, float b)
  141. {
  142.     float32 fa,fb;
  143.     fa.f=a;
  144.     fb.f=b;
  145.     return ((isFloat32NaN(fa))||(isFloat32NaN(fb)));
  146. };
  147.  
  148. /**
  149.  * @return zero, if neither argument is a NaN and are equal
  150.  * */
  151. int __eqsf2(float a, float b)
  152. {
  153.     float32 fa,fb;
  154.     fa.f=a;
  155.     fb.f=b;
  156.     if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
  157.         /* TODO: sigNaNs*/
  158.         return 1;
  159.         };
  160.     return isFloat32eq(fa,fb)-1;
  161. };
  162.  
  163. /* strange behavior, but it was in gcc documentation */
  164. int __nesf2(float a, float b)
  165. {
  166.     return __eqsf2(a,b);
  167. };
  168.  
  169. /* return value >= 0 if a>=b and neither is NaN */
  170. int __gesf2(float a, float b)
  171. {
  172.     float32 fa,fb;
  173.     fa.f=a;
  174.     fb.f=b;
  175.     if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
  176.         /* TODO: sigNaNs*/
  177.         return -1;
  178.         };
  179.    
  180.     if (isFloat32eq(fa,fb)) {
  181.         return 0;
  182.     };
  183.    
  184.     if (isFloat32gt(fa,fb)) {
  185.         return 1;
  186.         };
  187.    
  188.     return -1;
  189. }
  190.  
  191. /** Return negative value, if a<b and neither is NaN*/
  192. int __ltsf2(float a, float b)
  193. {
  194.     float32 fa,fb;
  195.     fa.f=a;
  196.     fb.f=b;
  197.     if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
  198.         /* TODO: sigNaNs*/
  199.         return 1;
  200.         };
  201.     if (isFloat32lt(fa, fb)) {
  202.         return -1;
  203.         };
  204.     return 0;
  205. }
  206.  
  207. /* return value <= 0 if a<=b and neither is NaN */
  208. int __lesf2(float a, float b)
  209. {
  210.     float32 fa,fb;
  211.     fa.f=a;
  212.     fb.f=b;
  213.     if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
  214.         /* TODO: sigNaNs*/
  215.         return 1;
  216.         };
  217.    
  218.     if (isFloat32eq(fa,fb)) {
  219.         return 0;
  220.     };
  221.    
  222.     if (isFloat32lt(fa,fb)) {
  223.         return -1;
  224.         };
  225.    
  226.     return 1;
  227. }
  228.  
  229. /** Return positive value, if a>b and neither is NaN*/
  230. int __gtsf2(float a, float b)
  231. {
  232.     float32 fa,fb;
  233.     fa.f=a;
  234.     fb.f=b;
  235.     if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
  236.         /* TODO: sigNaNs*/
  237.         return -1;
  238.         };
  239.     if (isFloat32gt(fa, fb)) {
  240.         return 1;
  241.         };
  242.     return 0;
  243. }
  244.  
  245. /* Other functions */
  246.  
  247.