Subversion Repositories HelenOS-historic

Rev

Rev 857 | Rev 865 | 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. }
  177.  
  178. long __fixsfdi(float a)
  179. {
  180.     float32 fa;
  181.     fa.f = a;
  182.    
  183.     return float32_to_long(fa);
  184. }
  185. long __fixdfdi(double a)
  186. {
  187. }
  188.  
  189. long long __fixsfti(float a)
  190. {
  191. }
  192. long long __fixdfti(double a)
  193. {
  194. }
  195.  
  196. unsigned int __fixunssfsi(float a)
  197. {
  198.     float32 fa;
  199.     fa.f = a;
  200.    
  201.     return float32_to_uint(fa);
  202. }
  203. unsigned int __fixunsdfsi(double a)
  204. {
  205. }
  206.  
  207. unsigned long __fixunssfdi(float a)
  208. {
  209.     float32 fa;
  210.     fa.f = a;
  211.    
  212.     return float32_to_ulong(fa);
  213. }
  214. unsigned long __fixunsdfdi(double a)
  215. {
  216. }
  217.  
  218. unsigned long long __fixunssfti(float a)
  219. {
  220. }
  221. unsigned long long __fixunsdfti(double a)
  222. {
  223. }
  224.  
  225. float __floatsisf(int i)
  226. {
  227. }
  228. double __floatsidf(int i)
  229. {
  230. }
  231.  
  232. float __floatdisf(long i)
  233. {
  234. }
  235. double __floatdidf(long i)
  236. {
  237. }
  238.  
  239. float __floattisf(long long i)
  240. {
  241. }
  242. double __floattidf(long long i)
  243. {
  244. }
  245.  
  246. float __floatunsisf(unsigned int i)
  247. {
  248. }
  249. double __floatunsidf(unsigned int i)
  250. {
  251. }
  252.  
  253. float __floatundisf(unsigned long i)
  254. {
  255. }
  256. double __floatundidf(unsigned long i)
  257. {
  258. }
  259.  
  260. float __floatuntisf(unsigned long long i)
  261. {
  262. }
  263. double __floatuntidf(unsigned long long i)
  264. {
  265. }
  266.  
  267. /* Comparison functions */
  268. /* Comparison functions */
  269.  
  270. /* a<b .. -1
  271.  * a=b ..  0
  272.  * a>b ..  1
  273.  * */
  274.  
  275. int __cmpsf2(float a, float b)
  276. {
  277.     float32 fa, fb;
  278.     fa.f = a;
  279.     fb.f = b;
  280.     if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
  281.         return 1; /* no special constant for unordered - maybe signaled? */
  282.     };
  283.  
  284.    
  285.     if (isFloat32eq(fa, fb)) {
  286.         return 0;
  287.     };
  288.    
  289.     if (isFloat32lt(fa, fb)) {
  290.         return -1;
  291.         };
  292.     return 1;
  293. }
  294.  
  295. int __unordsf2(float a, float b)
  296. {
  297.     float32 fa, fb;
  298.     fa.f = a;
  299.     fb.f = b;
  300.     return ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) );
  301. }
  302.  
  303. /**
  304.  * @return zero, if neither argument is a NaN and are equal
  305.  * */
  306. int __eqsf2(float a, float b)
  307. {
  308.     float32 fa, fb;
  309.     fa.f = a;
  310.     fb.f = b;
  311.     if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
  312.         /* TODO: sigNaNs*/
  313.         return 1;
  314.         };
  315.     return isFloat32eq(fa, fb) - 1;
  316. }
  317.  
  318. /* strange behavior, but it was in gcc documentation */
  319. int __nesf2(float a, float b)
  320. {
  321.     return __eqsf2(a, b);
  322. }
  323.  
  324. /* return value >= 0 if a>=b and neither is NaN */
  325. int __gesf2(float a, float b)
  326. {
  327.     float32 fa, fb;
  328.     fa.f = a;
  329.     fb.f = b;
  330.     if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
  331.         /* TODO: sigNaNs*/
  332.         return -1;
  333.         };
  334.    
  335.     if (isFloat32eq(fa, fb)) {
  336.         return 0;
  337.     };
  338.    
  339.     if (isFloat32gt(fa, fb)) {
  340.         return 1;
  341.         };
  342.    
  343.     return -1;
  344. }
  345.  
  346. /** Return negative value, if a<b and neither is NaN*/
  347. int __ltsf2(float a, float b)
  348. {
  349.     float32 fa, fb;
  350.     fa.f = a;
  351.     fb.f = b;
  352.     if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
  353.         /* TODO: sigNaNs*/
  354.         return 1;
  355.         };
  356.     if (isFloat32lt(fa, fb)) {
  357.         return -1;
  358.         };
  359.     return 0;
  360. }
  361.  
  362. /* return value <= 0 if a<=b and neither is NaN */
  363. int __lesf2(float a, float b)
  364. {
  365.     float32 fa, fb;
  366.     fa.f = a;
  367.     fb.f = b;
  368.     if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
  369.         /* TODO: sigNaNs*/
  370.         return 1;
  371.         };
  372.    
  373.     if (isFloat32eq(fa, fb)) {
  374.         return 0;
  375.     };
  376.    
  377.     if (isFloat32lt(fa, fb)) {
  378.         return -1;
  379.         };
  380.    
  381.     return 1;
  382. }
  383.  
  384. /** Return positive value, if a>b and neither is NaN*/
  385. int __gtsf2(float a, float b)
  386. {
  387.     float32 fa, fb;
  388.     fa.f = a;
  389.     fb.f = b;
  390.     if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
  391.         /* TODO: sigNaNs*/
  392.         return -1;
  393.         };
  394.     if (isFloat32gt(fa, fb)) {
  395.         return 1;
  396.         };
  397.     return 0;
  398. }
  399.  
  400. /* Other functions */
  401.  
  402. float __powisf2(float a, int b)
  403. {
  404. /* TODO: */
  405. }
  406.  
  407. float __mulsc3(float a, float b, float c, float d)
  408. {
  409. /* TODO: */
  410. }
  411.  
  412. float __divsc3(float a, float b, float c, float d)
  413. {
  414. /* TODO: */
  415. }
  416.  
  417.