Subversion Repositories HelenOS-historic

Rev

Rev 865 | Rev 876 | 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.  
  32. #include<add.h>
  33. #include<sub.h>
  34. #include<mul.h>
  35. #include<div.h>
  36.  
  37. #include<conversion.h>
  38. #include<comparison.h>
  39. #include<other.h>
  40.  
  41. #include<arch.h>
  42. #include<types.h>
  43. #include<functions.h>
  44.  
  45. /* Arithmetic functions */
  46.  
  47. float __addsf3(float a, float b)
  48. {
  49.     float32 fa, fb;
  50.     fa.f = a;
  51.     fb.f = b;
  52.     if (fa.parts.sign != fb.parts.sign) {
  53.         if (fa.parts.sign) {
  54.             fa.parts.sign = 0;
  55.             return subFloat32(fb, fa).f;
  56.         };
  57.         fb.parts.sign = 0;
  58.         return subFloat32(fa, fb).f;
  59.     }
  60.     return addFloat32(fa, fb).f;
  61. }
  62.  
  63. double __adddf3(double a, double b)
  64. {
  65.     float64 da, db;
  66.     da.d = a;
  67.     db.d = b;
  68.     if (da.parts.sign != db.parts.sign) {
  69.         if (da.parts.sign) {
  70.             da.parts.sign = 0;
  71.             return subFloat64(db, da).d;
  72.         };
  73.         db.parts.sign = 0;
  74.         return subFloat64(da, db).d;
  75.     }
  76.     return addFloat64(da, db).d;
  77. }
  78.  
  79. float __subsf3(float a, float b)
  80. {
  81.     float32 fa, fb;
  82.     fa.f = a;
  83.     fb.f = b;
  84.     if (fa.parts.sign != fb.parts.sign) {
  85.         fb.parts.sign = !fb.parts.sign;
  86.         return addFloat32(fa, fb).f;
  87.     }
  88.     return subFloat32(fa, fb).f;
  89. }
  90.  
  91. double __subdf3(double a, double b)
  92. {
  93.     float64 da, db;
  94.     da.d = a;
  95.     db.d = b;
  96.     if (da.parts.sign != db.parts.sign) {
  97.         db.parts.sign = !db.parts.sign;
  98.         return addFloat64(da, db).d;
  99.     }
  100.     return subFloat64(da, db).d;
  101. }
  102.  
  103. float __mulsf3(float a, float b)
  104. {
  105.     float32 fa, fb;
  106.     fa.f = a;
  107.     fb.f = b;
  108.     return  mulFloat32(fa, fb).f;
  109. }
  110.  
  111. double __muldf3(double a, double b)
  112. {
  113.     float64 da, db;
  114.     da.d = a;
  115.     db.d = b;
  116.     return  mulFloat64(da, db).d;
  117. }
  118.  
  119. float __divsf3(float a, float b)
  120. {
  121.     float32 fa, fb;
  122.     fa.f = a;
  123.     fb.f = b;
  124.     return  divFloat32(fa, fb).f;
  125. }
  126.  
  127. double __divdf3(double a, double b)
  128. {
  129.     float64 da, db;
  130.     da.d = a;
  131.     db.d = b;
  132.     return  divFloat64(da, db).d;
  133. }
  134.  
  135. float __negsf2(float a)
  136. {
  137.     float32 fa;
  138.     fa.f = a;
  139.     fa.parts.sign = !fa.parts.sign;
  140.     return fa.f;
  141. }
  142.  
  143. double __negdf2(double a)
  144. {
  145.     float64 fa;
  146.     fa.d = a;
  147.     fa.parts.sign = !fa.parts.sign;
  148.     return fa.d;
  149. }
  150.  
  151. /* Conversion functions */
  152.  
  153. double __extendsfdf2(float a)
  154. {
  155.     float32 fa;
  156.     fa.f = a;
  157.     return convertFloat32ToFloat64(fa).d;
  158. }
  159.  
  160. float __truncdfsf2(double a)
  161. {
  162.     float64 da;
  163.     da.d = a;
  164.     return convertFloat64ToFloat32(da).f;
  165. }
  166.  
  167. int __fixsfsi(float a)
  168. {
  169.     float32 fa;
  170.     fa.f = a;
  171.    
  172.     return float32_to_int(fa);
  173. }
  174. int __fixdfsi(double a)
  175. {
  176.     float64 da;
  177.     da.d = a;
  178.    
  179.     return float64_to_int(da);
  180. }
  181.  
  182. long __fixsfdi(float a)
  183. {
  184.     float32 fa;
  185.     fa.f = a;
  186.    
  187.     return float32_to_long(fa);
  188. }
  189. long __fixdfdi(double a)
  190. {
  191.     float64 da;
  192.     da.d = a;
  193.    
  194.     return float64_to_long(da);
  195. }
  196.  
  197. long long __fixsfti(float a)
  198. {
  199.     float32 fa;
  200.     fa.f = a;
  201.    
  202.     return float32_to_longlong(fa);
  203. }
  204. long long __fixdfti(double a)
  205. {
  206.     float64 da;
  207.     da.d = a;
  208.    
  209.     return float64_to_longlong(da);
  210. }
  211.  
  212. unsigned int __fixunssfsi(float a)
  213. {
  214.     float32 fa;
  215.     fa.f = a;
  216.    
  217.     return float32_to_uint(fa);
  218. }
  219. unsigned int __fixunsdfsi(double a)
  220. {
  221.     float64 da;
  222.     da.d = a;
  223.    
  224.     return float64_to_uint(da);
  225. }
  226.  
  227. unsigned long __fixunssfdi(float a)
  228. {
  229.     float32 fa;
  230.     fa.f = a;
  231.    
  232.     return float32_to_ulong(fa);
  233. }
  234. unsigned long __fixunsdfdi(double a)
  235. {
  236.     float64 da;
  237.     da.d = a;
  238.    
  239.     return float64_to_ulong(da);
  240. }
  241.  
  242. unsigned long long __fixunssfti(float a)
  243. {
  244.     float32 fa;
  245.     fa.f = a;
  246.    
  247.     return float32_to_ulonglong(fa);
  248. }
  249. unsigned long long __fixunsdfti(double a)
  250. {
  251.     float64 da;
  252.     da.d = a;
  253.    
  254.     return float64_to_ulonglong(da);
  255. }
  256.  
  257. float __floatsisf(int i)
  258. {
  259.     float32 fa;
  260.    
  261.     fa = int_to_float32(i);
  262.     return fa.f;
  263. }
  264. double __floatsidf(int i)
  265. {
  266. }
  267.  
  268. float __floatdisf(long i)
  269. {
  270.     float32 fa;
  271.    
  272.     fa = long_to_float32(i);
  273.     return fa.f;
  274. }
  275. double __floatdidf(long i)
  276. {
  277. }
  278.  
  279. float __floattisf(long long i)
  280. {
  281.     float32 fa;
  282.    
  283.     fa = longlong_to_float32(i);
  284.     return fa.f;
  285. }
  286. double __floattidf(long long i)
  287. {
  288. }
  289.  
  290. float __floatunsisf(unsigned int i)
  291. {
  292.     float32 fa;
  293.    
  294.     fa = uint_to_float32(i);
  295.     return fa.f;
  296. }
  297. double __floatunsidf(unsigned int i)
  298. {
  299. }
  300.  
  301. float __floatundisf(unsigned long i)
  302. {
  303.     float32 fa;
  304.    
  305.     fa = ulong_to_float32(i);
  306.     return fa.f;
  307. }
  308. double __floatundidf(unsigned long i)
  309. {
  310. }
  311.  
  312. float __floatuntisf(unsigned long long i)
  313. {
  314.     float32 fa;
  315.    
  316.     fa = ulonglong_to_float32(i);
  317.     return fa.f;
  318. }
  319. double __floatuntidf(unsigned long long i)
  320. {
  321. }
  322.  
  323. /* Comparison functions */
  324. /* Comparison functions */
  325.  
  326. /* a<b .. -1
  327.  * a=b ..  0
  328.  * a>b ..  1
  329.  * */
  330.  
  331. int __cmpsf2(float a, float b)
  332. {
  333.     float32 fa, fb;
  334.     fa.f = a;
  335.     fb.f = b;
  336.     if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
  337.         return 1; /* no special constant for unordered - maybe signaled? */
  338.     };
  339.  
  340.    
  341.     if (isFloat32eq(fa, fb)) {
  342.         return 0;
  343.     };
  344.    
  345.     if (isFloat32lt(fa, fb)) {
  346.         return -1;
  347.         };
  348.     return 1;
  349. }
  350.  
  351. int __unordsf2(float a, float b)
  352. {
  353.     float32 fa, fb;
  354.     fa.f = a;
  355.     fb.f = b;
  356.     return ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) );
  357. }
  358.  
  359. /**
  360.  * @return zero, if neither argument is a NaN and are equal
  361.  * */
  362. int __eqsf2(float a, float b)
  363. {
  364.     float32 fa, fb;
  365.     fa.f = a;
  366.     fb.f = b;
  367.     if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
  368.         /* TODO: sigNaNs*/
  369.         return 1;
  370.         };
  371.     return isFloat32eq(fa, fb) - 1;
  372. }
  373.  
  374. /* strange behavior, but it was in gcc documentation */
  375. int __nesf2(float a, float b)
  376. {
  377.     return __eqsf2(a, b);
  378. }
  379.  
  380. /* return value >= 0 if a>=b and neither is NaN */
  381. int __gesf2(float a, float b)
  382. {
  383.     float32 fa, fb;
  384.     fa.f = a;
  385.     fb.f = b;
  386.     if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
  387.         /* TODO: sigNaNs*/
  388.         return -1;
  389.         };
  390.    
  391.     if (isFloat32eq(fa, fb)) {
  392.         return 0;
  393.     };
  394.    
  395.     if (isFloat32gt(fa, fb)) {
  396.         return 1;
  397.         };
  398.    
  399.     return -1;
  400. }
  401.  
  402. /** Return negative value, if a<b and neither is NaN*/
  403. int __ltsf2(float a, float b)
  404. {
  405.     float32 fa, fb;
  406.     fa.f = a;
  407.     fb.f = b;
  408.     if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
  409.         /* TODO: sigNaNs*/
  410.         return 1;
  411.         };
  412.     if (isFloat32lt(fa, fb)) {
  413.         return -1;
  414.         };
  415.     return 0;
  416. }
  417.  
  418. /* return value <= 0 if a<=b and neither is NaN */
  419. int __lesf2(float a, float b)
  420. {
  421.     float32 fa, fb;
  422.     fa.f = a;
  423.     fb.f = b;
  424.     if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
  425.         /* TODO: sigNaNs*/
  426.         return 1;
  427.         };
  428.    
  429.     if (isFloat32eq(fa, fb)) {
  430.         return 0;
  431.     };
  432.    
  433.     if (isFloat32lt(fa, fb)) {
  434.         return -1;
  435.         };
  436.    
  437.     return 1;
  438. }
  439.  
  440. /** Return positive value, if a>b and neither is NaN*/
  441. int __gtsf2(float a, float b)
  442. {
  443.     float32 fa, fb;
  444.     fa.f = a;
  445.     fb.f = b;
  446.     if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
  447.         /* TODO: sigNaNs*/
  448.         return -1;
  449.         };
  450.     if (isFloat32gt(fa, fb)) {
  451.         return 1;
  452.         };
  453.     return 0;
  454. }
  455.  
  456. /* Other functions */
  457.  
  458. float __powisf2(float a, int b)
  459. {
  460. /* TODO: */
  461. }
  462.  
  463. float __mulsc3(float a, float b, float c, float d)
  464. {
  465. /* TODO: */
  466. }
  467.  
  468. float __divsc3(float a, float b, float c, float d)
  469. {
  470. /* TODO: */
  471. }
  472.  
  473.