PageRenderTime 53ms CodeModel.GetById 9ms app.highlight 39ms RepoModel.GetById 1ms app.codeStats 0ms

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

https://github.com/aicjofs/android_kernel_lge_v500_20d
C | 501 lines | 368 code | 27 blank | 106 comment | 131 complexity | 7b7fcdc472d2ca7e3c3732a6129ea05c 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/fcnvfx.c		$Revision: 1.1 $
 26 *
 27 *  Purpose:
 28 *	Single Floating-point to Single Fixed-point
 29 *	Single Floating-point to Double Fixed-point 
 30 *	Double Floating-point to Single Fixed-point 
 31 *	Double Floating-point to Double Fixed-point 
 32 *
 33 *  External Interfaces:
 34 *	dbl_to_dbl_fcnvfx(srcptr,nullptr,dstptr,status)
 35 *	dbl_to_sgl_fcnvfx(srcptr,nullptr,dstptr,status)
 36 *	sgl_to_dbl_fcnvfx(srcptr,nullptr,dstptr,status)
 37 *	sgl_to_sgl_fcnvfx(srcptr,nullptr,dstptr,status)
 38 *
 39 *  Internal Interfaces:
 40 *
 41 *  Theory:
 42 *	<<please update with a overview of the operation of this file>>
 43 *
 44 * END_DESC
 45*/
 46
 47
 48#include "float.h"
 49#include "sgl_float.h"
 50#include "dbl_float.h"
 51#include "cnv_float.h"
 52
 53/*
 54 *  Single Floating-point to Single Fixed-point 
 55 */
 56/*ARGSUSED*/
 57int
 58sgl_to_sgl_fcnvfx(
 59		    sgl_floating_point *srcptr,
 60		    sgl_floating_point *nullptr,
 61		    int *dstptr,
 62		    sgl_floating_point *status)
 63{
 64	register unsigned int src, temp;
 65	register int src_exponent, result;
 66	register boolean inexact = FALSE;
 67
 68	src = *srcptr;
 69	src_exponent = Sgl_exponent(src) - SGL_BIAS;
 70
 71	/* 
 72	 * Test for overflow
 73	 */
 74	if (src_exponent > SGL_FX_MAX_EXP) {
 75		/* check for MININT */
 76		if ((src_exponent > SGL_FX_MAX_EXP + 1) || 
 77		Sgl_isnotzero_mantissa(src) || Sgl_iszero_sign(src)) {
 78                        if (Sgl_iszero_sign(src)) result = 0x7fffffff;
 79                        else result = 0x80000000; 
 80
 81	                if (Is_invalidtrap_enabled()) {
 82                            return(INVALIDEXCEPTION);
 83                        }
 84                        Set_invalidflag();
 85			*dstptr = result;
 86			return(NOEXCEPTION);
 87       		}
 88	}
 89	/*
 90	 * Generate result
 91	 */
 92	if (src_exponent >= 0) {
 93		temp = src;
 94		Sgl_clear_signexponent_set_hidden(temp);
 95		Int_from_sgl_mantissa(temp,src_exponent);
 96		if (Sgl_isone_sign(src))  result = -Sgl_all(temp);
 97		else result = Sgl_all(temp);
 98
 99		/* check for inexact */
100		if (Sgl_isinexact_to_fix(src,src_exponent)) {
101			inexact = TRUE;
102			/*  round result  */
103			switch (Rounding_mode()) {
104			case ROUNDPLUS:
105			     if (Sgl_iszero_sign(src)) result++;
106			     break;
107			case ROUNDMINUS:
108			     if (Sgl_isone_sign(src)) result--;
109			     break;
110			case ROUNDNEAREST:
111			     if (Sgl_isone_roundbit(src,src_exponent)) {
112			        if (Sgl_isone_stickybit(src,src_exponent) 
113				|| (Sgl_isone_lowmantissa(temp)))
114			           if (Sgl_iszero_sign(src)) result++;
115			           else result--;
116			     }
117			} 
118		}
119	}
120	else {
121		result = 0;
122
123		/* check for inexact */
124		if (Sgl_isnotzero_exponentmantissa(src)) {
125			inexact = TRUE;
126			/*  round result  */
127			switch (Rounding_mode()) {
128			case ROUNDPLUS:
129			     if (Sgl_iszero_sign(src)) result++;
130			     break;
131			case ROUNDMINUS:
132			     if (Sgl_isone_sign(src)) result--;
133			     break;
134			case ROUNDNEAREST:
135			     if (src_exponent == -1)
136			        if (Sgl_isnotzero_mantissa(src))
137			           if (Sgl_iszero_sign(src)) result++;
138			           else result--;
139			} 
140		}
141	}
142	*dstptr = result;
143	if (inexact) {
144		if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
145		else Set_inexactflag();
146	}
147	return(NOEXCEPTION);
148}
149
150/*
151 *  Single Floating-point to Double Fixed-point 
152 */
153/*ARGSUSED*/
154int
155sgl_to_dbl_fcnvfx(
156		sgl_floating_point *srcptr,
157		unsigned int *nullptr,
158		dbl_integer *dstptr,
159		unsigned int *status)
160{
161	register int src_exponent, resultp1;
162	register unsigned int src, temp, resultp2;
163	register boolean inexact = FALSE;
164
165	src = *srcptr;
166	src_exponent = Sgl_exponent(src) - SGL_BIAS;
167
168	/* 
169	 * Test for overflow
170	 */
171	if (src_exponent > DBL_FX_MAX_EXP) {
172		/* check for MININT */
173		if ((src_exponent > DBL_FX_MAX_EXP + 1) || 
174		Sgl_isnotzero_mantissa(src) || Sgl_iszero_sign(src)) {
175                        if (Sgl_iszero_sign(src)) {
176                              resultp1 = 0x7fffffff;
177			      resultp2 = 0xffffffff;
178			}
179                        else {
180			    resultp1 = 0x80000000; 
181			    resultp2 = 0;
182			}
183	                if (Is_invalidtrap_enabled()) {
184                            return(INVALIDEXCEPTION);
185                        }
186                        Set_invalidflag();
187    		        Dint_copytoptr(resultp1,resultp2,dstptr);
188			return(NOEXCEPTION);
189		}
190		Dint_set_minint(resultp1,resultp2);
191		Dint_copytoptr(resultp1,resultp2,dstptr);
192		return(NOEXCEPTION);
193	}
194	/*
195	 * Generate result
196	 */
197	if (src_exponent >= 0) {
198		temp = src;
199		Sgl_clear_signexponent_set_hidden(temp);
200		Dint_from_sgl_mantissa(temp,src_exponent,resultp1,resultp2);
201		if (Sgl_isone_sign(src)) {
202			Dint_setone_sign(resultp1,resultp2);
203		}
204
205		/* check for inexact */
206		if (Sgl_isinexact_to_fix(src,src_exponent)) {
207			inexact = TRUE;
208                        /*  round result  */
209                        switch (Rounding_mode()) {
210                        case ROUNDPLUS:
211                             if (Sgl_iszero_sign(src)) {
212				Dint_increment(resultp1,resultp2);
213			     }
214                             break;
215                        case ROUNDMINUS:
216                             if (Sgl_isone_sign(src)) {
217				Dint_decrement(resultp1,resultp2);
218			     }
219                             break;
220                        case ROUNDNEAREST:
221                             if (Sgl_isone_roundbit(src,src_exponent))
222                                if (Sgl_isone_stickybit(src,src_exponent) || 
223				(Dint_isone_lowp2(resultp2)))
224				   if (Sgl_iszero_sign(src)) {
225				      Dint_increment(resultp1,resultp2);
226				   }
227                                   else {
228				      Dint_decrement(resultp1,resultp2);
229				   }
230                        }
231                }
232        }
233	else {
234		Dint_setzero(resultp1,resultp2);
235
236		/* check for inexact */
237		if (Sgl_isnotzero_exponentmantissa(src)) {
238			inexact = TRUE;
239                        /*  round result  */
240                        switch (Rounding_mode()) {
241                        case ROUNDPLUS:
242                             if (Sgl_iszero_sign(src)) {
243				Dint_increment(resultp1,resultp2);
244			     }
245                             break;
246                        case ROUNDMINUS:
247                             if (Sgl_isone_sign(src)) {
248				Dint_decrement(resultp1,resultp2);
249			     }
250                             break;
251                        case ROUNDNEAREST:
252                             if (src_exponent == -1)
253                                if (Sgl_isnotzero_mantissa(src))
254                                   if (Sgl_iszero_sign(src)) {
255				      Dint_increment(resultp1,resultp2);
256				   }
257                                   else {
258				      Dint_decrement(resultp1,resultp2);
259				   }
260			}
261		}
262	}
263	Dint_copytoptr(resultp1,resultp2,dstptr);
264	if (inexact) {
265		if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
266		else Set_inexactflag();
267	}
268	return(NOEXCEPTION);
269}
270
271/*
272 *  Double Floating-point to Single Fixed-point 
273 */
274/*ARGSUSED*/
275int
276dbl_to_sgl_fcnvfx(
277		    dbl_floating_point *srcptr,
278		    unsigned int *nullptr,
279		    int *dstptr,
280		    unsigned int *status)
281{
282	register unsigned int srcp1,srcp2, tempp1,tempp2;
283	register int src_exponent, result;
284	register boolean inexact = FALSE;
285
286	Dbl_copyfromptr(srcptr,srcp1,srcp2);
287	src_exponent = Dbl_exponent(srcp1) - DBL_BIAS;
288
289	/* 
290	 * Test for overflow
291	 */
292	if (src_exponent > SGL_FX_MAX_EXP) {
293		/* check for MININT */
294		if (Dbl_isoverflow_to_int(src_exponent,srcp1,srcp2)) {
295                        if (Dbl_iszero_sign(srcp1)) result = 0x7fffffff;
296                        else result = 0x80000000; 
297
298	                if (Is_invalidtrap_enabled()) {
299                            return(INVALIDEXCEPTION);
300                        }
301                        Set_invalidflag();
302			*dstptr = result;
303			return(NOEXCEPTION);
304		}
305	}
306	/*
307	 * Generate result
308	 */
309	if (src_exponent >= 0) {
310		tempp1 = srcp1;
311		tempp2 = srcp2;
312		Dbl_clear_signexponent_set_hidden(tempp1);
313		Int_from_dbl_mantissa(tempp1,tempp2,src_exponent);
314		if (Dbl_isone_sign(srcp1) && (src_exponent <= SGL_FX_MAX_EXP))
315			result = -Dbl_allp1(tempp1);
316		else result = Dbl_allp1(tempp1);
317
318		/* check for inexact */
319		if (Dbl_isinexact_to_fix(srcp1,srcp2,src_exponent)) {
320                        inexact = TRUE;
321                        /*  round result  */
322                        switch (Rounding_mode()) {
323                        case ROUNDPLUS:
324                             if (Dbl_iszero_sign(srcp1)) result++;
325                             break;
326                        case ROUNDMINUS:
327                             if (Dbl_isone_sign(srcp1)) result--;
328                             break;
329                        case ROUNDNEAREST:
330                             if (Dbl_isone_roundbit(srcp1,srcp2,src_exponent))
331                                if (Dbl_isone_stickybit(srcp1,srcp2,src_exponent) || 
332				(Dbl_isone_lowmantissap1(tempp1)))
333                                   if (Dbl_iszero_sign(srcp1)) result++;
334                                   else result--;
335                        } 
336			/* check for overflow */
337			if ((Dbl_iszero_sign(srcp1) && result < 0) ||
338			    (Dbl_isone_sign(srcp1) && result > 0)) {
339			        
340                          if (Dbl_iszero_sign(srcp1)) result = 0x7fffffff;
341                          else result = 0x80000000; 
342
343	                  if (Is_invalidtrap_enabled()) {
344                            return(INVALIDEXCEPTION);
345                          }
346                          Set_invalidflag();
347			  *dstptr = result;
348			  return(NOEXCEPTION);
349			}
350                }
351	}
352	else {
353		result = 0;
354
355		/* check for inexact */
356		if (Dbl_isnotzero_exponentmantissa(srcp1,srcp2)) {
357                        inexact = TRUE;
358                        /*  round result  */
359                        switch (Rounding_mode()) {
360                        case ROUNDPLUS:
361                             if (Dbl_iszero_sign(srcp1)) result++;
362                             break;
363                        case ROUNDMINUS:
364                             if (Dbl_isone_sign(srcp1)) result--;
365                             break;
366                        case ROUNDNEAREST:
367                             if (src_exponent == -1)
368                                if (Dbl_isnotzero_mantissa(srcp1,srcp2))
369                                   if (Dbl_iszero_sign(srcp1)) result++;
370                                   else result--;
371			}
372                }
373	}
374	*dstptr = result;
375        if (inexact) {
376                if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
377		else Set_inexactflag();
378        }
379	return(NOEXCEPTION);
380}
381
382/*
383 *  Double Floating-point to Double Fixed-point 
384 */
385/*ARGSUSED*/
386int
387dbl_to_dbl_fcnvfx(
388		    dbl_floating_point *srcptr,
389		    unsigned int *nullptr,
390		    dbl_integer *dstptr,
391		    unsigned int *status)
392{
393	register int src_exponent, resultp1;
394	register unsigned int srcp1, srcp2, tempp1, tempp2, resultp2;
395	register boolean inexact = FALSE;
396
397	Dbl_copyfromptr(srcptr,srcp1,srcp2);
398	src_exponent = Dbl_exponent(srcp1) - DBL_BIAS;
399
400	/* 
401	 * Test for overflow
402	 */
403	if (src_exponent > DBL_FX_MAX_EXP) {
404		/* check for MININT */
405		if ((src_exponent > DBL_FX_MAX_EXP + 1) || 
406		Dbl_isnotzero_mantissa(srcp1,srcp2) || Dbl_iszero_sign(srcp1)) {
407                        if (Dbl_iszero_sign(srcp1)) {
408                              resultp1 = 0x7fffffff;
409			      resultp2 = 0xffffffff;
410			}
411                        else {
412			    resultp1 = 0x80000000; 
413			    resultp2 = 0;
414			}
415	                if (Is_invalidtrap_enabled()) {
416                            return(INVALIDEXCEPTION);
417                        }
418                        Set_invalidflag();
419    		        Dint_copytoptr(resultp1,resultp2,dstptr);
420			return(NOEXCEPTION);
421		}
422	}
423 
424	/*
425	 * Generate result
426	 */
427	if (src_exponent >= 0) {
428		tempp1 = srcp1;
429		tempp2 = srcp2;
430		Dbl_clear_signexponent_set_hidden(tempp1);
431		Dint_from_dbl_mantissa(tempp1,tempp2,src_exponent,resultp1,
432		resultp2);
433		if (Dbl_isone_sign(srcp1)) {
434			Dint_setone_sign(resultp1,resultp2);
435		}
436
437		/* check for inexact */
438		if (Dbl_isinexact_to_fix(srcp1,srcp2,src_exponent)) {
439                        inexact = TRUE;
440                        /*  round result  */
441                        switch (Rounding_mode()) {
442                        case ROUNDPLUS:
443                             if (Dbl_iszero_sign(srcp1)) {
444				Dint_increment(resultp1,resultp2);
445			     }
446                             break;
447                        case ROUNDMINUS:
448                             if (Dbl_isone_sign(srcp1)) {
449				Dint_decrement(resultp1,resultp2);
450			     }
451                             break;
452                        case ROUNDNEAREST:
453                             if (Dbl_isone_roundbit(srcp1,srcp2,src_exponent))
454                                if (Dbl_isone_stickybit(srcp1,srcp2,src_exponent) || 
455				(Dint_isone_lowp2(resultp2)))
456                                   if (Dbl_iszero_sign(srcp1)) {
457				      Dint_increment(resultp1,resultp2);
458				   }
459                                   else {
460				      Dint_decrement(resultp1,resultp2);
461				   }
462                        } 
463                }
464	}
465	else {
466		Dint_setzero(resultp1,resultp2);
467
468		/* check for inexact */
469		if (Dbl_isnotzero_exponentmantissa(srcp1,srcp2)) {
470                        inexact = TRUE;
471                        /*  round result  */
472                        switch (Rounding_mode()) {
473                        case ROUNDPLUS:
474                             if (Dbl_iszero_sign(srcp1)) {
475				Dint_increment(resultp1,resultp2);
476			     }
477                             break;
478                        case ROUNDMINUS:
479                             if (Dbl_isone_sign(srcp1)) {
480				Dint_decrement(resultp1,resultp2);
481			     }
482                             break;
483                        case ROUNDNEAREST:
484                             if (src_exponent == -1)
485                                if (Dbl_isnotzero_mantissa(srcp1,srcp2))
486                                   if (Dbl_iszero_sign(srcp1)) {
487				      Dint_increment(resultp1,resultp2);
488				   }
489                                   else {
490				      Dint_decrement(resultp1,resultp2);
491				   }
492			}
493                }
494	}
495	Dint_copytoptr(resultp1,resultp2,dstptr);
496        if (inexact) {
497                if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
498        	else Set_inexactflag();
499        }
500	return(NOEXCEPTION);
501}