Subversion Repositories HelenOS-historic

Rev

Rev 653 | Rev 688 | 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 __negsf2(float a)
  67. {
  68.     float32 fa;
  69.     fa.f=a;
  70.     fa.parts.sign=!fa.parts.sign;
  71.     return fa.f;
  72. };
  73.  
  74. double __negdf2(double a)
  75. {
  76.     float64 fa;
  77.     fa.d=a;
  78.     fa.parts.sign=!fa.parts.sign;
  79.     return fa.d;
  80. };
  81.  
  82. /* Conversion functions */
  83.  
  84. /* Comparison functions */
  85.  
  86. /* a<b .. -1
  87.  * a=b ..  0
  88.  * a>b ..  1
  89.  * */
  90.  
  91. int __cmpsf2(float a, float b)
  92. {
  93.     float32 fa,fb;
  94.     fa.f=a;
  95.     fb.f=b;
  96.     if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
  97.         return 1; /* no special constant for unordered - maybe signaled? */
  98.     };
  99.  
  100.    
  101.     if (isFloat32eq(fa,fb)) {
  102.         return 0;
  103.     };
  104.    
  105.     if (isFloat32lt(fa,fb)) {
  106.         return -1;
  107.         };
  108.     return 1;
  109. }
  110.  
  111. int __unordsf2(float a, float b)
  112. {
  113.     float32 fa,fb;
  114.     fa.f=a;
  115.     fb.f=b;
  116.     return ((isFloat32NaN(fa))||(isFloat32NaN(fb)));
  117. };
  118.  
  119. /**
  120.  * @return zero, if neither argument is a NaN and are equal
  121.  * */
  122. int __eqsf2(float a, float b)
  123. {
  124.     float32 fa,fb;
  125.     fa.f=a;
  126.     fb.f=b;
  127.     if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
  128.         /* TODO: sigNaNs*/
  129.         return 1;
  130.         };
  131.     return isFloat32eq(fa,fb)-1;
  132. };
  133.  
  134. /* strange behavior, but it was in gcc documentation */
  135. int __nesf2(float a, float b)
  136. {
  137.     return __eqsf2(a,b);
  138. };
  139.  
  140. /* return value >= 0 if a>=b and neither is NaN */
  141. int __gesf2(float a, float b)
  142. {
  143.     float32 fa,fb;
  144.     fa.f=a;
  145.     fb.f=b;
  146.     if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
  147.         /* TODO: sigNaNs*/
  148.         return -1;
  149.         };
  150.    
  151.     if (isFloat32eq(fa,fb)) {
  152.         return 0;
  153.     };
  154.    
  155.     if (isFloat32gt(fa,fb)) {
  156.         return 1;
  157.         };
  158.    
  159.     return -1;
  160. }
  161.  
  162. /** Return negative value, if a<b and neither is NaN*/
  163. int __ltsf2(float a, float b)
  164. {
  165.     float32 fa,fb;
  166.     fa.f=a;
  167.     fb.f=b;
  168.     if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
  169.         /* TODO: sigNaNs*/
  170.         return 1;
  171.         };
  172.     if (isFloat32lt(fa, fb)) {
  173.         return -1;
  174.         };
  175.     return 0;
  176. }
  177.  
  178. /* return value <= 0 if a<=b and neither is NaN */
  179. int __lesf2(float a, float b)
  180. {
  181.     float32 fa,fb;
  182.     fa.f=a;
  183.     fb.f=b;
  184.     if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
  185.         /* TODO: sigNaNs*/
  186.         return 1;
  187.         };
  188.    
  189.     if (isFloat32eq(fa,fb)) {
  190.         return 0;
  191.     };
  192.    
  193.     if (isFloat32lt(fa,fb)) {
  194.         return -1;
  195.         };
  196.    
  197.     return 1;
  198. }
  199.  
  200. /** Return positive value, if a>b and neither is NaN*/
  201. int __gtsf2(float a, float b)
  202. {
  203.     float32 fa,fb;
  204.     fa.f=a;
  205.     fb.f=b;
  206.     if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
  207.         /* TODO: sigNaNs*/
  208.         return -1;
  209.         };
  210.     if (isFloat32gt(fa, fb)) {
  211.         return 1;
  212.         };
  213.     return 0;
  214. }
  215.  
  216. /* Other functions */
  217.  
  218.