1 /* $NetBSD: xdr_float.c,v 1.23 2000/07/17 04:59:51 matt Exp $ */ 2 3 /* 4 * Sun RPC is a product of Sun Microsystems, Inc. and is provided for 5 * unrestricted use provided that this legend is included on all tape 6 * media and as a part of the software program in whole or part. Users 7 * may copy or modify Sun RPC without charge, but are not authorized 8 * to license or distribute it to anyone else except as part of a product or 9 * program developed by the user. 10 * 11 * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE 12 * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR 13 * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. 14 * 15 * Sun RPC is provided with no support and without any obligation on the 16 * part of Sun Microsystems, Inc. to assist in its use, correction, 17 * modification or enhancement. 18 * 19 * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE 20 * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC 21 * OR ANY PART THEREOF. 22 * 23 * In no event will Sun Microsystems, Inc. be liable for any lost revenue 24 * or profits or other special, indirect and consequential damages, even if 25 * Sun has been advised of the possibility of such damages. 26 * 27 * Sun Microsystems, Inc. 28 * 2550 Garcia Avenue 29 * Mountain View, California 94043 30 */ 31 32 #if defined(LIBC_SCCS) && !defined(lint) 33 static char *sccsid2 = "@(#)xdr_float.c 1.12 87/08/11 Copyr 1984 Sun Micro"; 34 static char *sccsid = "@(#)xdr_float.c 2.1 88/07/29 4.0 RPCSRC"; 35 #endif 36 #include <sys/cdefs.h> 37 __FBSDID("$FreeBSD$"); 38 39 /* 40 * xdr_float.c, Generic XDR routines implementation. 41 * 42 * Copyright (C) 1984, Sun Microsystems, Inc. 43 * 44 * These are the "floating point" xdr routines used to (de)serialize 45 * most common data items. See xdr.h for more info on the interface to 46 * xdr. 47 */ 48 49 #include "namespace.h" 50 #include <sys/types.h> 51 #include <sys/param.h> 52 53 #include <stdio.h> 54 55 #include <rpc/types.h> 56 #include <rpc/xdr.h> 57 #include "un-namespace.h" 58 59 /* 60 * NB: Not portable. 61 * This routine works on machines with IEEE754 FP and Vaxen. 62 */ 63 64 #if defined(__m68k__) || defined(__sparc__) || defined(__i386__) || \ 65 defined(__mips__) || defined(__ns32k__) || defined(__alpha__) || \ 66 defined(__arm__) || defined(__ppc__) || defined(__ia64__) || \ 67 defined(__arm26__) || defined(__sparc64__) || defined(__amd64__) 68 #include <machine/endian.h> 69 #define IEEEFP 70 #endif 71 72 #if defined(__vax__) 73 74 /* What IEEE single precision floating point looks like on a Vax */ 75 struct ieee_single { 76 unsigned int mantissa: 23; 77 unsigned int exp : 8; 78 unsigned int sign : 1; 79 }; 80 81 /* Vax single precision floating point */ 82 struct vax_single { 83 unsigned int mantissa1 : 7; 84 unsigned int exp : 8; 85 unsigned int sign : 1; 86 unsigned int mantissa2 : 16; 87 }; 88 89 #define VAX_SNG_BIAS 0x81 90 #define IEEE_SNG_BIAS 0x7f 91 92 static struct sgl_limits { 93 struct vax_single s; 94 struct ieee_single ieee; 95 } sgl_limits[2] = { 96 {{ 0x7f, 0xff, 0x0, 0xffff }, /* Max Vax */ 97 { 0x0, 0xff, 0x0 }}, /* Max IEEE */ 98 {{ 0x0, 0x0, 0x0, 0x0 }, /* Min Vax */ 99 { 0x0, 0x0, 0x0 }} /* Min IEEE */ 100 }; 101 #endif /* vax */ 102 103 bool_t 104 xdr_float(xdrs, fp) 105 XDR *xdrs; 106 float *fp; 107 { 108 #ifndef IEEEFP 109 struct ieee_single is; 110 struct vax_single vs, *vsp; 111 struct sgl_limits *lim; 112 int i; 113 #endif 114 switch (xdrs->x_op) { 115 116 case XDR_ENCODE: 117 #ifdef IEEEFP 118 return (XDR_PUTINT32(xdrs, (int32_t *)fp)); 119 #else 120 vs = *((struct vax_single *)fp); 121 for (i = 0, lim = sgl_limits; 122 i < sizeof(sgl_limits)/sizeof(struct sgl_limits); 123 i++, lim++) { 124 if ((vs.mantissa2 == lim->s.mantissa2) && 125 (vs.exp == lim->s.exp) && 126 (vs.mantissa1 == lim->s.mantissa1)) { 127 is = lim->ieee; 128 goto shipit; 129 } 130 } 131 is.exp = vs.exp - VAX_SNG_BIAS + IEEE_SNG_BIAS; 132 is.mantissa = (vs.mantissa1 << 16) | vs.mantissa2; 133 shipit: 134 is.sign = vs.sign; 135 return (XDR_PUTINT32(xdrs, (int32_t *)&is)); 136 #endif 137 138 case XDR_DECODE: 139 #ifdef IEEEFP 140 return (XDR_GETINT32(xdrs, (int32_t *)fp)); 141 #else 142 vsp = (struct vax_single *)fp; 143 if (!XDR_GETINT32(xdrs, (int32_t *)&is)) 144 return (FALSE); 145 for (i = 0, lim = sgl_limits; 146 i < sizeof(sgl_limits)/sizeof(struct sgl_limits); 147 i++, lim++) { 148 if ((is.exp == lim->ieee.exp) && 149 (is.mantissa == lim->ieee.mantissa)) { 150 *vsp = lim->s; 151 goto doneit; 152 } 153 } 154 vsp->exp = is.exp - IEEE_SNG_BIAS + VAX_SNG_BIAS; 155 vsp->mantissa2 = is.mantissa; 156 vsp->mantissa1 = (is.mantissa >> 16); 157 doneit: 158 vsp->sign = is.sign; 159 return (TRUE); 160 #endif 161 162 case XDR_FREE: 163 return (TRUE); 164 } 165 /* NOTREACHED */ 166 return (FALSE); 167 } 168 169 #if defined(__vax__) 170 /* What IEEE double precision floating point looks like on a Vax */ 171 struct ieee_double { 172 unsigned int mantissa1 : 20; 173 unsigned int exp : 11; 174 unsigned int sign : 1; 175 unsigned int mantissa2 : 32; 176 }; 177 178 /* Vax double precision floating point */ 179 struct vax_double { 180 unsigned int mantissa1 : 7; 181 unsigned int exp : 8; 182 unsigned int sign : 1; 183 unsigned int mantissa2 : 16; 184 unsigned int mantissa3 : 16; 185 unsigned int mantissa4 : 16; 186 }; 187 188 #define VAX_DBL_BIAS 0x81 189 #define IEEE_DBL_BIAS 0x3ff 190 #define MASK(nbits) ((1 << nbits) - 1) 191 192 static struct dbl_limits { 193 struct vax_double d; 194 struct ieee_double ieee; 195 } dbl_limits[2] = { 196 {{ 0x7f, 0xff, 0x0, 0xffff, 0xffff, 0xffff }, /* Max Vax */ 197 { 0x0, 0x7ff, 0x0, 0x0 }}, /* Max IEEE */ 198 {{ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, /* Min Vax */ 199 { 0x0, 0x0, 0x0, 0x0 }} /* Min IEEE */ 200 }; 201 202 #endif /* vax */ 203 204 205 bool_t 206 xdr_double(xdrs, dp) 207 XDR *xdrs; 208 double *dp; 209 { 210 #ifdef IEEEFP 211 int32_t *i32p; 212 bool_t rv; 213 #else 214 int32_t *lp; 215 struct ieee_double id; 216 struct vax_double vd; 217 struct dbl_limits *lim; 218 int i; 219 #endif 220 221 switch (xdrs->x_op) { 222 223 case XDR_ENCODE: 224 #ifdef IEEEFP 225 i32p = (int32_t *)(void *)dp; 226 #if BYTE_ORDER == BIG_ENDIAN 227 rv = XDR_PUTINT32(xdrs, i32p); 228 if (!rv) 229 return (rv); 230 rv = XDR_PUTINT32(xdrs, i32p+1); 231 #else 232 rv = XDR_PUTINT32(xdrs, i32p+1); 233 if (!rv) 234 return (rv); 235 rv = XDR_PUTINT32(xdrs, i32p); 236 #endif 237 return (rv); 238 #else 239 vd = *((struct vax_double *)dp); 240 for (i = 0, lim = dbl_limits; 241 i < sizeof(dbl_limits)/sizeof(struct dbl_limits); 242 i++, lim++) { 243 if ((vd.mantissa4 == lim->d.mantissa4) && 244 (vd.mantissa3 == lim->d.mantissa3) && 245 (vd.mantissa2 == lim->d.mantissa2) && 246 (vd.mantissa1 == lim->d.mantissa1) && 247 (vd.exp == lim->d.exp)) { 248 id = lim->ieee; 249 goto shipit; 250 } 251 } 252 id.exp = vd.exp - VAX_DBL_BIAS + IEEE_DBL_BIAS; 253 id.mantissa1 = (vd.mantissa1 << 13) | (vd.mantissa2 >> 3); 254 id.mantissa2 = ((vd.mantissa2 & MASK(3)) << 29) | 255 (vd.mantissa3 << 13) | 256 ((vd.mantissa4 >> 3) & MASK(13)); 257 shipit: 258 id.sign = vd.sign; 259 lp = (int32_t *)&id; 260 return (XDR_PUTINT32(xdrs, lp++) && XDR_PUTINT32(xdrs, lp)); 261 #endif 262 263 case XDR_DECODE: 264 #ifdef IEEEFP 265 i32p = (int32_t *)(void *)dp; 266 #if BYTE_ORDER == BIG_ENDIAN 267 rv = XDR_GETINT32(xdrs, i32p); 268 if (!rv) 269 return (rv); 270 rv = XDR_GETINT32(xdrs, i32p+1); 271 #else 272 rv = XDR_GETINT32(xdrs, i32p+1); 273 if (!rv) 274 return (rv); 275 rv = XDR_GETINT32(xdrs, i32p); 276 #endif 277 return (rv); 278 #else 279 lp = (int32_t *)&id; 280 if (!XDR_GETINT32(xdrs, lp++) || !XDR_GETINT32(xdrs, lp)) 281 return (FALSE); 282 for (i = 0, lim = dbl_limits; 283 i < sizeof(dbl_limits)/sizeof(struct dbl_limits); 284 i++, lim++) { 285 if ((id.mantissa2 == lim->ieee.mantissa2) && 286 (id.mantissa1 == lim->ieee.mantissa1) && 287 (id.exp == lim->ieee.exp)) { 288 vd = lim->d; 289 goto doneit; 290 } 291 } 292 vd.exp = id.exp - IEEE_DBL_BIAS + VAX_DBL_BIAS; 293 vd.mantissa1 = (id.mantissa1 >> 13); 294 vd.mantissa2 = ((id.mantissa1 & MASK(13)) << 3) | 295 (id.mantissa2 >> 29); 296 vd.mantissa3 = (id.mantissa2 >> 13); 297 vd.mantissa4 = (id.mantissa2 << 3); 298 doneit: 299 vd.sign = id.sign; 300 *dp = *((double *)&vd); 301 return (TRUE); 302 #endif 303 304 case XDR_FREE: 305 return (TRUE); 306 } 307 /* NOTREACHED */ 308 return (FALSE); 309 } 310