Subversion Repositories HelenOS-historic

Rev

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