qemu

1
/* Decimal context 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 Context module					      */
33
/* ------------------------------------------------------------------ */
34
/* This module comprises the routines for handling arithmetic	      */
35
/* context structures.						      */
36
/* ------------------------------------------------------------------ */
37

38
#include "qemu/osdep.h"
39
#include "libdecnumber/dconfig.h"
40
#include "libdecnumber/decContext.h"
41
#include "libdecnumber/decNumberLocal.h"
42

43
#if DECCHECK
44
/* compile-time endian tester [assumes sizeof(Int)>1] */
45
static	const  Int mfcone=1;		     /* constant 1 */
46
static	const  Flag *mfctop=(Flag *)&mfcone; /* -> top byte */
47
#define LITEND *mfctop		   /* named flag; 1=little-endian */
48
#endif
49

50
/* ------------------------------------------------------------------ */
51
/* round-for-reround digits					      */
52
/* ------------------------------------------------------------------ */
53
const uByte DECSTICKYTAB[10]={1,1,2,3,4,6,6,7,8,9}; /* used if sticky */
54

55
/* ------------------------------------------------------------------ */
56
/* Powers of ten (powers[n]==10**n, 0<=n<=19)                         */
57
/* ------------------------------------------------------------------ */
58
const uLong DECPOWERS[20] = {1, 10, 100, 1000, 10000, 100000, 1000000,
59
  10000000, 100000000, 1000000000, 10000000000ULL, 100000000000ULL,
60
  1000000000000ULL, 10000000000000ULL, 100000000000000ULL, 1000000000000000ULL,
61
  10000000000000000ULL, 100000000000000000ULL, 1000000000000000000ULL,
62
  10000000000000000000ULL,};
63

64
/* ------------------------------------------------------------------ */
65
/* decContextClearStatus -- clear bits in current status	      */
66
/*								      */
67
/*  context is the context structure to be queried		      */
68
/*  mask indicates the bits to be cleared (the status bit that	      */
69
/*    corresponds to each 1 bit in the mask is cleared)		      */
70
/*  returns context						      */
71
/*								      */
72
/* No error is possible.					      */
73
/* ------------------------------------------------------------------ */
74
decContext *decContextClearStatus(decContext *context, uInt mask) {
75
  context->status&=~mask;
76
  return context;
77
  } /* decContextClearStatus */
78

