1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
/* IEEE floating point support routines, for GDB, the GNU Debugger.
Copyright (C) 1991 Free Software Foundation, Inc.
This file is part of GDB.
GDB is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.
GDB is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GDB; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "defs.h"
#include "param.h"
#include "ieee-float.h"
#include <math.h> /* ldexp */
/* Convert an IEEE extended float to a double.
FROM is the address of the extended float.
Store the double in *TO. */
void
ieee_extended_to_double (ext_format, from, to)
struct ext_format *ext_format;
char *from;
double *to;
{
unsigned char *ufrom = (unsigned char *)from;
double dto;
unsigned long mant0, mant1, exp;
bcopy (&from[MANBYTE_H], &mant0, 4);
bcopy (&from[MANBYTE_L], &mant1, 4);
exp = ((ufrom[EXPBYTE_H] & (unsigned char)~SIGNMASK) << 8) | ufrom[EXPBYTE_L];
if (exp == EXT_EXP_NAN) {
/* We have a NaN source. */
dto = 0.123456789; /* Not much else useful to do */
} else if (exp == 0 && mant0 == 0 && mant1 == 0) {
dto = 0;
} else {
/* Build the result algebraically. Might go infinite, underflow, etc;
who cares. */
mant0 |= 0x80000000;
dto = ldexp ((double)mant0, exp - EXT_EXP_BIAS - 31);
dto += ldexp ((double)mant1, exp - EXT_EXP_BIAS - 31 - 32);
}
*to = dto;
}
/* The converse: convert the double *FROM to an extended float
and store where TO points. */
void
double_to_ieee_extended (ext_format, from, to)
struct ext_format *ext_format;
double *from;
char *to;
{
double dfrom = *from;
unsigned long twolongs[2];
unsigned long mant0, mant1, exp;
unsigned char twobytes[2];
bzero (to, TOTALSIZE);
if (dfrom == 0)
return; /* Result is zero */
if (dfrom != dfrom) {
/* From is NaN */
to[EXPBYTE_H] = (unsigned char)(EXT_EXP_NAN >> 8);
to[EXPBYTE_L] = (unsigned char)EXT_EXP_NAN;
to[MANBYTE_H] = 1; /* Be sure it's not infinity, but NaN value is irrel */
return; /* Result is NaN */
}
if (dfrom < 0)
to[SIGNBYTE] |= SIGNMASK; /* Set negative sign */
/* How to tell an infinity from an ordinary number? FIXME-someday */
/* The following code assumes that the host has IEEE doubles. FIXME-someday.
It also assumes longs are 32 bits! FIXME-someday. */
bcopy (from, twolongs, 8);
bcopy (from, twobytes, 2);
#if HOST_BYTE_ORDER == BIG_ENDIAN
exp = ((twobytes[1] & 0xF0) >> 4) | (twobytes[0] & 0x7F) << 4;
mant0 = (twolongs[0] << 11) | twolongs[1] >> 21;
mant1 = (twolongs[1] << 11);
#else
exp = ((twobytes[0] & 0xF0) >> 4) | (twobytes[1] & 0x7F) << 4;
mant0 = (twolongs[1] << 11) | twolongs[0] >> 21;
mant1 = (twolongs[0] << 11);
#endif
/* Fiddle with leading 1-bit, implied in double, explicit in extended. */
if (exp == 0)
mant0 &= 0x7FFFFFFF;
else
mant0 |= 0x80000000;
exp -= DBL_EXP_BIAS; /* Get integer exp */
exp += EXT_EXP_BIAS; /* Offset for extended *&/
/* OK, now store it in extended format. */
to[EXPBYTE_H] |= (unsigned char)(exp >> 8); /* Retain sign */
to[EXPBYTE_L] = (unsigned char) exp;
bcopy (&mant0, &to[MANBYTE_H], 4);
bcopy (&mant1, &to[MANBYTE_L], 4);
}
#ifdef DEBUG
/* Test some numbers to see that extended/double conversion works for them. */
ieee_test (n)
int n;
{
union { double d; int i[2]; } di;
double result;
int i;
char exten[16];
extern struct ext_format ext_format_68881;
for (i = 0; i < n; i++) {
di.i[0] = random();
di.i[1] = random();
double_to_ieee_extended (ext_format_68881, &di.d, exten);
ieee_extended_to_double (ext_format_68881, exten, &result);
if (di.d != result)
printf ("Differ: %x %x %g => %x %x %g\n", di.d, di.d, result, result);
}
}
#endif
|
