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/fcnvfu.c		$Revision: 1.1 $
26 *
27 *  Purpose:
28 *	Floating-point to Unsigned Fixed-point Converts
29 *
30 *  External Interfaces:
31 *	dbl_to_dbl_fcnvfu(srcptr,nullptr,dstptr,status)
32 *	dbl_to_sgl_fcnvfu(srcptr,nullptr,dstptr,status)
33 *	sgl_to_dbl_fcnvfu(srcptr,nullptr,dstptr,status)
34 *	sgl_to_sgl_fcnvfu(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			*
52 ************************************************************************/
53
54/*
55 *  Single Floating-point to Single Unsigned Fixed
56 */
57/*ARGSUSED*/
58int
59sgl_to_sgl_fcnvfu(
60			sgl_floating_point *srcptr,
61			unsigned int *nullptr,
62			unsigned int *dstptr,
63			unsigned int *status)
64{
65	register unsigned int src, result;
66	register int src_exponent;
67	register boolean inexact = FALSE;
68
69	src = *srcptr;
70	src_exponent = Sgl_exponent(src) - SGL_BIAS;
71
72	/*
73	 * Test for overflow
74	 */
75	if (src_exponent > SGL_FX_MAX_EXP + 1) {
76		if (Sgl_isone_sign(src)) {
77			result = 0;
78		} else {
79			result = 0xffffffff;
80		}
81		if (Is_invalidtrap_enabled()) {
82			return(INVALIDEXCEPTION);
83		}
84		Set_invalidflag();
85		*dstptr = result;
86		return(NOEXCEPTION);
87	}
88	/*
89	 * Generate result
90	 */
91	if (src_exponent >= 0) {
92		/*
93		 * Check sign.
94		 * If negative, trap unimplemented.
95		 */
96		if (Sgl_isone_sign(src)) {
97			result = 0;
98			if (Is_invalidtrap_enabled()) {
99				return(INVALIDEXCEPTION);
100			}
101			Set_invalidflag();
102			*dstptr = result;
103			return(NOEXCEPTION);
104		}
105		Sgl_clear_signexponent_set_hidden(src);
106		Suint_from_sgl_mantissa(src,src_exponent,result);
107
108		/* check for inexact */
109		if (Sgl_isinexact_to_unsigned(src,src_exponent)) {
110			inexact = TRUE;
111			/*  round result  */
112			switch (Rounding_mode()) {
113			case ROUNDPLUS:
114				result++;
115				break;
116			case ROUNDMINUS: /* never negative */
117				break;
118			case ROUNDNEAREST:
119				if (Sgl_isone_roundbit(src,src_exponent) &&
120				    (Sgl_isone_stickybit(src,src_exponent) ||
121				     (result & 1))) {
122			     		result++;
123				}
124				break;
125			}
126		}
127	} else {
128		result = 0;
129
130		/* check for inexact */
131		if (Sgl_isnotzero_exponentmantissa(src)) {
132			inexact = TRUE;
133			/*  round result  */
134			switch (Rounding_mode()) {
135			case ROUNDPLUS:
136				if (Sgl_iszero_sign(src)) {
137					result++;
138				}
139				break;
140			case ROUNDMINUS:
141				if (Sgl_isone_sign(src)) {
142					result = 0;
143					if (Is_invalidtrap_enabled()) {
144						return(INVALIDEXCEPTION);
145					}
146					Set_invalidflag();
147					inexact = FALSE;
148				}
149				break;
150			case ROUNDNEAREST:
151				if (src_exponent == -1 &&
152				    Sgl_isnotzero_mantissa(src)) {
153					if (Sgl_isone_sign(src)) {
154						result = 0;
155						if (Is_invalidtrap_enabled()) {
156							return(INVALIDEXCEPTION);
157						}
158						Set_invalidflag();
159						inexact = FALSE;
160					}
161			      		else result++;
162				}
163				break;
164			}
165		}
166	}
167	*dstptr = result;
168	if (inexact) {
169		if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
170		else Set_inexactflag();
171	}
172	return(NOEXCEPTION);
173}
174
175/*
176 *  Single Floating-point to Double Unsigned Fixed
177 */
178/*ARGSUSED*/
179int
180sgl_to_dbl_fcnvfu(
181		    sgl_floating_point *srcptr,
182		    unsigned int *nullptr,
183		    dbl_unsigned *dstptr,
184		    unsigned int *status)
185{
186	register int src_exponent;
187	register unsigned int src, resultp1, resultp2;
188	register boolean inexact = FALSE;
189
190	src = *srcptr;
191	src_exponent = Sgl_exponent(src) - SGL_BIAS;
192
193	/*
194	 * Test for overflow
195	 */
196	if (src_exponent > DBL_FX_MAX_EXP + 1) {
197		if (Sgl_isone_sign(src)) {
198			resultp1 = resultp2 = 0;
199		} else {
200			resultp1 = resultp2 = 0xffffffff;
201		}
202		if (Is_invalidtrap_enabled()) {
203			return(INVALIDEXCEPTION);
204		}
205		Set_invalidflag();
206    		Duint_copytoptr(resultp1,resultp2,dstptr);
207		return(NOEXCEPTION);
208	}
209	/*
210	 * Generate result
211	 */
212	if (src_exponent >= 0) {
213		/*
214		 * Check sign.
215		 * If negative, trap unimplemented.
216		 */
217		if (Sgl_isone_sign(src)) {
218			resultp1 = resultp2 = 0;
219			if (Is_invalidtrap_enabled()) {
220				return(INVALIDEXCEPTION);
221			}
222			Set_invalidflag();
223    			Duint_copytoptr(resultp1,resultp2,dstptr);
224			return(NOEXCEPTION);
225		}
226		Sgl_clear_signexponent_set_hidden(src);
227		Duint_from_sgl_mantissa(src,src_exponent,resultp1,resultp2);
228
229		/* check for inexact */
230		if (Sgl_isinexact_to_unsigned(src,src_exponent)) {
231			inexact = TRUE;
232			/*  round result  */
233			switch (Rounding_mode()) {
234			case ROUNDPLUS:
235				Duint_increment(resultp1,resultp2);
236				break;
237			case ROUNDMINUS: /* never negative */
238				break;
239			case ROUNDNEAREST:
240				if (Sgl_isone_roundbit(src,src_exponent) &&
241				    (Sgl_isone_stickybit(src,src_exponent) ||
242				     Duint_isone_lowp2(resultp2))) {
243					Duint_increment(resultp1,resultp2);
244				}
245				break;
246			}
247		}
248	} else {
249		Duint_setzero(resultp1,resultp2);
250
251		/* check for inexact */
252		if (Sgl_isnotzero_exponentmantissa(src)) {
253			inexact = TRUE;
254			/*  round result  */
255			switch (Rounding_mode()) {
256			case ROUNDPLUS:
257				if (Sgl_iszero_sign(src)) {
258					Duint_increment(resultp1,resultp2);
259				}
260				break;
261			case ROUNDMINUS:
262				if (Sgl_isone_sign(src)) {
263					resultp1 = resultp2 = 0;
264					if (Is_invalidtrap_enabled()) {
265						return(INVALIDEXCEPTION);
266					}
267					Set_invalidflag();
268					inexact = FALSE;
269				}
270				break;
271			case ROUNDNEAREST:
272				if (src_exponent == -1 &&
273				    Sgl_isnotzero_mantissa(src)) {
274					if (Sgl_isone_sign(src)) {
275						resultp1 = 0;
276						resultp2 = 0;
277						if (Is_invalidtrap_enabled()) {
278							return(INVALIDEXCEPTION);
279						}
280						Set_invalidflag();
281						inexact = FALSE;
282					}
283					else Duint_increment(resultp1,resultp2);
284				}
285			}
286		}
287	}
288	Duint_copytoptr(resultp1,resultp2,dstptr);
289	if (inexact) {
290		if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
291		else Set_inexactflag();
292	}
293	return(NOEXCEPTION);
294}
295
296/*
297 *  Double Floating-point to Single Unsigned Fixed
298 */
299/*ARGSUSED*/
300int
301dbl_to_sgl_fcnvfu (dbl_floating_point * srcptr, unsigned int *nullptr,
302		   unsigned int *dstptr, unsigned int *status)
303{
304	register unsigned int srcp1, srcp2, result;
305	register int src_exponent;
306	register boolean inexact = FALSE;
307
308	Dbl_copyfromptr(srcptr,srcp1,srcp2);
309	src_exponent = Dbl_exponent(srcp1) - DBL_BIAS;
310
311	/*
312	 * Test for overflow
313	 */
314	if (src_exponent > SGL_FX_MAX_EXP + 1) {
315		if (Dbl_isone_sign(srcp1)) {
316			result = 0;
317		} else {
318			result = 0xffffffff;
319		}
320		if (Is_invalidtrap_enabled()) {
321			return(INVALIDEXCEPTION);
322		}
323		Set_invalidflag();
324		*dstptr = result;
325		return(NOEXCEPTION);
326	}
327	/*
328	 * Generate result
329	 */
330	if (src_exponent >= 0) {
331		/*
332		 * Check sign.
333		 * If negative, trap unimplemented.
334		 */
335		if (Dbl_isone_sign(srcp1)) {
336			result = 0;
337			if (Is_invalidtrap_enabled()) {
338				return(INVALIDEXCEPTION);
339			}
340			Set_invalidflag();
341			*dstptr = result;
342			return(NOEXCEPTION);
343		}
344		Dbl_clear_signexponent_set_hidden(srcp1);
345		Suint_from_dbl_mantissa(srcp1,srcp2,src_exponent,result);
346
347		/* check for inexact */
348		if (Dbl_isinexact_to_unsigned(srcp1,srcp2,src_exponent)) {
349			inexact = TRUE;
350			/*  round result  */
351			switch (Rounding_mode()) {
352			case ROUNDPLUS:
353			     result++;
354			     break;
355			case ROUNDMINUS: /* never negative */
356			     break;
357			case ROUNDNEAREST:
358			     if(Dbl_isone_roundbit(srcp1,srcp2,src_exponent) &&
359				(Dbl_isone_stickybit(srcp1,srcp2,src_exponent)||
360				 result&1))
361				   result++;
362			     break;
363			}
364			/* check for overflow */
365			if (result == 0) {
366				result = 0xffffffff;
367				if (Is_invalidtrap_enabled()) {
368					return(INVALIDEXCEPTION);
369				}
370				Set_invalidflag();
371				*dstptr = result;
372				return(NOEXCEPTION);
373			}
374		}
375	} else {
376		result = 0;
377
378		/* check for inexact */
379		if (Dbl_isnotzero_exponentmantissa(srcp1,srcp2)) {
380			inexact = TRUE;
381			/*  round result  */
382			switch (Rounding_mode()) {
383			case ROUNDPLUS:
384				if (Dbl_iszero_sign(srcp1)) result++;
385				break;
386			case ROUNDMINUS:
387				if (Dbl_isone_sign(srcp1)) {
388					result = 0;
389					if (Is_invalidtrap_enabled()) {
390						return(INVALIDEXCEPTION);
391					}
392					Set_invalidflag();
393					inexact = FALSE;
394				}
395				break;
396			case ROUNDNEAREST:
397				if (src_exponent == -1 &&
398				    Dbl_isnotzero_mantissa(srcp1,srcp2))
399					if (Dbl_isone_sign(srcp1)) {
400						result = 0;
401						if (Is_invalidtrap_enabled()) {
402							return(INVALIDEXCEPTION);
403						}
404						Set_invalidflag();
405						inexact = FALSE;
406					}
407					else result++;
408			}
409		}
410	}
411	*dstptr = result;
412	if (inexact) {
413		if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
414		else Set_inexactflag();
415	}
416	return(NOEXCEPTION);
417}
418
419/*
420 *  Double Floating-point to Double Unsigned Fixed
421 */
422/*ARGSUSED*/
423int
424dbl_to_dbl_fcnvfu (dbl_floating_point * srcptr, unsigned int *nullptr,
425		   dbl_unsigned * dstptr, unsigned int *status)
426{
427	register int src_exponent;
428	register unsigned int srcp1, srcp2, resultp1, resultp2;
429	register boolean inexact = FALSE;
430
431	Dbl_copyfromptr(srcptr,srcp1,srcp2);
432	src_exponent = Dbl_exponent(srcp1) - DBL_BIAS;
433
434	/*
435	 * Test for overflow
436	 */
437	if (src_exponent > DBL_FX_MAX_EXP + 1) {
438		if (Dbl_isone_sign(srcp1)) {
439			resultp1 = resultp2 = 0;
440		} else {
441			resultp1 = resultp2 = 0xffffffff;
442		}
443		if (Is_invalidtrap_enabled()) {
444			return(INVALIDEXCEPTION);
445		}
446		Set_invalidflag();
447    		Duint_copytoptr(resultp1,resultp2,dstptr);
448		return(NOEXCEPTION);
449	}
450
451	/*
452	 * Generate result
453	 */
454	if (src_exponent >= 0) {
455		/*
456		 * Check sign.
457		 * If negative, trap unimplemented.
458		 */
459		if (Dbl_isone_sign(srcp1)) {
460			resultp1 = resultp2 = 0;
461			if (Is_invalidtrap_enabled()) {
462				return(INVALIDEXCEPTION);
463			}
464			Set_invalidflag();
465    			Duint_copytoptr(resultp1,resultp2,dstptr);
466			return(NOEXCEPTION);
467		}
468		Dbl_clear_signexponent_set_hidden(srcp1);
469		Duint_from_dbl_mantissa(srcp1,srcp2,src_exponent,resultp1,
470		  resultp2);
471
472		/* check for inexact */
473		if (Dbl_isinexact_to_unsigned(srcp1,srcp2,src_exponent)) {
474			inexact = TRUE;
475			/*  round result  */
476			switch (Rounding_mode()) {
477			case ROUNDPLUS:
478				Duint_increment(resultp1,resultp2);
479				break;
480			case ROUNDMINUS: /* never negative */
481				break;
482			case ROUNDNEAREST:
483				if(Dbl_isone_roundbit(srcp1,srcp2,src_exponent))
484				  if(Dbl_isone_stickybit(srcp1,srcp2,src_exponent) ||
485				     Duint_isone_lowp2(resultp2))
486					Duint_increment(resultp1,resultp2);
487			}
488		}
489	} else {
490		Duint_setzero(resultp1,resultp2);
491
492		/* check for inexact */
493		if (Dbl_isnotzero_exponentmantissa(srcp1,srcp2)) {
494			inexact = TRUE;
495			/*  round result  */
496			switch (Rounding_mode()) {
497			case ROUNDPLUS:
498				if (Dbl_iszero_sign(srcp1)) {
499					Duint_increment(resultp1,resultp2);
500				}
501				break;
502			case ROUNDMINUS:
503				if (Dbl_isone_sign(srcp1)) {
504					resultp1 = resultp2 = 0;
505					if (Is_invalidtrap_enabled()) {
506						return(INVALIDEXCEPTION);
507					}
508					Set_invalidflag();
509					inexact = FALSE;
510				}
511				break;
512			case ROUNDNEAREST:
513				if (src_exponent == -1 &&
514				    Dbl_isnotzero_mantissa(srcp1,srcp2))
515					if (Dbl_iszero_sign(srcp1)) {
516						Duint_increment(resultp1,resultp2);
517					} else {
518						resultp1 = 0;
519						resultp2 = 0;
520						if (Is_invalidtrap_enabled()) {
521							return(INVALIDEXCEPTION);
522						}
523						Set_invalidflag();
524						inexact = FALSE;
525					}
526			}
527		}
528	}
529	Duint_copytoptr(resultp1,resultp2,dstptr);
530	if (inexact) {
531		if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
532		else Set_inexactflag();
533	}
534	return(NOEXCEPTION);
535}
536
537