79
/* ------------------------------------------------------------------ */
80
/* decContextDefault -- initialize a context structure		      */
81
/*								      */
82
/*  context is the structure to be initialized			      */
83
/*  kind selects the required set of default values, one of:	      */
84
/*	DEC_INIT_BASE	    -- select ANSI X3-274 defaults	      */
85
/*	DEC_INIT_DECIMAL32  -- select IEEE 754r defaults, 32-bit      */
86
/*	DEC_INIT_DECIMAL64  -- select IEEE 754r defaults, 64-bit      */
87
/*	DEC_INIT_DECIMAL128 -- select IEEE 754r defaults, 128-bit     */
88
/*	For any other value a valid context is returned, but with     */
89
/*	Invalid_operation set in the status field.		      */
90
/*  returns a context structure with the appropriate initial values.  */
91
/* ------------------------------------------------------------------ */
92
decContext * decContextDefault(decContext *context, Int kind) {
93
  /* set defaults... */
94
  context->digits=9;			     /* 9 digits */
95
  context->emax=DEC_MAX_EMAX;		     /* 9-digit exponents */
96
  context->emin=DEC_MIN_EMIN;		     /* .. balanced */
97
  context->round=DEC_ROUND_HALF_UP;	     /* 0.5 rises */
98
  context->traps=DEC_Errors;		     /* all but informational */
99
  context->status=0;			     /* cleared */
100
  context->clamp=0;			     /* no clamping */
101
  #if DECSUBSET
102
  context->extended=0;			     /* cleared */
103
  #endif
104
  switch (kind) {
105
    case DEC_INIT_BASE:
106
      /* [use defaults] */
107
      break;
108
    case DEC_INIT_DECIMAL32:
109
      context->digits=7;		     /* digits */
110
      context->emax=96;			     /* Emax */
111
      context->emin=-95;		     /* Emin */
112
      context->round=DEC_ROUND_HALF_EVEN;    /* 0.5 to nearest even */
113
      context->traps=0;			     /* no traps set */
114
      context->clamp=1;			     /* clamp exponents */
115
      #if DECSUBSET
116
      context->extended=1;		     /* set */
117
      #endif
118
      break;
119
    case DEC_INIT_DECIMAL64:
120
      context->digits=16;		     /* digits */
121
      context->emax=384;		     /* Emax */
122
      context->emin=-383;		     /* Emin */
123
      context->round=DEC_ROUND_HALF_EVEN;    /* 0.5 to nearest even */
124
      context->traps=0;			     /* no traps set */
125
      context->clamp=1;			     /* clamp exponents */
126
      #if DECSUBSET
127
      context->extended=1;		     /* set */
128
      #endif
129
      break;
130
    case DEC_INIT_DECIMAL128:
131
      context->digits=34;		     /* digits */
132
      context->emax=6144;		     /* Emax */
133
      context->emin=-6143;		     /* Emin */
134
      context->round=DEC_ROUND_HALF_EVEN;    /* 0.5 to nearest even */
135
      context->traps=0;			     /* no traps set */
136
      context->clamp=1;			     /* clamp exponents */
137
      #if DECSUBSET
138
      context->extended=1;		     /* set */
139
      #endif
140
      break;
141

142
    default:				     /* invalid Kind */
143
      /* use defaults, and .. */
144
      decContextSetStatus(context, DEC_Invalid_operation); /* trap */
145
    }
146

147
  #if DECCHECK
148
  if (LITEND!=DECLITEND) {
149
    const char *adj;
150
    if (LITEND) adj="little";
151
	   else adj="big";
152
    printf("Warning: DECLITEND is set to %d, but this computer appears to be %s-endian\n",
153
	   DECLITEND, adj);
154
    }
155
  #endif
156
  return context;} /* decContextDefault */
157

158
/* ------------------------------------------------------------------ */
159
/* decContextGetRounding -- return current rounding mode	      */
160
/*								      */
161
/*  context is the context structure to be queried		      */
162
/*  returns the rounding mode					      */
163
/*								      */
164
/* No error is possible.					      */
165
/* ------------------------------------------------------------------ */
166
enum rounding decContextGetRounding(decContext *context) {
167
  return context->round;
168
  } /* decContextGetRounding */
169

170
/* ------------------------------------------------------------------ */
171
/* decContextGetStatus -- return current status			      */
172
/*								      */
173
/*  context is the context structure to be queried		      */
174
/*  returns status						      */
175
/*								      */
176
/* No error is possible.					      */
177
/* ------------------------------------------------------------------ */
178
uInt decContextGetStatus(decContext *context) {
179
  return context->status;
180
  } /* decContextGetStatus */
181

182
/* ------------------------------------------------------------------ */
183
/* decContextRestoreStatus -- restore bits in current status	      */
184
/*								      */
185
/*  context is the context structure to be updated		      */
186
/*  newstatus is the source for the bits to be restored		      */
187
/*  mask indicates the bits to be restored (the status bit that	      */
188
/*    corresponds to each 1 bit in the mask is set to the value of    */
189
/*    the corresponding bit in newstatus)			      */
190
/*  returns context						      */
191
/*								      */
192
/* No error is possible.					      */
193
/* ------------------------------------------------------------------ */
194
decContext *decContextRestoreStatus(decContext *context,
195
				    uInt newstatus, uInt mask) {
196
  context->status&=~mask;		/* clear the selected bits */
197
  context->status|=(mask&newstatus);	/* or in the new bits */
198
  return context;
199
  } /* decContextRestoreStatus */
200

