Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
fcnvfx.c
Go to the documentation of this 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) <[email protected]>
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*/
57 int
58 sgl_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*/
154 int
155 sgl_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*/
275 int
276 dbl_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*/
386 int
387 dbl_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 }
Generated on Thu Jan 10 2013 13:13:04 for Linux Kernel by   doxygen 1.8.2