xref: /openbmc/qemu/libdecnumber/dpd/decimal128.c (revision 09125c5e)
1 /* Decimal 128-bit format module for the decNumber C Library.
2    Copyright (C) 2005, 2007 Free Software Foundation, Inc.
3    Contributed by IBM Corporation.  Author Mike Cowlishaw.
4 
5    This file is part of GCC.
6 
7    GCC is free software; you can redistribute it and/or modify it under
8    the terms of the GNU General Public License as published by the Free
9    Software Foundation; either version 2, or (at your option) any later
10    version.
11 
12    In addition to the permissions in the GNU General Public License,
13    the Free Software Foundation gives you unlimited permission to link
14    the compiled version of this file into combinations with other
15    programs, and to distribute those combinations without any
16    restriction coming from the use of this file.  (The General Public
17    License restrictions do apply in other respects; for example, they
18    cover modification of the file, and distribution when not linked
19    into a combine executable.)
20 
21    GCC is distributed in the hope that it will be useful, but WITHOUT ANY
22    WARRANTY; without even the implied warranty of MERCHANTABILITY or
23    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
24    for more details.
25 
26    You should have received a copy of the GNU General Public License
27    along with GCC; see the file COPYING.  If not, write to the Free
28    Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
29    02110-1301, USA.  */
30 
31 /* ------------------------------------------------------------------ */
32 /* Decimal 128-bit format module				      */
33 /* ------------------------------------------------------------------ */
34 /* This module comprises the routines for decimal128 format numbers.  */
35 /* Conversions are supplied to and from decNumber and String.	      */
36 /*								      */
37 /* This is used when decNumber provides operations, either for all    */
38 /* operations or as a proxy between decNumber and decSingle.	      */
39 /*								      */
40 /* Error handling is the same as decNumber (qv.).		      */
41 /* ------------------------------------------------------------------ */
42 #include "qemu/osdep.h"
43 
44 #include "libdecnumber/dconfig.h"
45 #define	 DECNUMDIGITS 34      /* make decNumbers with space for 34 */
46 #include "libdecnumber/decNumber.h"
47 #include "libdecnumber/decNumberLocal.h"
48 #include "libdecnumber/dpd/decimal128.h"
49 
50 /* Utility routines and tables [in decimal64.c] */
51 extern const uInt   COMBEXP[32], COMBMSD[32];
52 extern const uByte  BIN2CHAR[4001];
53 
54 extern void decDigitsFromDPD(decNumber *, const uInt *, Int);
55 extern void decDigitsToDPD(const decNumber *, uInt *, Int);
56 
57 #if DECTRACE || DECCHECK
58 void decimal128Show(const decimal128 *);	  /* for debug */
59 extern void decNumberShow(const decNumber *);	  /* .. */
60 #endif
61 
62 /* Useful macro */
63 /* Clear a structure (e.g., a decNumber) */
64 #define DEC_clear(d) memset(d, 0, sizeof(*d))
65 
66 /* ------------------------------------------------------------------ */
67 /* decimal128FromNumber -- convert decNumber to decimal128	      */
68 /*								      */
69 /*   ds is the target decimal128				      */
70 /*   dn is the source number (assumed valid)			      */
71 /*   set is the context, used only for reporting errors		      */
72 /*								      */
73 /* The set argument is used only for status reporting and for the     */
74 /* rounding mode (used if the coefficient is more than DECIMAL128_Pmax*/
75 /* digits or an overflow is detected).	If the exponent is out of the */
76 /* valid range then Overflow or Underflow will be raised.	      */
77 /* After Underflow a subnormal result is possible.		      */
78 /*								      */
79 /* DEC_Clamped is set if the number has to be 'folded down' to fit,   */
80 /* by reducing its exponent and multiplying the coefficient by a      */
81 /* power of ten, or if the exponent on a zero had to be clamped.      */
82 /* ------------------------------------------------------------------ */
decimal128FromNumber(decimal128 * d128,const decNumber * dn,decContext * set)83 decimal128 * decimal128FromNumber(decimal128 *d128, const decNumber *dn,
84 				  decContext *set) {
85   uInt status=0;		   /* status accumulator */
86   Int ae;			   /* adjusted exponent */
87   decNumber  dw;		   /* work */
88   decContext dc;		   /* .. */
89   uInt *pu;			   /* .. */
90   uInt comb, exp;		   /* .. */
91   uInt targar[4]={0,0,0,0};	   /* target 128-bit */
92   #define targhi targar[3]	   /* name the word with the sign */
93   #define targmh targar[2]	   /* name the words */
94   #define targml targar[1]	   /* .. */
95   #define targlo targar[0]	   /* .. */
96 
97   /* If the number has too many digits, or the exponent could be */
98   /* out of range then reduce the number under the appropriate */
99   /* constraints.  This could push the number to Infinity or zero, */
100   /* so this check and rounding must be done before generating the */
101   /* decimal128] */
102   ae=dn->exponent+dn->digits-1;		     /* [0 if special] */
103   if (dn->digits>DECIMAL128_Pmax	     /* too many digits */
104    || ae>DECIMAL128_Emax		     /* likely overflow */
105    || ae<DECIMAL128_Emin) {		     /* likely underflow */
106     decContextDefault(&dc, DEC_INIT_DECIMAL128); /* [no traps] */
107     dc.round=set->round;		     /* use supplied rounding */
108     decNumberPlus(&dw, dn, &dc);	     /* (round and check) */
109     /* [this changes -0 to 0, so enforce the sign...] */
110     dw.bits|=dn->bits&DECNEG;
111     status=dc.status;			     /* save status */
112     dn=&dw;				     /* use the work number */
113     } /* maybe out of range */
114 
115   if (dn->bits&DECSPECIAL) {			  /* a special value */
116     if (dn->bits&DECINF) targhi=DECIMAL_Inf<<24;
117      else {					  /* sNaN or qNaN */
118       if ((*dn->lsu!=0 || dn->digits>1)		  /* non-zero coefficient */
119        && (dn->digits<DECIMAL128_Pmax)) {	  /* coefficient fits */
120 	decDigitsToDPD(dn, targar, 0);
121 	}
122       if (dn->bits&DECNAN) targhi|=DECIMAL_NaN<<24;
123        else targhi|=DECIMAL_sNaN<<24;
124       } /* a NaN */
125     } /* special */
126 
127    else { /* is finite */
128     if (decNumberIsZero(dn)) {		     /* is a zero */
129       /* set and clamp exponent */
130       if (dn->exponent<-DECIMAL128_Bias) {
131 	exp=0;				     /* low clamp */
132 	status|=DEC_Clamped;
133 	}
134        else {
135 	exp=dn->exponent+DECIMAL128_Bias;    /* bias exponent */
136 	if (exp>DECIMAL128_Ehigh) {	     /* top clamp */
137 	  exp=DECIMAL128_Ehigh;
138 	  status|=DEC_Clamped;
139 	  }
140 	}
141       comb=(exp>>9) & 0x18;		/* msd=0, exp top 2 bits .. */
142       }
143      else {				/* non-zero finite number */
144       uInt msd;				/* work */
145       Int pad=0;			/* coefficient pad digits */
146 
147       /* the dn is known to fit, but it may need to be padded */
148       exp=(uInt)(dn->exponent+DECIMAL128_Bias);	   /* bias exponent */
149       if (exp>DECIMAL128_Ehigh) {		   /* fold-down case */
150 	pad=exp-DECIMAL128_Ehigh;
151 	exp=DECIMAL128_Ehigh;			   /* [to maximum] */
152 	status|=DEC_Clamped;
153 	}
154 
155       /* [fastpath for common case is not a win, here] */
156       decDigitsToDPD(dn, targar, pad);
157       /* save and clear the top digit */
158       msd=targhi>>14;
159       targhi&=0x00003fff;
160 
161       /* create the combination field */
162       if (msd>=8) comb=0x18 | ((exp>>11) & 0x06) | (msd & 0x01);
163 	     else comb=((exp>>9) & 0x18) | msd;
164       }
165     targhi|=comb<<26;		   /* add combination field .. */
166     targhi|=(exp&0xfff)<<14;	   /* .. and exponent continuation */
167     } /* finite */
168 
169   if (dn->bits&DECNEG) targhi|=0x80000000; /* add sign bit */
170 
171   /* now write to storage; this is endian */
172   pu=(uInt *)d128->bytes;	   /* overlay */
173   if (DECLITEND) {
174     pu[0]=targlo;		   /* directly store the low int */
175     pu[1]=targml;		   /* then the mid-low */
176     pu[2]=targmh;		   /* then the mid-high */
177     pu[3]=targhi;		   /* then the high int */
178     }
179    else {
180     pu[0]=targhi;		   /* directly store the high int */
181     pu[1]=targmh;		   /* then the mid-high */
182     pu[2]=targml;		   /* then the mid-low */
183     pu[3]=targlo;		   /* then the low int */
184     }
185 
186   if (status!=0) decContextSetStatus(set, status); /* pass on status */
187   /* decimal128Show(d128); */
188   return d128;
189   } /* decimal128FromNumber */
190 
191 /* ------------------------------------------------------------------ */
192 /* decimal128ToNumber -- convert decimal128 to decNumber	      */
193 /*   d128 is the source decimal128				      */
194 /*   dn is the target number, with appropriate space		      */
195 /* No error is possible.					      */
196 /* ------------------------------------------------------------------ */
decimal128ToNumber(const decimal128 * d128,decNumber * dn)197 decNumber * decimal128ToNumber(const decimal128 *d128, decNumber *dn) {
198   uInt msd;			   /* coefficient MSD */
199   uInt exp;			   /* exponent top two bits */
200   uInt comb;			   /* combination field */
201   const uInt *pu;		   /* work */
202   Int  need;			   /* .. */
203   uInt sourar[4];		   /* source 128-bit */
204   #define sourhi sourar[3]	   /* name the word with the sign */
205   #define sourmh sourar[2]	   /* and the mid-high word */
206   #define sourml sourar[1]	   /* and the mod-low word */
207   #define sourlo sourar[0]	   /* and the lowest word */
208 
209   /* load source from storage; this is endian */
210   pu=(const uInt *)d128->bytes;	   /* overlay */
211   if (DECLITEND) {
212     sourlo=pu[0];		   /* directly load the low int */
213     sourml=pu[1];		   /* then the mid-low */
214     sourmh=pu[2];		   /* then the mid-high */
215     sourhi=pu[3];		   /* then the high int */
216     }
217    else {
218     sourhi=pu[0];		   /* directly load the high int */
219     sourmh=pu[1];		   /* then the mid-high */
220     sourml=pu[2];		   /* then the mid-low */
221     sourlo=pu[3];		   /* then the low int */
222     }
223 
224   comb=(sourhi>>26)&0x1f;	   /* combination field */
225 
226   decNumberZero(dn);		   /* clean number */
227   if (sourhi&0x80000000) dn->bits=DECNEG; /* set sign if negative */
228 
229   msd=COMBMSD[comb];		   /* decode the combination field */
230   exp=COMBEXP[comb];		   /* .. */
231 
232   if (exp==3) {			   /* is a special */
233     if (msd==0) {
234       dn->bits|=DECINF;
235       return dn;		   /* no coefficient needed */
236       }
237     else if (sourhi&0x02000000) dn->bits|=DECSNAN;
238     else dn->bits|=DECNAN;
239     msd=0;			   /* no top digit */
240     }
241    else {			   /* is a finite number */
242     dn->exponent=(exp<<12)+((sourhi>>14)&0xfff)-DECIMAL128_Bias; /* unbiased */
243     }
244 
245   /* get the coefficient */
246   sourhi&=0x00003fff;		   /* clean coefficient continuation */
247   if (msd) {			   /* non-zero msd */
248     sourhi|=msd<<14;		   /* prefix to coefficient */
249     need=12;			   /* process 12 declets */
250     }
251    else { /* msd=0 */
252     if (sourhi) need=11;	   /* declets to process */
253      else if (sourmh) need=10;
254      else if (sourml) need=7;
255      else if (sourlo) need=4;
256      else return dn;		   /* easy: coefficient is 0 */
257     } /*msd=0 */
258 
259   decDigitsFromDPD(dn, sourar, need);	/* process declets */
260   /* decNumberShow(dn); */
261   return dn;
262   } /* decimal128ToNumber */
263 
264 /* ------------------------------------------------------------------ */
265 /* to-scientific-string -- conversion to numeric string		      */
266 /* to-engineering-string -- conversion to numeric string	      */
267 /*								      */
268 /*   decimal128ToString(d128, string);				      */
269 /*   decimal128ToEngString(d128, string);			      */
270 /*								      */
271 /*  d128 is the decimal128 format number to convert		      */
272 /*  string is the string where the result will be laid out	      */
273 /*								      */
274 /*  string must be at least 24 characters			      */
275 /*								      */
276 /*  No error is possible, and no status can be set.		      */
277 /* ------------------------------------------------------------------ */
decimal128ToEngString(const decimal128 * d128,char * string)278 char * decimal128ToEngString(const decimal128 *d128, char *string){
279   decNumber dn;				/* work */
280   decimal128ToNumber(d128, &dn);
281   decNumberToEngString(&dn, string);
282   return string;
283   } /* decimal128ToEngString */
284 
decimal128ToString(const decimal128 * d128,char * string)285 char * decimal128ToString(const decimal128 *d128, char *string){
286   uInt msd;			   /* coefficient MSD */
287   Int  exp;			   /* exponent top two bits or full */
288   uInt comb;			   /* combination field */
289   char *cstart;			   /* coefficient start */
290   char *c;			   /* output pointer in string */
291   const uInt *pu;		   /* work */
292   char *s, *t;			   /* .. (source, target) */
293   Int  dpd;			   /* .. */
294   Int  pre, e;			   /* .. */
295   const uByte *u;		   /* .. */
296 
297   uInt sourar[4];		   /* source 128-bit */
298   #define sourhi sourar[3]	   /* name the word with the sign */
299   #define sourmh sourar[2]	   /* and the mid-high word */
300   #define sourml sourar[1]	   /* and the mod-low word */
301   #define sourlo sourar[0]	   /* and the lowest word */
302 
303   /* load source from storage; this is endian */
304   pu=(const uInt *)d128->bytes;	   /* overlay */
305   if (DECLITEND) {
306     sourlo=pu[0];		   /* directly load the low int */
307     sourml=pu[1];		   /* then the mid-low */
308     sourmh=pu[2];		   /* then the mid-high */
309     sourhi=pu[3];		   /* then the high int */
310     }
311    else {
312     sourhi=pu[0];		   /* directly load the high int */
313     sourmh=pu[1];		   /* then the mid-high */
314     sourml=pu[2];		   /* then the mid-low */
315     sourlo=pu[3];		   /* then the low int */
316     }
317 
318   c=string;			   /* where result will go */
319   if (((Int)sourhi)<0) *c++='-';   /* handle sign */
320 
321   comb=(sourhi>>26)&0x1f;	   /* combination field */
322   msd=COMBMSD[comb];		   /* decode the combination field */
323   exp=COMBEXP[comb];		   /* .. */
324 
325   if (exp==3) {
326     if (msd==0) {		   /* infinity */
327       strcpy(c,	  "Inf");
328       strcpy(c+3, "inity");
329       return string;		   /* easy */
330       }
331     if (sourhi&0x02000000) *c++='s'; /* sNaN */
332     strcpy(c, "NaN");		   /* complete word */
333     c+=3;			   /* step past */
334     if (sourlo==0 && sourml==0 && sourmh==0
335      && (sourhi&0x0003ffff)==0) return string; /* zero payload */
336     /* otherwise drop through to add integer; set correct exp */
337     exp=0; msd=0;		   /* setup for following code */
338     }
339    else exp=(exp<<12)+((sourhi>>14)&0xfff)-DECIMAL128_Bias; /* unbiased */
340 
341   /* convert 34 digits of significand to characters */
342   cstart=c;			   /* save start of coefficient */
343   if (msd) *c++='0'+(char)msd;	   /* non-zero most significant digit */
344 
345   /* Now decode the declets.  After extracting each one, it is */
346   /* decoded to binary and then to a 4-char sequence by table lookup; */
347   /* the 4-chars are a 1-char length (significant digits, except 000 */
348   /* has length 0).  This allows us to left-align the first declet */
349   /* with non-zero content, then remaining ones are full 3-char */
350   /* length.  We use fixed-length memcpys because variable-length */
351   /* causes a subroutine call in GCC.  (These are length 4 for speed */
352   /* and are safe because the array has an extra terminator byte.) */
353   #define dpd2char u=&BIN2CHAR[DPD2BIN[dpd]*4];			  \
354 		   if (c!=cstart) {memcpy(c, u+1, 4); c+=3;}	  \
355 		    else if (*u)  {memcpy(c, u+4-*u, 4); c+=*u;}
356   dpd=(sourhi>>4)&0x3ff;		     /* declet 1 */
357   dpd2char;
358   dpd=((sourhi&0xf)<<6) | (sourmh>>26);	     /* declet 2 */
359   dpd2char;
360   dpd=(sourmh>>16)&0x3ff;		     /* declet 3 */
361   dpd2char;
362   dpd=(sourmh>>6)&0x3ff;		     /* declet 4 */
363   dpd2char;
364   dpd=((sourmh&0x3f)<<4) | (sourml>>28);     /* declet 5 */
365   dpd2char;
366   dpd=(sourml>>18)&0x3ff;		     /* declet 6 */
367   dpd2char;
368   dpd=(sourml>>8)&0x3ff;		     /* declet 7 */
369   dpd2char;
370   dpd=((sourml&0xff)<<2) | (sourlo>>30);     /* declet 8 */
371   dpd2char;
372   dpd=(sourlo>>20)&0x3ff;		     /* declet 9 */
373   dpd2char;
374   dpd=(sourlo>>10)&0x3ff;		     /* declet 10 */
375   dpd2char;
376   dpd=(sourlo)&0x3ff;			     /* declet 11 */
377   dpd2char;
378 
379   if (c==cstart) *c++='0';	   /* all zeros -- make 0 */
380 
381   if (exp==0) {			   /* integer or NaN case -- easy */
382     *c='\0';			   /* terminate */
383     return string;
384     }
385 
386   /* non-0 exponent */
387   e=0;				   /* assume no E */
388   pre=c-cstart+exp;
389   /* [here, pre-exp is the digits count (==1 for zero)] */
390   if (exp>0 || pre<-5) {	   /* need exponential form */
391     e=pre-1;			   /* calculate E value */
392     pre=1;			   /* assume one digit before '.' */
393     } /* exponential form */
394 
395   /* modify the coefficient, adding 0s, '.', and E+nn as needed */
396   s=c-1;			   /* source (LSD) */
397   if (pre>0) {			   /* ddd.ddd (plain), perhaps with E */
398     char *dotat=cstart+pre;
399     if (dotat<c) {		   /* if embedded dot needed... */
400       t=c;				/* target */
401       for (; s>=dotat; s--, t--) *t=*s; /* open the gap; leave t at gap */
402       *t='.';				/* insert the dot */
403       c++;				/* length increased by one */
404       }
405 
406     /* finally add the E-part, if needed; it will never be 0, and has */
407     /* a maximum length of 4 digits */
408     if (e!=0) {
409       *c++='E';			   /* starts with E */
410       *c++='+';			   /* assume positive */
411       if (e<0) {
412 	*(c-1)='-';		   /* oops, need '-' */
413 	e=-e;			   /* uInt, please */
414 	}
415       if (e<1000) {		   /* 3 (or fewer) digits case */
416 	u=&BIN2CHAR[e*4];	   /* -> length byte */
417 	memcpy(c, u+4-*u, 4);	   /* copy fixed 4 characters [is safe] */
418 	c+=*u;			   /* bump pointer appropriately */
419 	}
420        else {			   /* 4-digits */
421 	Int thou=((e>>3)*1049)>>17; /* e/1000 */
422 	Int rem=e-(1000*thou);	    /* e%1000 */
423 	*c++='0'+(char)thou;
424 	u=&BIN2CHAR[rem*4];	   /* -> length byte */
425 	memcpy(c, u+1, 4);	   /* copy fixed 3+1 characters [is safe] */
426 	c+=3;			   /* bump pointer, always 3 digits */
427 	}
428       }
429     *c='\0';			   /* add terminator */
430     /*printf("res %s\n", string); */
431     return string;
432     } /* pre>0 */
433 
434   /* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */
435   t=c+1-pre;
436   *(t+1)='\0';				/* can add terminator now */
437   for (; s>=cstart; s--, t--) *t=*s;	/* shift whole coefficient right */
438   c=cstart;
439   *c++='0';				/* always starts with 0. */
440   *c++='.';
441   for (; pre<0; pre++) *c++='0';	/* add any 0's after '.' */
442   /*printf("res %s\n", string); */
443   return string;
444   } /* decimal128ToString */
445 
446 /* ------------------------------------------------------------------ */
447 /* to-number -- conversion from numeric string			      */
448 /*								      */
449 /*   decimal128FromString(result, string, set);			      */
450 /*								      */
451 /*  result  is the decimal128 format number which gets the result of  */
452 /*	    the conversion					      */
453 /*  *string is the character string which should contain a valid      */
454 /*	    number (which may be a special value)		      */
455 /*  set	    is the context					      */
456 /*								      */
457 /* The context is supplied to this routine is used for error handling */
458 /* (setting of status and traps) and for the rounding mode, only.     */
459 /* If an error occurs, the result will be a valid decimal128 NaN.     */
460 /* ------------------------------------------------------------------ */
decimal128FromString(decimal128 * result,const char * string,decContext * set)461 decimal128 * decimal128FromString(decimal128 *result, const char *string,
462 				  decContext *set) {
463   decContext dc;			     /* work */
464   decNumber dn;				     /* .. */
465 
466   decContextDefault(&dc, DEC_INIT_DECIMAL128); /* no traps, please */
467   dc.round=set->round;			       /* use supplied rounding */
468 
469   decNumberFromString(&dn, string, &dc);     /* will round if needed */
470   decimal128FromNumber(result, &dn, &dc);
471   if (dc.status!=0) {			     /* something happened */
472     decContextSetStatus(set, dc.status);     /* .. pass it on */
473     }
474   return result;
475   } /* decimal128FromString */
476 
477 /* ------------------------------------------------------------------ */
478 /* decimal128IsCanonical -- test whether encoding is canonical	      */
479 /*   d128 is the source decimal128				      */
480 /*   returns 1 if the encoding of d128 is canonical, 0 otherwise      */
481 /* No error is possible.					      */
482 /* ------------------------------------------------------------------ */
decimal128IsCanonical(const decimal128 * d128)483 uint32_t decimal128IsCanonical(const decimal128 *d128) {
484   decNumber dn;				/* work */
485   decimal128 canon;			 /* .. */
486   decContext dc;			/* .. */
487   decContextDefault(&dc, DEC_INIT_DECIMAL128);
488   decimal128ToNumber(d128, &dn);
489   decimal128FromNumber(&canon, &dn, &dc);/* canon will now be canonical */
490   return memcmp(d128, &canon, DECIMAL128_Bytes)==0;
491   } /* decimal128IsCanonical */
492 
493 /* ------------------------------------------------------------------ */
494 /* decimal128Canonical -- copy an encoding, ensuring it is canonical  */
495 /*   d128 is the source decimal128				      */
496 /*   result is the target (may be the same decimal128)		      */
497 /*   returns result						      */
498 /* No error is possible.					      */
499 /* ------------------------------------------------------------------ */
decimal128Canonical(decimal128 * result,const decimal128 * d128)500 decimal128 * decimal128Canonical(decimal128 *result, const decimal128 *d128) {
501   decNumber dn;				/* work */
502   decContext dc;			/* .. */
503   decContextDefault(&dc, DEC_INIT_DECIMAL128);
504   decimal128ToNumber(d128, &dn);
505   decimal128FromNumber(result, &dn, &dc);/* result will now be canonical */
506   return result;
507   } /* decimal128Canonical */
508 
509 #if DECTRACE || DECCHECK
510 /* Macros for accessing decimal128 fields.  These assume the argument
511    is a reference (pointer) to the decimal128 structure, and the
512    decimal128 is in network byte order (big-endian) */
513 /* Get sign */
514 #define decimal128Sign(d)	((unsigned)(d)->bytes[0]>>7)
515 
516 /* Get combination field */
517 #define decimal128Comb(d)	(((d)->bytes[0] & 0x7c)>>2)
518 
519 /* Get exponent continuation [does not remove bias] */
520 #define decimal128ExpCon(d)	((((d)->bytes[0] & 0x03)<<10)	      \
521 			      | ((unsigned)(d)->bytes[1]<<2)	      \
522 			      | ((unsigned)(d)->bytes[2]>>6))
523 
524 /* Set sign [this assumes sign previously 0] */
525 #define decimal128SetSign(d, b) {				      \
526   (d)->bytes[0]|=((unsigned)(b)<<7);}
527 
528 /* Set exponent continuation [does not apply bias] */
529 /* This assumes range has been checked and exponent previously 0; */
530 /* type of exponent must be unsigned */
531 #define decimal128SetExpCon(d, e) {				      \
532   (d)->bytes[0]|=(uint8_t)((e)>>10);				      \
533   (d)->bytes[1] =(uint8_t)(((e)&0x3fc)>>2);			      \
534   (d)->bytes[2]|=(uint8_t)(((e)&0x03)<<6);}
535 
536 /* ------------------------------------------------------------------ */
537 /* decimal128Show -- display a decimal128 in hexadecimal [debug aid]  */
538 /*   d128 -- the number to show					      */
539 /* ------------------------------------------------------------------ */
540 /* Also shows sign/cob/expconfields extracted */
decimal128Show(const decimal128 * d128)541 void decimal128Show(const decimal128 *d128) {
542   char buf[DECIMAL128_Bytes*2+1];
543   Int i, j=0;
544 
545   if (DECLITEND) {
546     for (i=0; i<DECIMAL128_Bytes; i++, j+=2) {
547       sprintf(&buf[j], "%02x", d128->bytes[15-i]);
548       }
549     printf(" D128> %s [S:%d Cb:%02x Ec:%02x] LittleEndian\n", buf,
550 	   d128->bytes[15]>>7, (d128->bytes[15]>>2)&0x1f,
551 	   ((d128->bytes[15]&0x3)<<10)|(d128->bytes[14]<<2)|
552 	   (d128->bytes[13]>>6));
553     }
554    else {
555     for (i=0; i<DECIMAL128_Bytes; i++, j+=2) {
556       sprintf(&buf[j], "%02x", d128->bytes[i]);
557       }
558     printf(" D128> %s [S:%d Cb:%02x Ec:%02x] BigEndian\n", buf,
559 	   decimal128Sign(d128), decimal128Comb(d128),
560 	   decimal128ExpCon(d128));
561     }
562   } /* decimal128Show */
563 #endif
564