201
/* ------------------------------------------------------------------ */
202
/* decContextSaveStatus -- save bits in current status		      */
203
/*								      */
204
/*  context is the context structure to be queried		      */
205
/*  mask indicates the bits to be saved (the status bits that	      */
206
/*    correspond to each 1 bit in the mask are saved)		      */
207
/*  returns the AND of the mask and the current status		      */
208
/*								      */
209
/* No error is possible.					      */
210
/* ------------------------------------------------------------------ */
211
uInt decContextSaveStatus(decContext *context, uInt mask) {
212
  return context->status&mask;
213
  } /* decContextSaveStatus */
214

215
/* ------------------------------------------------------------------ */
216
/* decContextSetRounding -- set current rounding mode		      */
217
/*								      */
218
/*  context is the context structure to be updated		      */
219
/*  newround is the value which will replace the current mode	      */
220
/*  returns context						      */
221
/*								      */
222
/* No error is possible.					      */
223
/* ------------------------------------------------------------------ */
224
decContext *decContextSetRounding(decContext *context,
225
				  enum rounding newround) {
226
  context->round=newround;
227
  return context;
228
  } /* decContextSetRounding */
229

230
/* ------------------------------------------------------------------ */
231
/* decContextSetStatus -- set status and raise trap if appropriate    */
232
/*								      */
233
/*  context is the context structure to be updated		      */
234
/*  status  is the DEC_ exception code				      */
235
/*  returns the context structure				      */
236
/*								      */
237
/* Control may never return from this routine, if there is a signal   */
238
/* handler and it takes a long jump.				      */
239
/* ------------------------------------------------------------------ */
240
decContext * decContextSetStatus(decContext *context, uInt status) {
241
  context->status|=status;
242
  if (status & context->traps) raise(SIGFPE);
243
  return context;} /* decContextSetStatus */
244

245
/* ------------------------------------------------------------------ */
246
/* decContextSetStatusFromString -- set status from a string + trap   */
247
/*								      */
248
/*  context is the context structure to be updated		      */
249
/*  string is a string exactly equal to one that might be returned    */
250
/*	      by decContextStatusToString			      */
251
/*								      */
252
/*  The status bit corresponding to the string is set, and a trap     */
253
/*  is raised if appropriate.					      */
254
/*								      */
255
/*  returns the context structure, unless the string is equal to      */
256
/*    DEC_Condition_MU or is not recognized.  In these cases NULL is  */
257
/*    returned.							      */
258
/* ------------------------------------------------------------------ */
259
decContext * decContextSetStatusFromString(decContext *context,
260
					   const char *string) {
261
  if (strcmp(string, DEC_Condition_CS)==0)
262
    return decContextSetStatus(context, DEC_Conversion_syntax);
263
  if (strcmp(string, DEC_Condition_DZ)==0)
264
    return decContextSetStatus(context, DEC_Division_by_zero);
265
  if (strcmp(string, DEC_Condition_DI)==0)
266
    return decContextSetStatus(context, DEC_Division_impossible);
267
  if (strcmp(string, DEC_Condition_DU)==0)
268
    return decContextSetStatus(context, DEC_Division_undefined);
269
  if (strcmp(string, DEC_Condition_IE)==0)
270
    return decContextSetStatus(context, DEC_Inexact);
271
  if (strcmp(string, DEC_Condition_IS)==0)
272
    return decContextSetStatus(context, DEC_Insufficient_storage);
273
  if (strcmp(string, DEC_Condition_IC)==0)
274
    return decContextSetStatus(context, DEC_Invalid_context);
275
  if (strcmp(string, DEC_Condition_IO)==0)
276
    return decContextSetStatus(context, DEC_Invalid_operation);
277
  #if DECSUBSET
278
  if (strcmp(string, DEC_Condition_LD)==0)
279
    return decContextSetStatus(context, DEC_Lost_digits);
280
  #endif
281
  if (strcmp(string, DEC_Condition_OV)==0)
282
    return decContextSetStatus(context, DEC_Overflow);
283
  if (strcmp(string, DEC_Condition_PA)==0)
284
    return decContextSetStatus(context, DEC_Clamped);
285
  if (strcmp(string, DEC_Condition_RO)==0)
286
    return decContextSetStatus(context, DEC_Rounded);
287
  if (strcmp(string, DEC_Condition_SU)==0)
288
    return decContextSetStatus(context, DEC_Subnormal);
289
  if (strcmp(string, DEC_Condition_UN)==0)
290
    return decContextSetStatus(context, DEC_Underflow);
291
  if (strcmp(string, DEC_Condition_ZE)==0)
292
    return context;
293
  return NULL;	/* Multiple status, or unknown */
294
  } /* decContextSetStatusFromString */
