PageRenderTime 44ms CodeModel.GetById 14ms app.highlight 25ms RepoModel.GetById 1ms app.codeStats 0ms

/arch/parisc/math-emu/fcnvfut.c

https://github.com/aicjofs/android_kernel_lge_v500_20d_f2fs
C | 332 lines | 199 code | 23 blank | 110 comment | 56 complexity | bfa488d8f4fc8f4d2ebb79c7f018ca00 MD5 | raw file
  1/*
  2 * Linux/PA-RISC Project (http://www.parisc-linux.org/)
  3 *
  4 * Floating-point emulation code
  5 *  Copyright (C) 2001 Hewlett-Packard (Paul Bame) <bame@debian.org>
  6 *
  7 *    This program is free software; you can redistribute it and/or modify
  8 *    it under the terms of the GNU General Public License as published by
  9 *    the Free Software Foundation; either version 2, or (at your option)
 10 *    any later version.
 11 *
 12 *    This program is distributed in the hope that it will be useful,
 13 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 14 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 15 *    GNU General Public License for more details.
 16 *
 17 *    You should have received a copy of the GNU General Public License
 18 *    along with this program; if not, write to the Free Software
 19 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 20 */
 21/*
 22 * BEGIN_DESC
 23 *
 24 *  File:
 25 *	@(#)	pa/spmath/fcnvfut.c		$Revision: 1.1 $
 26 *
 27 *  Purpose:
 28 *	Floating-point to Unsigned Fixed-point Converts with Truncation
 29 *
 30 *  External Interfaces:
 31 *	dbl_to_dbl_fcnvfut(srcptr,nullptr,dstptr,status)
 32 *	dbl_to_sgl_fcnvfut(srcptr,nullptr,dstptr,status)
 33 *	sgl_to_dbl_fcnvfut(srcptr,nullptr,dstptr,status)
 34 *	sgl_to_sgl_fcnvfut(srcptr,nullptr,dstptr,status)
 35 *
 36 *  Internal Interfaces:
 37 *
 38 *  Theory:
 39 *	<<please update with a overview of the operation of this file>>
 40 *
 41 * END_DESC
 42*/
 43
 44
 45#include "float.h"
 46#include "sgl_float.h"
 47#include "dbl_float.h"
 48#include "cnv_float.h"
 49
 50/************************************************************************
 51 *  Floating-point to Unsigned Fixed-point Converts with Truncation	*
 52 ************************************************************************/
 53
 54/*
 55 *  Convert single floating-point to single fixed-point format
 56 *  with truncated result
 57 */
 58/*ARGSUSED*/
 59int
 60sgl_to_sgl_fcnvfut (sgl_floating_point * srcptr, unsigned int *nullptr,
 61		    unsigned int *dstptr, unsigned int *status)
 62{
 63	register unsigned int src, result;
 64	register int src_exponent;
 65
 66	src = *srcptr;
 67	src_exponent = Sgl_exponent(src) - SGL_BIAS;
 68
 69	/* 
 70	 * Test for overflow
 71	 */
 72	if (src_exponent > SGL_FX_MAX_EXP + 1) {
 73		if (Sgl_isone_sign(src)) {
 74			result = 0;
 75		} else {
 76			result = 0xffffffff;
 77		}
 78		if (Is_invalidtrap_enabled()) {
 79			return(INVALIDEXCEPTION);
 80		}
 81		Set_invalidflag();
 82		*dstptr = result;
 83		return(NOEXCEPTION);
 84	}
 85	/*
 86	 * Generate result
 87	 */
 88	if (src_exponent >= 0) {
 89		/* 
 90		 * Check sign.
 91		 * If negative, trap unimplemented.
 92		 */
 93		if (Sgl_isone_sign(src)) {
 94			result = 0;
 95			if (Is_invalidtrap_enabled()) {
 96				return(INVALIDEXCEPTION);
 97			}
 98			Set_invalidflag();
 99			*dstptr = result;
100			return(NOEXCEPTION);
101		}
102		Sgl_clear_signexponent_set_hidden(src);
103		Suint_from_sgl_mantissa(src,src_exponent,result);
104		*dstptr = result;
105
106		/* check for inexact */
107		if (Sgl_isinexact_to_unsigned(src,src_exponent)) {
108			if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
109			else Set_inexactflag();
110		}
111	}
112	else {
113		*dstptr = 0;
114
115		/* check for inexact */
116		if (Sgl_isnotzero_exponentmantissa(src)) {
117			if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
118			else Set_inexactflag();
119		}
120	}
121	return(NOEXCEPTION);
122}
123
124/*
125 *  Single Floating-point to Double Unsigned Fixed 
126 */
127/*ARGSUSED*/
128int
129sgl_to_dbl_fcnvfut (sgl_floating_point * srcptr, unsigned int *nullptr,
130		    dbl_unsigned * dstptr, unsigned int *status)
131{
132	register int src_exponent;
133	register unsigned int src, resultp1, resultp2;
134
135	src = *srcptr;
136	src_exponent = Sgl_exponent(src) - SGL_BIAS;
137
138	/* 
139	 * Test for overflow
140	 */
141	if (src_exponent > DBL_FX_MAX_EXP + 1) {
142		if (Sgl_isone_sign(src)) {
143			resultp1 = resultp2 = 0;
144		} else {
145			resultp1 = resultp2 = 0xffffffff;
146		}
147		if (Is_invalidtrap_enabled()) {
148			return(INVALIDEXCEPTION);
149		}
150		Set_invalidflag();
151    		Duint_copytoptr(resultp1,resultp2,dstptr);
152		return(NOEXCEPTION);
153	}
154	/*
155	 * Generate result
156	 */
157	if (src_exponent >= 0) {
158		/* 
159		 * Check sign.
160		 * If negative, trap unimplemented.
161		 */
162		if (Sgl_isone_sign(src)) {
163			resultp1 = resultp2 = 0;
164			if (Is_invalidtrap_enabled()) {
165				return(INVALIDEXCEPTION);
166			}
167			Set_invalidflag();
168    			Duint_copytoptr(resultp1,resultp2,dstptr);
169			return(NOEXCEPTION);
170		}
171		Sgl_clear_signexponent_set_hidden(src);
172		Duint_from_sgl_mantissa(src,src_exponent,resultp1,resultp2);
173		Duint_copytoptr(resultp1,resultp2,dstptr);
174
175		/* check for inexact */
176		if (Sgl_isinexact_to_unsigned(src,src_exponent)) {
177			if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
178			else Set_inexactflag();
179		}
180	}
181	else {
182		Duint_setzero(resultp1,resultp2);
183		Duint_copytoptr(resultp1,resultp2,dstptr);
184
185		/* check for inexact */
186		if (Sgl_isnotzero_exponentmantissa(src)) {
187			if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
188			else Set_inexactflag();
189		}
190	}
191	return(NOEXCEPTION);
192}
193
194/*
195 *  Double Floating-point to Single Unsigned Fixed 
196 */
197/*ARGSUSED*/
198int
199dbl_to_sgl_fcnvfut (dbl_floating_point * srcptr, unsigned int *nullptr,
200		    unsigned int *dstptr, unsigned int *status)
201{
202	register unsigned int srcp1, srcp2, result;
203	register int src_exponent;
204
205	Dbl_copyfromptr(srcptr,srcp1,srcp2);
206	src_exponent = Dbl_exponent(srcp1) - DBL_BIAS;
207
208	/* 
209	 * Test for overflow
210	 */
211	if (src_exponent > SGL_FX_MAX_EXP + 1) {
212		if (Dbl_isone_sign(srcp1)) {
213			result = 0;
214		} else {
215			result = 0xffffffff;
216		}
217		if (Is_invalidtrap_enabled()) {
218			return(INVALIDEXCEPTION);
219		}
220		Set_invalidflag();
221		*dstptr = result;
222		return(NOEXCEPTION);
223	}
224	/*
225	 * Generate result
226	 */
227	if (src_exponent >= 0) {
228		/* 
229		 * Check sign.
230		 * If negative, trap unimplemented.
231		 */
232		if (Dbl_isone_sign(srcp1)) {
233			result = 0;
234			if (Is_invalidtrap_enabled()) {
235				return(INVALIDEXCEPTION);
236			}
237			Set_invalidflag();
238			*dstptr = result;
239			return(NOEXCEPTION);
240		}
241		Dbl_clear_signexponent_set_hidden(srcp1);
242		Suint_from_dbl_mantissa(srcp1,srcp2,src_exponent,result);
243		*dstptr = result;
244
245		/* check for inexact */
246		if (Dbl_isinexact_to_unsigned(srcp1,srcp2,src_exponent)) {
247			if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
248			else Set_inexactflag();
249		}
250	}
251	else {
252		*dstptr = 0;
253
254		/* check for inexact */
255		if (Dbl_isnotzero_exponentmantissa(srcp1,srcp2)) {
256			if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
257			else Set_inexactflag();
258		}
259	}
260	return(NOEXCEPTION);
261}
262
263/*
264 *  Double Floating-point to Double Unsigned Fixed 
265 */
266/*ARGSUSED*/
267int
268dbl_to_dbl_fcnvfut (dbl_floating_point * srcptr, unsigned int *nullptr,
269		    dbl_unsigned * dstptr, unsigned int *status)
270{
271	register int src_exponent;
272	register unsigned int srcp1, srcp2, resultp1, resultp2;
273
274	Dbl_copyfromptr(srcptr,srcp1,srcp2);
275	src_exponent = Dbl_exponent(srcp1) - DBL_BIAS;
276
277	/* 
278	 * Test for overflow
279	 */
280	if (src_exponent > DBL_FX_MAX_EXP + 1) {
281		if (Dbl_isone_sign(srcp1)) {
282			resultp1 = resultp2 = 0;
283		} else {
284			resultp1 = resultp2 = 0xffffffff;
285		}
286		if (Is_invalidtrap_enabled()) {
287			return(INVALIDEXCEPTION);
288		}
289		Set_invalidflag();
290    		Duint_copytoptr(resultp1,resultp2,dstptr);
291		return(NOEXCEPTION);
292	}
293	/*
294	 * Generate result
295	 */
296	if (src_exponent >= 0) {
297		/* 
298		 * Check sign.
299		 * If negative, trap unimplemented.
300		 */
301		if (Dbl_isone_sign(srcp1)) {
302			resultp1 = resultp2 = 0;
303			if (Is_invalidtrap_enabled()) {
304				return(INVALIDEXCEPTION);
305			}
306			Set_invalidflag();
307    			Duint_copytoptr(resultp1,resultp2,dstptr);
308			return(NOEXCEPTION);
309		}
310		Dbl_clear_signexponent_set_hidden(srcp1);
311		Duint_from_dbl_mantissa(srcp1,srcp2,src_exponent,
312		  resultp1,resultp2);
313		Duint_copytoptr(resultp1,resultp2,dstptr);
314
315		/* check for inexact */
316		if (Dbl_isinexact_to_unsigned(srcp1,srcp2,src_exponent)) {
317			if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
318			else Set_inexactflag();
319		}
320	}
321	else {
322		Duint_setzero(resultp1,resultp2);
323		Duint_copytoptr(resultp1,resultp2,dstptr);
324
325		/* check for inexact */
326		if (Dbl_isnotzero_exponentmantissa(srcp1,srcp2)) {
327			if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
328			else Set_inexactflag();
329		}
330	}
331	return(NOEXCEPTION);
332}