Add getSizeInBits function to the APFloat class

[tberghammer]

Summary

Add getSizeInBits function to the APFloat class

The newly added function returns the size of the specified floating point semantics in bits.

[tberghammer]

The function will be first used from LLDB

[bkramer]

This is wrong for x87 long doubles (implicit '1' always present, so the count is off by one) and PPC double doubles (weird 128 bit format). It's probably best to just hardcode the value for all supported fp formats.

[tberghammer]

Use hard coded size values

[hfinkel]

lib/Support/APFloat.cpp

3374 ↗

(On Diff #22185)

Why not just add this number to the fltSemantics structure itself?

[tberghammer]

lib/Support/APFloat.cpp

3374 ↗

(On Diff #22185)

I think it is not really part of the semantic, but I can move it to there if you want.
If I move it into the semantic then what should be the size value of calcSemantic in roundSignificandWithExponent? It isn't used by anybody (yet) but we still should give it a reasonable value.

[tberghammer]

Friendly ping

[chandlerc]

I think I agree with Hal and this should be in the semantic struct. Open to other suggestions though.

[tberghammer]

Move size into the semantics

[tberghammer]

Friendly ping

[tberghammer]

Friendly ping

[tberghammer]

Friendly ping

[hfinkel]

LGTM.

lib/Support/APFloat.cpp

3375 ↗

(On Diff #23762)

This { should be on the previous line.

3377 ↗

(On Diff #23762)

If I move it into the semantic then what should be the size value of calcSemantic in roundSignificandWithExponent? It isn't used by anybody (yet) but we still should give it a reasonable value.

I'd just leave it as 0 as you now have it. It also has 0 precision ;)

llvm/trunk/include/llvm/ADT/APFloat.h

static APFloat getSmallestNormalized(const fltSemantics &Sem,
                                        bool Negative = false);
 
   /// Returns a float which is bitcasted from an all one value int.
   ///
   /// \param BitWidth - Select float type
   /// \param isIEEE   - If 128 bit number, select between PPC and IEEE
   static APFloat getAllOnesValue(unsigned BitWidth, bool isIEEE = false);
 
+  /// Returns the size of the floating point number (in bits) in the given
+  /// semantics.
+  static unsigned getSizeInBits(const fltSemantics &Sem);
+
   /// @}
 
   /// Used to insert APFloat objects, or objects that contain APFloat objects,
   /// into FoldingSets.
   void Profile(FoldingSetNodeID &NID) const;
 
   /// \name Arithmetic
   /// @{

llvm/trunk/lib/Support/APFloat.cpp

struct fltSemantics {
 
     /* The smallest E such that 2^E is a normalized number; this
        matches the definition of IEEE 754.  */
     APFloat::ExponentType minExponent;
 
     /* Number of bits in the significand.  This includes the integer
        bit.  */
     unsigned int precision;
+
+    /* Number of bits actually used in the semantics. */
+    unsigned int sizeInBits;
   };
 
-  const fltSemantics APFloat::IEEEhalf = { 15, -14, 11 };
-  const fltSemantics APFloat::IEEEsingle = { 127, -126, 24 };
-  const fltSemantics APFloat::IEEEdouble = { 1023, -1022, 53 };
-  const fltSemantics APFloat::IEEEquad = { 16383, -16382, 113 };
-  const fltSemantics APFloat::x87DoubleExtended = { 16383, -16382, 64 };
-  const fltSemantics APFloat::Bogus = { 0, 0, 0 };
+  const fltSemantics APFloat::IEEEhalf = { 15, -14, 11, 16 };
+  const fltSemantics APFloat::IEEEsingle = { 127, -126, 24, 32 };
+  const fltSemantics APFloat::IEEEdouble = { 1023, -1022, 53, 64 };
+  const fltSemantics APFloat::IEEEquad = { 16383, -16382, 113, 128 };
+  const fltSemantics APFloat::x87DoubleExtended = { 16383, -16382, 64, 80 };
+  const fltSemantics APFloat::Bogus = { 0, 0, 0, 0 };
 
   /* The PowerPC format consists of two doubles.  It does not map cleanly
      onto the usual format above.  It is approximated using twice the
      mantissa bits.  Note that for exponents near the double minimum,
      we no longer can represent the full 106 mantissa bits, so those
      will be treated as denormal numbers.
 
      FIXME: While this approximation is equivalent to what GCC uses for
      compile-time arithmetic on PPC double-double numbers, it is not able
      to represent all possible values held by a PPC double-double number,
      for example: (long double) 1.0 + (long double) 0x1p-106
      Should this be replaced by a full emulation of PPC double-double?  */
-  const fltSemantics APFloat::PPCDoubleDouble = { 1023, -1022 + 53, 53 + 53 };
+  const fltSemantics APFloat::PPCDoubleDouble = { 1023, -1022 + 53, 53 + 53, 128 };
 
   /* A tight upper bound on number of parts required to hold the value
      pow(5, power) is
 
        power * 815 / (351 * integerPartWidth) + 1
 
      However, whilst the result may require only this many parts,
      because we are multiplying two values to get it, the

 }
 
 APFloat::opStatus
 APFloat::roundSignificandWithExponent(const integerPart *decSigParts,
                                       unsigned sigPartCount, int exp,
                                       roundingMode rounding_mode)
 {
   unsigned int parts, pow5PartCount;
-  fltSemantics calcSemantics = { 32767, -32767, 0 };
+  fltSemantics calcSemantics = { 32767, -32767, 0, 0 };
   integerPart pow5Parts[maxPowerOfFiveParts];
   bool isNearest;
 
   isNearest = (rounding_mode == rmNearestTiesToEven ||
                rounding_mode == rmNearestTiesToAway);
 
   parts = partCountForBits(semantics->precision + 11);
 
case 128:
     if (isIEEE)
       return APFloat(IEEEquad, APInt::getAllOnesValue(BitWidth));
     return APFloat(PPCDoubleDouble, APInt::getAllOnesValue(BitWidth));
   default:
     llvm_unreachable("Unknown floating bit width");
   }
 }
 
+unsigned APFloat::getSizeInBits(const fltSemantics &Sem) {
+  return Sem.sizeInBits;
+}
+
 /// Make this number the largest magnitude normal number in the given
 /// semantics.
 void APFloat::makeLargest(bool Negative) {
   // We want (in interchange format):
   //   sign = {Negative}
   //   exponent = 1..10
   //   significand = 1..1
   category = fcNormal;