295

296
/* ------------------------------------------------------------------ */
297
/* decContextSetStatusFromStringQuiet -- set status from a string     */
298
/*								      */
299
/*  context is the context structure to be updated		      */
300
/*  string is a string exactly equal to one that might be returned    */
301
/*	      by decContextStatusToString			      */
302
/*								      */
303
/*  The status bit corresponding to the string is set; no trap is     */
304
/*  raised.							      */
305
/*								      */
306
/*  returns the context structure, unless the string is equal to      */
307
/*    DEC_Condition_MU or is not recognized.  In these cases NULL is  */
308
/*    returned.							      */
309
/* ------------------------------------------------------------------ */
310
decContext * decContextSetStatusFromStringQuiet(decContext *context,
311
						const char *string) {
312
  if (strcmp(string, DEC_Condition_CS)==0)
313
    return decContextSetStatusQuiet(context, DEC_Conversion_syntax);
314
  if (strcmp(string, DEC_Condition_DZ)==0)
315
    return decContextSetStatusQuiet(context, DEC_Division_by_zero);
316
  if (strcmp(string, DEC_Condition_DI)==0)
317
    return decContextSetStatusQuiet(context, DEC_Division_impossible);
318
  if (strcmp(string, DEC_Condition_DU)==0)
319
    return decContextSetStatusQuiet(context, DEC_Division_undefined);
320
  if (strcmp(string, DEC_Condition_IE)==0)
321
    return decContextSetStatusQuiet(context, DEC_Inexact);
322
  if (strcmp(string, DEC_Condition_IS)==0)
323
    return decContextSetStatusQuiet(context, DEC_Insufficient_storage);
324
  if (strcmp(string, DEC_Condition_IC)==0)
325
    return decContextSetStatusQuiet(context, DEC_Invalid_context);
326
  if (strcmp(string, DEC_Condition_IO)==0)
327
    return decContextSetStatusQuiet(context, DEC_Invalid_operation);
328
  #if DECSUBSET
329
  if (strcmp(string, DEC_Condition_LD)==0)
330
    return decContextSetStatusQuiet(context, DEC_Lost_digits);
331
  #endif
332
  if (strcmp(string, DEC_Condition_OV)==0)
333
    return decContextSetStatusQuiet(context, DEC_Overflow);
334
  if (strcmp(string, DEC_Condition_PA)==0)
335
    return decContextSetStatusQuiet(context, DEC_Clamped);
336
  if (strcmp(string, DEC_Condition_RO)==0)
337
    return decContextSetStatusQuiet(context, DEC_Rounded);
338
  if (strcmp(string, DEC_Condition_SU)==0)
339
    return decContextSetStatusQuiet(context, DEC_Subnormal);
340
  if (strcmp(string, DEC_Condition_UN)==0)
341
    return decContextSetStatusQuiet(context, DEC_Underflow);
342
  if (strcmp(string, DEC_Condition_ZE)==0)
343
    return context;
344
  return NULL;	/* Multiple status, or unknown */
345
  } /* decContextSetStatusFromStringQuiet */
346

347
/* ------------------------------------------------------------------ */
348
/* decContextSetStatusQuiet -- set status without trap		      */
349
/*								      */
350
/*  context is the context structure to be updated		      */
351
/*  status  is the DEC_ exception code				      */
352
/*  returns the context structure				      */
353
/*								      */
354
/* No error is possible.					      */
355
/* ------------------------------------------------------------------ */
356
decContext * decContextSetStatusQuiet(decContext *context, uInt status) {
357
  context->status|=status;
358
  return context;} /* decContextSetStatusQuiet */
