WebSVN – HelenOS-historic – Blame – /uspace/trunk/softfloat/generic/conversion.c

Rev	Author	Line No.	Line
647	cejka	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
697	cejka	29	#include "sftypes.h"
		30	#include "conversion.h"
857	cejka	31	#include "comparison.h"
697	cejka	32
		33	float64 convertFloat32ToFloat64(float32 a)
		34	{
		35	float64 result;
804	cejka	36	__u64 frac;
697	cejka	37
		38	result.parts.sign = a.parts.sign;
804	cejka	39	result.parts.fraction = a.parts.fraction;
		40	result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE );
697	cejka	41
		42	if ((isFloat32Infinity(a))\|\|(isFloat32NaN(a))) {
		43	result.parts.exp = 0x7FF;
		44	/* TODO; check if its correct for SigNaNs*/
		45	return result;
		46	};
		47
		48	result.parts.exp = a.parts.exp + ( (int)FLOAT64_BIAS - FLOAT32_BIAS );
		49	if (a.parts.exp == 0) {
		50	/* normalize denormalized numbers */
		51
804	cejka	52	if (result.parts.fraction == 0ll) { /* fix zero */
697	cejka	53	result.parts.exp = 0ll;
		54	return result;
		55	}
		56
804	cejka	57	frac = result.parts.fraction;
697	cejka	58
804	cejka	59	while (!(frac & (0x10000000000000ll))) {
		60	frac <<= 1;
697	cejka	61	--result.parts.exp;
		62	};
698	cejka	63
		64	++result.parts.exp;
804	cejka	65	result.parts.fraction = frac;
697	cejka	66	};
		67
		68	return result;
		69
857	cejka	70	}
697	cejka	71
		72	float32 convertFloat64ToFloat32(float64 a)
		73	{
		74	float32 result;
		75	__s32 exp;
804	cejka	76	__u64 frac;
697	cejka	77
		78	result.parts.sign = a.parts.sign;
		79
		80	if (isFloat64NaN(a)) {
		81
		82	result.parts.exp = 0xFF;
		83
		84	if (isFloat64SigNaN(a)) {
804	cejka	85	result.parts.fraction = 0x800000; /* set first bit of fraction nonzero */
697	cejka	86	return result;
		87	}
		88
804	cejka	89	result.parts.fraction = 0x1; /* fraction nonzero but its first bit is zero */
697	cejka	90	return result;
		91	};
		92
		93	if (isFloat64Infinity(a)) {
804	cejka	94	result.parts.fraction = 0;
697	cejka	95	result.parts.exp = 0xFF;
		96	return result;
		97	};
		98
		99	exp = (int)a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS;
		100
		101	if (exp >= 0xFF) {
		102	/FIXME: overflow/
804	cejka	103	result.parts.fraction = 0;
697	cejka	104	result.parts.exp = 0xFF;
		105	return result;
		106
		107	} else if (exp <= 0 ) {
		108
		109	/* underflow or denormalized */
		110
		111	result.parts.exp = 0;
		112
		113	exp *= -1;
804	cejka	114	if (exp > FLOAT32_FRACTION_SIZE ) {
697	cejka	115	/* FIXME: underflow */
804	cejka	116	result.parts.fraction = 0;
697	cejka	117	return result;
		118	};
		119
		120	/* denormalized */
		121
804	cejka	122	frac = a.parts.fraction;
		123	frac \|= 0x10000000000000ll; /* denormalize and set hidden bit */
697	cejka	124
804	cejka	125	frac >>= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1);
698	cejka	126
697	cejka	127	while (exp > 0) {
		128	--exp;
804	cejka	129	frac >>= 1;
697	cejka	130	};
804	cejka	131	result.parts.fraction = frac;
697	cejka	132
		133	return result;
		134	};
		135
		136	result.parts.exp = exp;
