← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/ADT/APFloat.h

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-03-12 11:30:04 UTC
  • mfrom: (0.41.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100312113004-b0fop4bkycszdd0z
Tags: 0.96~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/537636
* New upstream RC - FFE (LP: #537636):
  - Add OfficialDatabaseOnly option to clamav-base.postinst.in
  - Add LocalSocketGroup option to clamav-base.postinst.in
  - Add LocalSocketMode option to clamav-base.postinst.in
  - Add CrossFilesystems option to clamav-base.postinst.in
  - Add ClamukoScannerCount option to clamav-base.postinst.in
  - Add BytecodeSecurity opiton to clamav-base.postinst.in
  - Add DetectionStatsHostID option to clamav-freshclam.postinst.in
  - Add Bytecode option to clamav-freshclam.postinst.in
  - Add MilterSocketGroup option to clamav-milter.postinst.in
  - Add MilterSocketMode option to clamav-milter.postinst.in
  - Add ReportHostname option to clamav-milter.postinst.in
  - Bump libclamav SO version to 6.1.0 in libclamav6.install
  - Drop clamdmon from clamav.examples (no longer shipped by upstream)
  - Drop libclamav.a from libclamav-dev.install (not built by upstream)
  - Update SO version for lintian override for libclamav6
  - Add new Bytecode Testing Tool, usr/bin/clambc, to clamav.install
  - Add build-depends on python and python-setuptools for new test suite
  - Update debian/copyright for the embedded copy of llvm (using the system
    llvm is not currently feasible)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/include/llvm/ADT/APFloat.h
 
1
//== llvm/Support/APFloat.h - Arbitrary Precision Floating Point -*- C++ -*-==//
 
2
//
 
3
//                     The LLVM Compiler Infrastructure
 
4
//
 
5
// This file is distributed under the University of Illinois Open Source
 
6
// License. See LICENSE.TXT for details.
 
7
//
 
8
//===----------------------------------------------------------------------===//
 
9
//
 
10
// This file declares a class to represent arbitrary precision floating
 
11
// point values and provide a variety of arithmetic operations on them.
 
12
//
 
13
//===----------------------------------------------------------------------===//
 
14
 
 
15
/*  A self-contained host- and target-independent arbitrary-precision
 
16
    floating-point software implementation.  It uses bignum integer
 
17
    arithmetic as provided by static functions in the APInt class.
 
18
    The library will work with bignum integers whose parts are any
 
19
    unsigned type at least 16 bits wide, but 64 bits is recommended.
 
20
 
 
21
    Written for clarity rather than speed, in particular with a view
 
22
    to use in the front-end of a cross compiler so that target
 
23
    arithmetic can be correctly performed on the host.  Performance
 
24
    should nonetheless be reasonable, particularly for its intended
 
25
    use.  It may be useful as a base implementation for a run-time
 
26
    library during development of a faster target-specific one.
 
27
 
 
28
    All 5 rounding modes in the IEEE-754R draft are handled correctly
 
29
    for all implemented operations.  Currently implemented operations
 
30
    are add, subtract, multiply, divide, fused-multiply-add,
 
31
    conversion-to-float, conversion-to-integer and
 
32
    conversion-from-integer.  New rounding modes (e.g. away from zero)
 
33
    can be added with three or four lines of code.
 
34
 
 
35
    Four formats are built-in: IEEE single precision, double
 
36
    precision, quadruple precision, and x87 80-bit extended double
 
37
    (when operating with full extended precision).  Adding a new
 
38
    format that obeys IEEE semantics only requires adding two lines of
 
39
    code: a declaration and definition of the format.
 
40
 
 
41
    All operations return the status of that operation as an exception
 
42
    bit-mask, so multiple operations can be done consecutively with
 
43
    their results or-ed together.  The returned status can be useful
 
44
    for compiler diagnostics; e.g., inexact, underflow and overflow
 
45
    can be easily diagnosed on constant folding, and compiler
 
46
    optimizers can determine what exceptions would be raised by
 
47
    folding operations and optimize, or perhaps not optimize,
 
48
    accordingly.
 
49
 
 
50
    At present, underflow tininess is detected after rounding; it
 
51
    should be straight forward to add support for the before-rounding
 
52
    case too.
 
53
 
 
54
    The library reads hexadecimal floating point numbers as per C99,
 
55
    and correctly rounds if necessary according to the specified
 
56
    rounding mode.  Syntax is required to have been validated by the
 
57
    caller.  It also converts floating point numbers to hexadecimal
 
58
    text as per the C99 %a and %A conversions.  The output precision
 
59
    (or alternatively the natural minimal precision) can be specified;
 
60
    if the requested precision is less than the natural precision the
 
61
    output is correctly rounded for the specified rounding mode.
 
62
 
 
63
    It also reads decimal floating point numbers and correctly rounds
 
64
    according to the specified rounding mode.
 
65
 
 
66
    Conversion to decimal text is not currently implemented.
 
67
 
 
68
    Non-zero finite numbers are represented internally as a sign bit,
 
69
    a 16-bit signed exponent, and the significand as an array of
 
70
    integer parts.  After normalization of a number of precision P the
 
71
    exponent is within the range of the format, and if the number is
 
72
    not denormal the P-th bit of the significand is set as an explicit
 
73
    integer bit.  For denormals the most significant bit is shifted
 
74
    right so that the exponent is maintained at the format's minimum,
 
75
    so that the smallest denormal has just the least significant bit
 
76
    of the significand set.  The sign of zeroes and infinities is
 
77
    significant; the exponent and significand of such numbers is not
 
78
    stored, but has a known implicit (deterministic) value: 0 for the
 
79
    significands, 0 for zero exponent, all 1 bits for infinity
 
80
    exponent.  For NaNs the sign and significand are deterministic,
 
81
    although not really meaningful, and preserved in non-conversion
 
82
    operations.  The exponent is implicitly all 1 bits.
 
83
 
 
84
    TODO
 
85
    ====
 
86
 
 
87
    Some features that may or may not be worth adding:
 
88
 
 
89
    Binary to decimal conversion (hard).
 
90
 
 
91
    Optional ability to detect underflow tininess before rounding.
 
92
 
 
93
    New formats: x87 in single and double precision mode (IEEE apart
 
94
    from extended exponent range) (hard).
 
95
 
 
96
    New operations: sqrt, IEEE remainder, C90 fmod, nextafter,
 
97
    nexttoward.
 
98
*/
 
99
 
 
100
#ifndef LLVM_FLOAT_H
 
101
#define LLVM_FLOAT_H
 
102
 
 
103
// APInt contains static functions implementing bignum arithmetic.
 
104
#include "llvm/ADT/APInt.h"
 
105
 
 
106
namespace llvm {
 
107
 
 
108
  /* Exponents are stored as signed numbers.  */
 
109
  typedef signed short exponent_t;
 
110
 
 
111
  struct fltSemantics;
 
112
  class StringRef;
 
113
 
 
114
  /* When bits of a floating point number are truncated, this enum is
 
115
     used to indicate what fraction of the LSB those bits represented.
 
116
     It essentially combines the roles of guard and sticky bits.  */
 
117
  enum lostFraction {           // Example of truncated bits:
 
118
    lfExactlyZero,              // 000000
 
119
    lfLessThanHalf,             // 0xxxxx  x's not all zero
 
120
    lfExactlyHalf,              // 100000
 
121
    lfMoreThanHalf              // 1xxxxx  x's not all zero
 
122
  };
 
123
 
 
124
  class APFloat {
 
125
  public:
 
126
 
 
127
    /* We support the following floating point semantics.  */
 
128
    static const fltSemantics IEEEhalf;
 
129
    static const fltSemantics IEEEsingle;
 
130
    static const fltSemantics IEEEdouble;
 
131
    static const fltSemantics IEEEquad;
 
132
    static const fltSemantics PPCDoubleDouble;
 
133
    static const fltSemantics x87DoubleExtended;
 
134
    /* And this pseudo, used to construct APFloats that cannot
 
135
       conflict with anything real. */
 
136
    static const fltSemantics Bogus;
 
137
 
 
138
    static unsigned int semanticsPrecision(const fltSemantics &);
 
139
 
 
140
    /* Floating point numbers have a four-state comparison relation.  */
 
141
    enum cmpResult {
 
142
      cmpLessThan,
 
143
      cmpEqual,
 
144
      cmpGreaterThan,
 
145
      cmpUnordered
 
146
    };
 
147
 
 
148
    /* IEEE-754R gives five rounding modes.  */
 
149
    enum roundingMode {
 
150
      rmNearestTiesToEven,
 
151
      rmTowardPositive,
 
152
      rmTowardNegative,
 
153
      rmTowardZero,
 
154
      rmNearestTiesToAway
 
155
    };
 
156
 
 
157
    // Operation status.  opUnderflow or opOverflow are always returned
 
158
    // or-ed with opInexact.
 
159
    enum opStatus {
 
160
      opOK          = 0x00,
 
161
      opInvalidOp   = 0x01,
 
162
      opDivByZero   = 0x02,
 
163
      opOverflow    = 0x04,
 
164
      opUnderflow   = 0x08,
 
165
      opInexact     = 0x10
 
166
    };
 
167
 
 
168
    // Category of internally-represented number.
 
169
    enum fltCategory {
 
170
      fcInfinity,
 
171
      fcNaN,
 
172
      fcNormal,
 
173
      fcZero
 
174
    };
 
175
 
 
176
    enum uninitializedTag {
 
177
      uninitialized
 
178
    };
 
179
 
 
180
    // Constructors.
 
181
    APFloat(const fltSemantics &); // Default construct to 0.0
 
182
    APFloat(const fltSemantics &, const StringRef &);
 
183
    APFloat(const fltSemantics &, integerPart);
 
184
    APFloat(const fltSemantics &, fltCategory, bool negative);
 
185
    APFloat(const fltSemantics &, uninitializedTag);
 
186
    explicit APFloat(double d);
 
187
    explicit APFloat(float f);
 
188
    explicit APFloat(const APInt &, bool isIEEE = false);
 
189
    APFloat(const APFloat &);
 
190
    ~APFloat();
 
191
 
 
192
    // Convenience "constructors"
 
193
    static APFloat getZero(const fltSemantics &Sem, bool Negative = false) {
 
194
      return APFloat(Sem, fcZero, Negative);
 
195
    }
 
196
    static APFloat getInf(const fltSemantics &Sem, bool Negative = false) {
 
197
      return APFloat(Sem, fcInfinity, Negative);
 
198
    }
 
199
 
 
200
    /// getNaN - Factory for QNaN values.
 
201
    ///
 
202
    /// \param Negative - True iff the NaN generated should be negative.
 
203
    /// \param type - The unspecified fill bits for creating the NaN, 0 by
 
204
    /// default.  The value is truncated as necessary.
 
205
    static APFloat getNaN(const fltSemantics &Sem, bool Negative = false,
 
206
                          unsigned type = 0) {
 
207
      if (type) {
 
208
        APInt fill(64, type);
 
209
        return getQNaN(Sem, Negative, &fill);
 
210
      } else {
 
211
        return getQNaN(Sem, Negative, 0);
 
212
      }
 
213
    }
 
214
 
 
215
    /// getQNan - Factory for QNaN values.
 
216
    static APFloat getQNaN(const fltSemantics &Sem,
 
217
                           bool Negative = false,
 
218
                           const APInt *payload = 0) {
 
219
      return makeNaN(Sem, false, Negative, payload);
 
220
    }
 
221
 
 
222
    /// getSNan - Factory for SNaN values.
 
223
    static APFloat getSNaN(const fltSemantics &Sem,
 
224
                           bool Negative = false,
 
225
                           const APInt *payload = 0) {
 
226
      return makeNaN(Sem, true, Negative, payload);
 
227
    }
 
228
 
 
229
    /// getLargest - Returns the largest finite number in the given
 
230
    /// semantics.
 
231
    ///
 
232
    /// \param Negative - True iff the number should be negative
 
233
    static APFloat getLargest(const fltSemantics &Sem, bool Negative = false);
 
234
 
 
235
    /// getSmallest - Returns the smallest (by magnitude) finite number
 
236
    /// in the given semantics.  Might be denormalized, which implies a
 
237
    /// relative loss of precision.
 
238
    ///
 
239
    /// \param Negative - True iff the number should be negative
 
240
    static APFloat getSmallest(const fltSemantics &Sem, bool Negative = false);
 
241
 
 
242
    /// getSmallestNormalized - Returns the smallest (by magnitude)
 
243
    /// normalized finite number in the given semantics.
 
244
    ///
 
245
    /// \param Negative - True iff the number should be negative
 
246
    static APFloat getSmallestNormalized(const fltSemantics &Sem,
 
247
                                         bool Negative = false);
 
248
 
 
249
    /// Profile - Used to insert APFloat objects, or objects that contain
 
250
    ///  APFloat objects, into FoldingSets.
 
251
    void Profile(FoldingSetNodeID& NID) const;
 
252
 
 
253
    /// @brief Used by the Bitcode serializer to emit APInts to Bitcode.
 
254
    void Emit(Serializer& S) const;
 
255
 
 
256
    /// @brief Used by the Bitcode deserializer to deserialize APInts.
 
257
    static APFloat ReadVal(Deserializer& D);
 
258
 
 
259
    /* Arithmetic.  */
 
260
    opStatus add(const APFloat &, roundingMode);
 
261
    opStatus subtract(const APFloat &, roundingMode);
 
262
    opStatus multiply(const APFloat &, roundingMode);
 
263
    opStatus divide(const APFloat &, roundingMode);
 
264
    /* IEEE remainder. */
 
265
    opStatus remainder(const APFloat &);
 
266
    /* C fmod, or llvm frem. */
 
267
    opStatus mod(const APFloat &, roundingMode);
 
268
    opStatus fusedMultiplyAdd(const APFloat &, const APFloat &, roundingMode);
 
269
 
 
270
    /* Sign operations.  */
 
271
    void changeSign();
 
272
    void clearSign();
 
273
    void copySign(const APFloat &);
 
274
 
 
275
    /* Conversions.  */
 
276
    opStatus convert(const fltSemantics &, roundingMode, bool *);
 
277
    opStatus convertToInteger(integerPart *, unsigned int, bool,
 
278
                              roundingMode, bool *) const;
 
279
    opStatus convertFromAPInt(const APInt &,
 
280
                              bool, roundingMode);
 
281
    opStatus convertFromSignExtendedInteger(const integerPart *, unsigned int,
 
282
                                            bool, roundingMode);
 
283
    opStatus convertFromZeroExtendedInteger(const integerPart *, unsigned int,
 
284
                                            bool, roundingMode);
 
285
    opStatus convertFromString(const StringRef&, roundingMode);
 
286
    APInt bitcastToAPInt() const;
 
287
    double convertToDouble() const;
 
288
    float convertToFloat() const;
 
289
 
 
290
    /* The definition of equality is not straightforward for floating point,
 
291
       so we won't use operator==.  Use one of the following, or write
 
292
       whatever it is you really mean. */
 
293
    // bool operator==(const APFloat &) const;     // DO NOT IMPLEMENT
 
294
 
 
295
    /* IEEE comparison with another floating point number (NaNs
 
296
       compare unordered, 0==-0). */
 
297
    cmpResult compare(const APFloat &) const;
 
298
 
 
299
    /* Bitwise comparison for equality (QNaNs compare equal, 0!=-0). */
 
300
    bool bitwiseIsEqual(const APFloat &) const;
 
301
 
 
302
    /* Write out a hexadecimal representation of the floating point
 
303
       value to DST, which must be of sufficient size, in the C99 form
 
304
       [-]0xh.hhhhp[+-]d.  Return the number of characters written,
 
305
       excluding the terminating NUL.  */
 
306
    unsigned int convertToHexString(char *dst, unsigned int hexDigits,
 
307
                                    bool upperCase, roundingMode) const;
 
308
 
 
309
    /* Simple queries.  */
 
310
    fltCategory getCategory() const { return category; }
 
311
    const fltSemantics &getSemantics() const { return *semantics; }
 
312
    bool isZero() const { return category == fcZero; }
 
313
    bool isNonZero() const { return category != fcZero; }
 
314
    bool isNaN() const { return category == fcNaN; }
 
315
    bool isInfinity() const { return category == fcInfinity; }
 
316
    bool isNegative() const { return sign; }
 
317
    bool isPosZero() const { return isZero() && !isNegative(); }
 
318
    bool isNegZero() const { return isZero() && isNegative(); }
 
319
 
 
320
    APFloat& operator=(const APFloat &);
 
321
 
 
322
    /* Return an arbitrary integer value usable for hashing. */
 
323
    uint32_t getHashValue() const;
 
324
 
 
325
    /// Converts this value into a decimal string.
 
326
    ///
 
327
    /// \param FormatPrecision The maximum number of digits of
 
328
    ///   precision to output.  If there are fewer digits available,
 
329
    ///   zero padding will not be used unless the value is
 
330
    ///   integral and small enough to be expressed in
 
331
    ///   FormatPrecision digits.  0 means to use the natural
 
332
    ///   precision of the number.
 
333
    /// \param FormatMaxPadding The maximum number of zeros to
 
334
    ///   consider inserting before falling back to scientific
 
335
    ///   notation.  0 means to always use scientific notation.
 
336
    ///
 
337
    /// Number       Precision    MaxPadding      Result
 
338
    /// ------       ---------    ----------      ------
 
339
    /// 1.01E+4              5             2       10100
 
340
    /// 1.01E+4              4             2       1.01E+4
 
341
    /// 1.01E+4              5             1       1.01E+4
 
342
    /// 1.01E-2              5             2       0.0101
 
343
    /// 1.01E-2              4             2       0.0101
 
344
    /// 1.01E-2              4             1       1.01E-2
 
345
    void toString(SmallVectorImpl<char> &Str,
 
346
                  unsigned FormatPrecision = 0,
 
347
                  unsigned FormatMaxPadding = 3);
 
348
 
 
349
  private:
 
350
 
 
351
    /* Trivial queries.  */
 
352
    integerPart *significandParts();
 
353
    const integerPart *significandParts() const;
 
354
    unsigned int partCount() const;
 
355
 
 
356
    /* Significand operations.  */
 
357
    integerPart addSignificand(const APFloat &);
 
358
    integerPart subtractSignificand(const APFloat &, integerPart);
 
359
    lostFraction addOrSubtractSignificand(const APFloat &, bool subtract);
 
360
    lostFraction multiplySignificand(const APFloat &, const APFloat *);
 
361
    lostFraction divideSignificand(const APFloat &);
 
362
    void incrementSignificand();
 
363
    void initialize(const fltSemantics *);
 
364
    void shiftSignificandLeft(unsigned int);
 
365
    lostFraction shiftSignificandRight(unsigned int);
 
366
    unsigned int significandLSB() const;
 
367
    unsigned int significandMSB() const;
 
368
    void zeroSignificand();
 
369
 
 
370
    /* Arithmetic on special values.  */
 
371
    opStatus addOrSubtractSpecials(const APFloat &, bool subtract);
 
372
    opStatus divideSpecials(const APFloat &);
 
373
    opStatus multiplySpecials(const APFloat &);
 
374
    opStatus modSpecials(const APFloat &);
 
375
 
 
376
    /* Miscellany.  */
 
377
    static APFloat makeNaN(const fltSemantics &Sem, bool SNaN, bool Negative,
 
378
                           const APInt *fill);
 
379
    void makeNaN(bool SNaN = false, bool Neg = false, const APInt *fill = 0);
 
380
    opStatus normalize(roundingMode, lostFraction);
 
381
    opStatus addOrSubtract(const APFloat &, roundingMode, bool subtract);
 
382
    cmpResult compareAbsoluteValue(const APFloat &) const;
 
383
    opStatus handleOverflow(roundingMode);
 
384
    bool roundAwayFromZero(roundingMode, lostFraction, unsigned int) const;
 
385
    opStatus convertToSignExtendedInteger(integerPart *, unsigned int, bool,
 
386
                                          roundingMode, bool *) const;
 
387
    opStatus convertFromUnsignedParts(const integerPart *, unsigned int,
 
388
                                      roundingMode);
 
389
    opStatus convertFromHexadecimalString(const StringRef&, roundingMode);
 
390
    opStatus convertFromDecimalString (const StringRef&, roundingMode);
 
391
    char *convertNormalToHexString(char *, unsigned int, bool,
 
392
                                   roundingMode) const;
 
393
    opStatus roundSignificandWithExponent(const integerPart *, unsigned int,
 
394
                                          int, roundingMode);
 
395
 
 
396
    APInt convertHalfAPFloatToAPInt() const;
 
397
    APInt convertFloatAPFloatToAPInt() const;
 
398
    APInt convertDoubleAPFloatToAPInt() const;
 
399
    APInt convertQuadrupleAPFloatToAPInt() const;
 
400
    APInt convertF80LongDoubleAPFloatToAPInt() const;
 
401
    APInt convertPPCDoubleDoubleAPFloatToAPInt() const;
 
402
    void initFromAPInt(const APInt& api, bool isIEEE = false);
 
403
    void initFromHalfAPInt(const APInt& api);
 
404
    void initFromFloatAPInt(const APInt& api);
 
405
    void initFromDoubleAPInt(const APInt& api);
 
406
    void initFromQuadrupleAPInt(const APInt &api);
 
407
    void initFromF80LongDoubleAPInt(const APInt& api);
 
408
    void initFromPPCDoubleDoubleAPInt(const APInt& api);
 
409
 
 
410
    void assign(const APFloat &);
 
411
    void copySignificand(const APFloat &);
 
412
    void freeSignificand();
 
413
 
 
414
    /* What kind of semantics does this value obey?  */
 
415
    const fltSemantics *semantics;
 
416
 
 
417
    /* Significand - the fraction with an explicit integer bit.  Must be
 
418
       at least one bit wider than the target precision.  */
 
419
    union Significand
 
420
    {
 
421
      integerPart part;
 
422
      integerPart *parts;
 
423
    } significand;
 
424
 
 
425
    /* The exponent - a signed number.  */
 
426
    exponent_t exponent;
 
427
 
 
428
    /* What kind of floating point number this is.  */
 
429
    /* Only 2 bits are required, but VisualStudio incorrectly sign extends
 
430
       it.  Using the extra bit keeps it from failing under VisualStudio */
 
431
    fltCategory category: 3;
 
432
 
 
433
    /* The sign bit of this number.  */
 
434
    unsigned int sign: 1;
 
435
 
 
436
    /* For PPCDoubleDouble, we have a second exponent and sign (the second
 
437
       significand is appended to the first one, although it would be wrong to
 
438
       regard these as a single number for arithmetic purposes).  These fields
 
439
       are not meaningful for any other type. */
 
440
    exponent_t exponent2 : 11;
 
441
    unsigned int sign2: 1;
 
442
  };
 
443
} /* namespace llvm */
 
444
 
 
445
#endif /* LLVM_FLOAT_H */