359

360
/* ------------------------------------------------------------------ */
361
/* decContextStatusToString -- convert status flags to a string	      */
362
/*								      */
363
/*  context is a context with valid status field		      */
364
/*								      */
365
/*  returns a constant string describing the condition.	 If multiple  */
366
/*    (or no) flags are set, a generic constant message is returned.  */
367
/* ------------------------------------------------------------------ */
368
const char *decContextStatusToString(const decContext *context) {
369
  Int status=context->status;
370

371
  /* test the five IEEE first, as some of the others are ambiguous when */
372
  /* DECEXTFLAG=0 */
373
  if (status==DEC_Invalid_operation    ) return DEC_Condition_IO;
374
  if (status==DEC_Division_by_zero     ) return DEC_Condition_DZ;
375
  if (status==DEC_Overflow	       ) return DEC_Condition_OV;
376
  if (status==DEC_Underflow	       ) return DEC_Condition_UN;
377
  if (status==DEC_Inexact	       ) return DEC_Condition_IE;
378

379
  if (status==DEC_Division_impossible  ) return DEC_Condition_DI;
380
  if (status==DEC_Division_undefined   ) return DEC_Condition_DU;
381
  if (status==DEC_Rounded	       ) return DEC_Condition_RO;
382
  if (status==DEC_Clamped	       ) return DEC_Condition_PA;
383
  if (status==DEC_Subnormal	       ) return DEC_Condition_SU;
384
  if (status==DEC_Conversion_syntax    ) return DEC_Condition_CS;
385
  if (status==DEC_Insufficient_storage ) return DEC_Condition_IS;
386
  if (status==DEC_Invalid_context      ) return DEC_Condition_IC;
387
  #if DECSUBSET
388
  if (status==DEC_Lost_digits	       ) return DEC_Condition_LD;
389
  #endif
390
  if (status==0			       ) return DEC_Condition_ZE;
391
  return DEC_Condition_MU;  /* Multiple errors */
392
  } /* decContextStatusToString */
393

394
/* ------------------------------------------------------------------ */
395
/* decContextTestSavedStatus -- test bits in saved status	      */
396
/*								      */
397
/*  oldstatus is the status word to be tested			      */
398
/*  mask indicates the bits to be tested (the oldstatus bits that     */
399
/*    correspond to each 1 bit in the mask are tested)		      */
400
/*  returns 1 if any of the tested bits are 1, or 0 otherwise	      */
401
/*								      */
402
/* No error is possible.					      */
403
/* ------------------------------------------------------------------ */
404
uInt decContextTestSavedStatus(uInt oldstatus, uInt mask) {
405
  return (oldstatus&mask)!=0;
406
  } /* decContextTestSavedStatus */
407

408
/* ------------------------------------------------------------------ */
409
/* decContextTestStatus -- test bits in current status		      */
410
/*								      */
411
/*  context is the context structure to be updated		      */
412
/*  mask indicates the bits to be tested (the status bits that	      */
413
/*    correspond to each 1 bit in the mask are tested)		      */
414
/*  returns 1 if any of the tested bits are 1, or 0 otherwise	      */
415
/*								      */
416
/* No error is possible.					      */
417
/* ------------------------------------------------------------------ */
418
uInt decContextTestStatus(decContext *context, uInt mask) {
419
  return (context->status&mask)!=0;
420
  } /* decContextTestStatus */
421

422
/* ------------------------------------------------------------------ */
423
/* decContextZeroStatus -- clear all status bits		      */
424
/*								      */
425
/*  context is the context structure to be updated		      */
426
/*  returns context						      */
427
/*								      */
428
/* No error is possible.					      */
429
/* ------------------------------------------------------------------ */
430
decContext *decContextZeroStatus(decContext *context) {
431
  context->status=0;
432
  return context;
433
  } /* decContextZeroStatus */
434