804	cejka	137	result.parts.fraction = a.parts.fraction >> (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE);
697	cejka	138	return result;
857	cejka	139	}
697	cejka	140
857	cejka	141
		142	/** Helping procedure for converting float32 to uint32
		143	* @param a floating point number in normalized form (no NaNs or Inf are checked )
		144	* @return unsigned integer
		145	*/
		146	static __u32 _float32_to_uint32_helper(float32 a)
		147	{
		148	__u32 frac;
		149
		150	if (a.parts.exp < FLOAT32_BIAS) {
		151	/TODO: rounding/
		152	return 0;
		153	}
		154
		155	frac = a.parts.fraction;
		156
		157	frac \|= FLOAT32_HIDDEN_BIT_MASK;
		158	/* shift fraction to left so hidden bit will be the most significant bit */
		159	frac <<= 32 - FLOAT32_FRACTION_SIZE - 1;
		160
		161	frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1;
		162	if ((a.parts.sign == 1) && (frac != 0)) {
		163	frac = ~frac;
		164	++frac;
		165	}
		166
		167	return frac;
		168	}
		169
		170	/* Convert float to unsigned int32
		171	* FIXME: Im not sure what to return if overflow/underflow happens
		172	* - now its the biggest or the smallest int
		173	*/
		174	__u32 float32_to_uint32(float32 a)
		175	{
		176	if (isFloat32NaN(a)) {
		177	return MAX_UINT32;
		178	}
		179
		180	if (isFloat32Infinity(a) \|\| (a.parts.exp >= (32 + FLOAT32_BIAS))) {
		181	if (a.parts.sign) {
		182	return MIN_UINT32;
		183	}
		184	return MAX_UINT32;
		185	}
		186
		187	return _float32_to_uint32_helper(a);
		188	}
		189
		190	/* Convert float to signed int32
		191	* FIXME: Im not sure what to return if overflow/underflow happens
		192	* - now its the biggest or the smallest int
		193	*/
		194	__s32 float32_to_int32(float32 a)
		195	{
		196	if (isFloat32NaN(a)) {
		197	return MAX_INT32;
		198	}
		199
		200	if (isFloat32Infinity(a) \|\| (a.parts.exp >= (32 + FLOAT32_BIAS))) {
		201	if (a.parts.sign) {
		202	return MIN_INT32;
		203	}
		204	return MAX_INT32;
		205	}
		206	return _float32_to_uint32_helper(a);
		207	}
		208
		209
865	cejka	210	/** Helping procedure for converting float64 to uint64
		211	* @param a floating point number in normalized form (no NaNs or Inf are checked )
		212	* @return unsigned integer
		213	*/
		214	static __u64 _float64_to_uint64_helper(float64 a)
		215	{
		216	__u64 frac;
		217
		218	if (a.parts.exp < FLOAT64_BIAS) {
		219	/TODO: rounding/
		220	return 0;
		221	}
		222
		223	frac = a.parts.fraction;
		224
		225	frac \|= FLOAT64_HIDDEN_BIT_MASK;
		226	/* shift fraction to left so hidden bit will be the most significant bit */
		227	frac <<= 64 - FLOAT64_FRACTION_SIZE - 1;
857	cejka	228
865	cejka	229	frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1;
		230	if ((a.parts.sign == 1) && (frac != 0)) {
		231	frac = ~frac;
		232	++frac;
		233	}
		234
		235	return frac;
		236	}
		237
		238	/* Convert float to unsigned int64
		239	* FIXME: Im not sure what to return if overflow/underflow happens
		240	* - now its the biggest or the smallest int
		241	*/
		242	__u64 float64_to_uint64(float64 a)
		243	{
		244	if (isFloat64NaN(a)) {
		245	return MAX_UINT64;
		246	}
		247
		248	if (isFloat64Infinity(a) \|\| (a.parts.exp >= (64 + FLOAT64_BIAS))) {
		249	if (a.parts.sign) {
		250	return MIN_UINT64;
		251	}
		252	return MAX_UINT64;
		253	}
		254
		255	return _float64_to_uint64_helper(a);
		256	}
		257
		258	/* Convert float to signed int64
		259	* FIXME: Im not sure what to return if overflow/underflow happens
		260	* - now its the biggest or the smallest int
		261	*/
		262	__s64 float64_to_int64(float64 a)
		263	{
		264	if (isFloat64NaN(a)) {
		265	return MAX_INT64;
		266	}
		267
		268	if (isFloat64Infinity(a) \|\| (a.parts.exp >= (64 + FLOAT64_BIAS))) {
		269	if (a.parts.sign) {
		270	return MIN_INT64;
		271	}
		272	return MAX_INT64;
		273	}
		274	return _float64_to_uint64_helper(a);
		275	}
		276
		277
		278
		279
		280
		281	/** Helping procedure for converting float32 to uint64
		282	* @param a floating point number in normalized form (no NaNs or Inf are checked )
		283	* @return unsigned integer
		284	*/
		285	static __u64 _float32_to_uint64_helper(float32 a)
		286	{
		287	__u64 frac;
		288
		289	if (a.parts.exp < FLOAT32_BIAS) {
		290	/TODO: rounding/
		291	return 0;
		292	}
		293
		294	frac = a.parts.fraction;
		295
		296	frac \|= FLOAT32_HIDDEN_BIT_MASK;
		297	/* shift fraction to left so hidden bit will be the most significant bit */
		298	frac <<= 64 - FLOAT32_FRACTION_SIZE - 1;
		299
		300	frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1;
		301	if ((a.parts.sign == 1) && (frac != 0)) {
		302	frac = ~frac;
		303	++frac;
		304	}
		305
		306	return frac;
		307	}
		308
		309	/* Convert float to unsigned int64
		310	* FIXME: Im not sure what to return if overflow/underflow happens
		311	* - now its the biggest or the smallest int
		312	*/
		313	__u64 float32_to_uint64(float32 a)
		314	{
		315	if (isFloat32NaN(a)) {
		316	return MAX_UINT64;
		317	}
		318
		319	if (isFloat32Infinity(a) \|\| (a.parts.exp >= (64 + FLOAT32_BIAS))) {
		320	if (a.parts.sign) {
		321	return MIN_UINT64;
		322	}
		323	return MAX_UINT64;
		324	}
		325
		326	return _float32_to_uint64_helper(a);
		327	}
		328
		329	/* Convert float to signed int64
		330	* FIXME: Im not sure what to return if overflow/underflow happens
		331	* - now its the biggest or the smallest int
		332	*/
		333	__s64 float32_to_int64(float32 a)
		334	{
		335	if (isFloat32NaN(a)) {
		336	return MAX_INT64;
		337	}
		338
		339	if (isFloat32Infinity(a) \|\| (a.parts.exp >= (64 + FLOAT32_BIAS))) {
		340	if (a.parts.sign) {
		341	return (MIN_INT64);
		342	}
		343	return MAX_INT64;
		344	}
		345	return _float32_to_uint64_helper(a);
		346	}
		347
		348
		349	/* Convert float64 to unsigned int32
		350	* FIXME: Im not sure what to return if overflow/underflow happens
		351	* - now its the biggest or the smallest int
		352	*/
		353	__u32 float64_to_uint32(float64 a)
		354	{
		355	if (isFloat64NaN(a)) {
		356	return MAX_UINT32;
		357	}
		358
		359	if (isFloat64Infinity(a) \|\| (a.parts.exp >= (32 + FLOAT64_BIAS))) {
		360	if (a.parts.sign) {
		361	return MIN_UINT32;
		362	}
		363	return MAX_UINT32;
		364	}
		365
		366	return (__u32)_float64_to_uint64_helper(a);
		367	}
		368
		369	/* Convert float64 to signed int32
		370	* FIXME: Im not sure what to return if overflow/underflow happens
		371	* - now its the biggest or the smallest int
		372	*/
		373	__s32 float64_to_int32(float64 a)
		374	{
		375	if (isFloat64NaN(a)) {
		376	return MAX_INT32;
		377	}
		378
		379	if (isFloat64Infinity(a) \|\| (a.parts.exp >= (32 + FLOAT64_BIAS))) {
		380	if (a.parts.sign) {
		381	return MIN_INT32;
		382	}
		383	return MAX_INT32;
		384	}
		385	return (__s32)_float64_to_uint64_helper(a);
		386	}
		387
		388

Subversion Repositories HelenOS-historic

(root)/uspace/trunk/softfloat/generic/conversion.c @ 1740 – Rev 865