[APFloat] Reduce some dispatch boilerplates. NFC.

[timshen]

Summary

This is an attempt to reduce the verbose manual dispatching code in APFloat. This doesn't handle multiple dispatch on single discriminator (e.g. APFloat::add(const APFloat&)), nor handles multiple dispatch on multiple discriminators (e.g. APFloat::convert()).

[jlebar]

Other than the naming nit, this seems like an improvement to me.

llvm/include/llvm/ADT/APFloat.h

24

What does "single" refer to here?

APFLOAT_SEMANTIC_DISPATCH? I don't really like that either.

Maybe someone else has a better suggestion.

[echristo]

llvm/include/llvm/ADT/APFloat.h

24

APFLOAT_FORMAT_DISPATCH ?

[jlebar]

llvm/include/llvm/ADT/APFloat.h

24

I like that one.

[timshen]

llvm/include/llvm/ADT/APFloat.h

24

For single dispatch, see https://en.m.wikipedia.org/wiki/Dynamic_dispatch#Single_and_multiple_dispatch .

Here the macro expands to code that dispatches on "*this" APFloat object. This isn't the case for add or convert.

[echristo]

llvm/include/llvm/ADT/APFloat.h

24

Most people will read the macro as a "what are we doing" rather than "how are we doing it" I think which is why I suggested format.

[timshen]

llvm/include/llvm/ADT/APFloat.h

24

I actually don't know what "format" means here. How about APFLOAT_DISPATCH? :)

[echristo]

llvm/include/llvm/ADT/APFloat.h

24

You could also use layout dispatch. The idea is the "format" of the float. I just don't like layout, but that's also fine if you'd prefer it.

[timshen]

llvm/include/llvm/ADT/APFloat.h

24

I see. Some how "format" reminded me of format string... oh well.

Then the consistent term to use here is "semantics". How about APFLOAT_DISPATCH_ON_SEMANTICS?

[jlebar]

llvm/include/llvm/ADT/APFloat.h

24

I'm also fine with that.

[timshen]

Change macro name to APFLOAT_DISPATCH_ON_SEMANTICS.

llvm/include/llvm/ADT/APFloat.h

 
 #ifndef LLVM_ADT_APFLOAT_H
 #define LLVM_ADT_APFLOAT_H
 
 #include "llvm/ADT/APInt.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <memory>
 
+#define APFLOAT_SINGLE_DISPATCH(METHOD_CALL)                                   \
+  do {                                                                         \
+    if (usesLayout<IEEEFloat>(getSemantics()))                                 \
+      return U.IEEE.METHOD_CALL;                                               \
+    if (usesLayout<DoubleAPFloat>(getSemantics()))                             \
+      return U.Double.METHOD_CALL;                                             \
+    llvm_unreachable("Unexpected semantics");                                  \
+  } while (false)
+
 namespace llvm {
 
 struct fltSemantics;
 class APSInt;
 class StringRef;
 class APFloat;
 class raw_ostream;
 
class APFloat : public APFloatBase {
   const IEEEFloat &getIEEE() const {
     if (usesLayout<IEEEFloat>(*U.semantics))
       return U.IEEE;
     if (usesLayout<DoubleAPFloat>(*U.semantics))
       return U.Double.getFirst().U.IEEE;
     llvm_unreachable("Unexpected semantics");
   }
 
-  void makeZero(bool Neg) {
-    if (usesLayout<IEEEFloat>(getSemantics())) {
-      U.IEEE.makeZero(Neg);
-      return;
-    }
-    if (usesLayout<DoubleAPFloat>(getSemantics())) {
-      U.Double.makeZero(Neg);
-      return;
-    }
-    llvm_unreachable("Unexpected semantics");
-  }
+  void makeZero(bool Neg) { APFLOAT_SINGLE_DISPATCH(makeZero(Neg)); }
 
-  void makeInf(bool Neg) {
-    if (usesLayout<IEEEFloat>(*U.semantics)) {
-      U.IEEE.makeInf(Neg);
-      return;
-    }
-    if (usesLayout<DoubleAPFloat>(*U.semantics)) {
-      U.Double.makeInf(Neg);
-      return;
-    }
-    llvm_unreachable("Unexpected semantics");
-  }
+  void makeInf(bool Neg) { APFLOAT_SINGLE_DISPATCH(makeInf(Neg)); }
 
   void makeNaN(bool SNaN, bool Neg, const APInt *fill) {
-    if (usesLayout<IEEEFloat>(getSemantics())) {
-      U.IEEE.makeNaN(SNaN, Neg, fill);
-      return;
-    }
-    if (usesLayout<DoubleAPFloat>(getSemantics())) {
-      return U.Double.makeNaN(SNaN, Neg, fill);
-      return;
-    }
-    llvm_unreachable("Unexpected semantics");
+    APFLOAT_SINGLE_DISPATCH(makeNaN(SNaN, Neg, fill));
   }
 
-  void makeLargest(bool Neg) {
-    if (usesLayout<IEEEFloat>(getSemantics())) {
-      U.IEEE.makeLargest(Neg);
-      return;
-    }
-    if (usesLayout<DoubleAPFloat>(getSemantics())) {
-      U.Double.makeLargest(Neg);
-      return;
-    }
-    llvm_unreachable("Unexpected semantics");
-  }
+  void makeLargest(bool Neg) { APFLOAT_SINGLE_DISPATCH(makeLargest(Neg)); }
 
-  void makeSmallest(bool Neg) {
-    if (usesLayout<IEEEFloat>(getSemantics())) {
-      U.IEEE.makeSmallest(Neg);
-      return;
-    }
-    if (usesLayout<DoubleAPFloat>(getSemantics())) {
-      U.Double.makeSmallest(Neg);
-      return;
-    }
-    llvm_unreachable("Unexpected semantics");
-  }
+  void makeSmallest(bool Neg) { APFLOAT_SINGLE_DISPATCH(makeSmallest(Neg)); }
 
   void makeSmallestNormalized(bool Neg) {
-    if (usesLayout<IEEEFloat>(getSemantics())) {
-      U.IEEE.makeSmallestNormalized(Neg);
-      return;
-    }
-    if (usesLayout<DoubleAPFloat>(getSemantics())) {
-      U.Double.makeSmallestNormalized(Neg);
-      return;
-    }
-    llvm_unreachable("Unexpected semantics");
+    APFLOAT_SINGLE_DISPATCH(makeSmallestNormalized(Neg));
   }
 
   // FIXME: This is due to clang 3.3 (or older version) always checks for the
   // default constructor in an array aggregate initialization, even if no
   // elements in the array is default initialized.
   APFloat() : U(IEEEdouble()) {
     llvm_unreachable("This is a workaround for old clang.");
   }
public:
   APFloat(const fltSemantics &Semantics, const APInt &I) : U(Semantics, I) {}
   explicit APFloat(double d) : U(IEEEFloat(d), IEEEdouble()) {}
   explicit APFloat(float f) : U(IEEEFloat(f), IEEEsingle()) {}
   APFloat(const APFloat &RHS) = default;
   APFloat(APFloat &&RHS) = default;
 
   ~APFloat() = default;
 
-  bool needsCleanup() const {
-    if (usesLayout<IEEEFloat>(getSemantics()))
-      return U.IEEE.needsCleanup();
-    if (usesLayout<DoubleAPFloat>(getSemantics()))
-      return U.Double.needsCleanup();
-    llvm_unreachable("Unexpected semantics");
-  }
+  bool needsCleanup() const { APFLOAT_SINGLE_DISPATCH(needsCleanup()); }
 
   /// Factory for Positive and Negative Zero.
   ///
   /// \param Negative True iff the number should be negative.
   static APFloat getZero(const fltSemantics &Sem, bool Negative = false) {
     APFloat Val(Sem, uninitialized);
     Val.makeZero(Negative);
     return Val;
opStatus fusedMultiplyAdd(const APFloat &Multiplicand, const APFloat &Addend,
     if (usesLayout<IEEEFloat>(getSemantics()))
       return U.IEEE.fusedMultiplyAdd(Multiplicand.U.IEEE, Addend.U.IEEE, RM);
     if (usesLayout<DoubleAPFloat>(getSemantics()))
       return U.Double.fusedMultiplyAdd(Multiplicand.U.Double, Addend.U.Double,
                                        RM);
     llvm_unreachable("Unexpected semantics");
   }
   opStatus roundToIntegral(roundingMode RM) {
-    if (usesLayout<IEEEFloat>(getSemantics()))
-      return U.IEEE.roundToIntegral(RM);
-    if (usesLayout<DoubleAPFloat>(getSemantics()))
-      return U.Double.roundToIntegral(RM);
-    llvm_unreachable("Unexpected semantics");
+    APFLOAT_SINGLE_DISPATCH(roundToIntegral(RM));
   }
 
   // TODO: bool parameters are not readable and a source of bugs.
   // Do something.
-  opStatus next(bool nextDown) {
-    if (usesLayout<IEEEFloat>(getSemantics()))
-      return U.IEEE.next(nextDown);
-    if (usesLayout<DoubleAPFloat>(getSemantics()))
-      return U.Double.next(nextDown);
-    llvm_unreachable("Unexpected semantics");
-  }
+  opStatus next(bool nextDown) { APFLOAT_SINGLE_DISPATCH(next(nextDown)); }
 
   /// Add two APFloats, rounding ties to the nearest even.
   /// No error checking.
   APFloat operator+(const APFloat &RHS) const {
     APFloat Result(*this);
     (void)Result.add(RHS, rmNearestTiesToEven);
     return Result;
   }
public:
   /// Divide the first APFloat by the second, rounding ties to the nearest even.
   /// No error checking.
   APFloat operator/(const APFloat &RHS) const {
     APFloat Result(*this);
     (void)Result.divide(RHS, rmNearestTiesToEven);
     return Result;
   }
 
-  void changeSign() {
-    if (usesLayout<IEEEFloat>(getSemantics())) {
-      U.IEEE.changeSign();
-      return;
-    }
-    if (usesLayout<DoubleAPFloat>(getSemantics())) {
-      U.Double.changeSign();
-      return;
-    }
-    llvm_unreachable("Unexpected semantics");
-  }
+  void changeSign() { APFLOAT_SINGLE_DISPATCH(changeSign()); }
   void clearSign() {
     if (isNegative())
       changeSign();
   }
   void copySign(const APFloat &RHS) {
     if (isNegative() != RHS.isNegative())
       changeSign();
   }
 
   /// A static helper to produce a copy of an APFloat value with its sign
   /// copied from some other APFloat.
   static APFloat copySign(APFloat Value, const APFloat &Sign) {
     Value.copySign(Sign);
     return Value;
   }
 
   opStatus convert(const fltSemantics &ToSemantics, roundingMode RM,
                    bool *losesInfo);
   opStatus convertToInteger(integerPart *Input, unsigned int Width,
                             bool IsSigned, roundingMode RM,
                             bool *IsExact) const {
-    if (usesLayout<IEEEFloat>(getSemantics()))
-      return U.IEEE.convertToInteger(Input, Width, IsSigned, RM, IsExact);
-    if (usesLayout<DoubleAPFloat>(getSemantics()))
-      return U.Double.convertToInteger(Input, Width, IsSigned, RM, IsExact);
-    llvm_unreachable("Unexpected semantics");
+    APFLOAT_SINGLE_DISPATCH(
+        convertToInteger(Input, Width, IsSigned, RM, IsExact));
   }
   opStatus convertToInteger(APSInt &Result, roundingMode RM,
                             bool *IsExact) const;
   opStatus convertFromAPInt(const APInt &Input, bool IsSigned,
                             roundingMode RM) {
-    if (usesLayout<IEEEFloat>(getSemantics()))
-      return U.IEEE.convertFromAPInt(Input, IsSigned, RM);
-    if (usesLayout<DoubleAPFloat>(getSemantics()))
-      return U.Double.convertFromAPInt(Input, IsSigned, RM);
-    llvm_unreachable("Unexpected semantics");
+    APFLOAT_SINGLE_DISPATCH(convertFromAPInt(Input, IsSigned, RM));
   }
   opStatus convertFromSignExtendedInteger(const integerPart *Input,
                                           unsigned int InputSize, bool IsSigned,
                                           roundingMode RM) {
-    if (usesLayout<IEEEFloat>(getSemantics()))
-      return U.IEEE.convertFromSignExtendedInteger(Input, InputSize, IsSigned,
-                                                   RM);
-    if (usesLayout<DoubleAPFloat>(getSemantics()))
-      return U.Double.convertFromSignExtendedInteger(Input, InputSize, IsSigned,
-                                                     RM);
-    llvm_unreachable("Unexpected semantics");
+    APFLOAT_SINGLE_DISPATCH(
+        convertFromSignExtendedInteger(Input, InputSize, IsSigned, RM));
   }
   opStatus convertFromZeroExtendedInteger(const integerPart *Input,
                                           unsigned int InputSize, bool IsSigned,
                                           roundingMode RM) {
-    if (usesLayout<IEEEFloat>(getSemantics()))
-      return U.IEEE.convertFromZeroExtendedInteger(Input, InputSize, IsSigned,
-                                                   RM);
-    if (usesLayout<DoubleAPFloat>(getSemantics()))
-      return U.Double.convertFromZeroExtendedInteger(Input, InputSize, IsSigned,
-                                                     RM);
-    llvm_unreachable("Unexpected semantics");
+    APFLOAT_SINGLE_DISPATCH(
+        convertFromZeroExtendedInteger(Input, InputSize, IsSigned, RM));
   }
   opStatus convertFromString(StringRef, roundingMode);
-  APInt bitcastToAPInt() const {
-    if (usesLayout<IEEEFloat>(getSemantics()))
-      return U.IEEE.bitcastToAPInt();
-    if (usesLayout<DoubleAPFloat>(getSemantics()))
-      return U.Double.bitcastToAPInt();
-    llvm_unreachable("Unexpected semantics");
-  }
+  APInt bitcastToAPInt() const { APFLOAT_SINGLE_DISPATCH(bitcastToAPInt()); }
   double convertToDouble() const { return getIEEE().convertToDouble(); }
   float convertToFloat() const { return getIEEE().convertToFloat(); }
 
   bool operator==(const APFloat &) const = delete;
 
   cmpResult compare(const APFloat &RHS) const {
     assert(&getSemantics() == &RHS.getSemantics() &&
            "Should only compare APFloats with the same semantics");
if (usesLayout<IEEEFloat>(getSemantics()))
       return U.IEEE.bitwiseIsEqual(RHS.U.IEEE);
     if (usesLayout<DoubleAPFloat>(getSemantics()))
       return U.Double.bitwiseIsEqual(RHS.U.Double);
     llvm_unreachable("Unexpected semantics");
   }
 
   unsigned int convertToHexString(char *DST, unsigned int HexDigits,
                                   bool UpperCase, roundingMode RM) const {
-    if (usesLayout<IEEEFloat>(getSemantics()))
-      return U.IEEE.convertToHexString(DST, HexDigits, UpperCase, RM);
-    if (usesLayout<DoubleAPFloat>(getSemantics()))
-      return U.Double.convertToHexString(DST, HexDigits, UpperCase, RM);
-    llvm_unreachable("Unexpected semantics");
+    APFLOAT_SINGLE_DISPATCH(convertToHexString(DST, HexDigits, UpperCase, RM));
   }
 
   bool isZero() const { return getCategory() == fcZero; }
   bool isInfinity() const { return getCategory() == fcInfinity; }
   bool isNaN() const { return getCategory() == fcNaN; }
 
   bool isNegative() const { return getIEEE().isNegative(); }
-  bool isDenormal() const {
-    if (usesLayout<IEEEFloat>(getSemantics()))
-      return U.IEEE.isDenormal();
-    if (usesLayout<DoubleAPFloat>(getSemantics()))
-      return U.Double.isDenormal();
-    llvm_unreachable("Unexpected semantics");
-  }
+  bool isDenormal() const { APFLOAT_SINGLE_DISPATCH(isDenormal()); }
   bool isSignaling() const { return getIEEE().isSignaling(); }
 
   bool isNormal() const { return !isDenormal() && isFiniteNonZero(); }
   bool isFinite() const { return !isNaN() && !isInfinity(); }
 
   fltCategory getCategory() const { return getIEEE().getCategory(); }
   const fltSemantics &getSemantics() const { return *U.semantics; }
   bool isNonZero() const { return !isZero(); }
   bool isFiniteNonZero() const { return isFinite() && !isZero(); }
   bool isPosZero() const { return isZero() && !isNegative(); }
   bool isNegZero() const { return isZero() && isNegative(); }
-  bool isSmallest() const {
-    if (usesLayout<IEEEFloat>(getSemantics()))
-      return U.IEEE.isSmallest();
-    if (usesLayout<DoubleAPFloat>(getSemantics()))
-      return U.Double.isSmallest();
-    llvm_unreachable("Unexpected semantics");
-  }
-  bool isLargest() const {
-    if (usesLayout<IEEEFloat>(getSemantics()))
-      return U.IEEE.isLargest();
-    if (usesLayout<DoubleAPFloat>(getSemantics()))
-      return U.Double.isLargest();
-    llvm_unreachable("Unexpected semantics");
-  }
-  bool isInteger() const {
-    if (usesLayout<IEEEFloat>(getSemantics()))
-      return U.IEEE.isInteger();
-    if (usesLayout<DoubleAPFloat>(getSemantics()))
-      return U.Double.isInteger();
-    llvm_unreachable("Unexpected semantics");
-  }
+  bool isSmallest() const { APFLOAT_SINGLE_DISPATCH(isSmallest()); }
+  bool isLargest() const { APFLOAT_SINGLE_DISPATCH(isLargest()); }
+  bool isInteger() const { APFLOAT_SINGLE_DISPATCH(isInteger()); }
 
   APFloat &operator=(const APFloat &RHS) = default;
   APFloat &operator=(APFloat &&RHS) = default;
 
   void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision = 0,
                 unsigned FormatMaxPadding = 3) const {
-    if (usesLayout<IEEEFloat>(getSemantics())) {
-      U.IEEE.toString(Str, FormatPrecision, FormatMaxPadding);
-      return;
-    }
-    if (usesLayout<DoubleAPFloat>(getSemantics())) {
-      U.Double.toString(Str, FormatPrecision, FormatMaxPadding);
-      return;
-    }
-    llvm_unreachable("Unexpected semantics");
+    APFLOAT_SINGLE_DISPATCH(toString(Str, FormatPrecision, FormatMaxPadding));
   }
 
   void print(raw_ostream &) const;
   void dump() const;
 
   bool getExactInverse(APFloat *inv) const {
-    if (usesLayout<IEEEFloat>(getSemantics()))
-      return U.IEEE.getExactInverse(inv);
-    if (usesLayout<DoubleAPFloat>(getSemantics()))
-      return U.Double.getExactInverse(inv);
-    llvm_unreachable("Unexpected semantics");
+    APFLOAT_SINGLE_DISPATCH(getExactInverse(inv));
   }
 
   friend hash_code hash_value(const APFloat &Arg);
   friend int ilogb(const APFloat &Arg) { return ilogb(Arg.getIEEE()); }
   friend APFloat scalbn(APFloat X, int Exp, roundingMode RM);
   friend APFloat frexp(const APFloat &X, int &Exp, roundingMode RM);
   friend IEEEFloat;
   friend DoubleAPFloat;
if (A.isNaN())
     return B;
   if (B.isNaN())
     return A;
   return (A.compare(B) == APFloat::cmpLessThan) ? B : A;
 }
 
 } // namespace llvm
 
+#undef APFLOAT_SINGLE_DISPATCH
 #endif // LLVM_ADT_APFLOAT_H

llvm/lib/Support/APFloat.cpp

 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstring>
 #include <limits.h>
 
+#define APFLOAT_SINGLE_DISPATCH(METHOD_CALL)                                   \
+  do {                                                                         \
+    if (usesLayout<IEEEFloat>(getSemantics()))                                 \
+      return U.IEEE.METHOD_CALL;                                               \
+    if (usesLayout<DoubleAPFloat>(getSemantics()))                             \
+      return U.Double.METHOD_CALL;                                             \
+    llvm_unreachable("Unexpected semantics");                                  \
+  } while (false)
+
 using namespace llvm;
 
 /// A macro used to combine two fcCategory enums into one key which can be used
 /// in a switch statement to classify how the interaction of two APFloat's
 /// categories affects an operation.
 ///
 /// TODO: If clang source code is ever allowed to use constexpr in its own
 /// codebase, change this into a static inline function.
new (&Double)
         DoubleAPFloat(Semantics, APFloat(std::move(F), F.getSemantics()),
                       APFloat(semIEEEdouble));
     return;
   }
   llvm_unreachable("Unexpected semantics");
 }
 
 APFloat::opStatus APFloat::convertFromString(StringRef Str, roundingMode RM) {
-  if (usesLayout<IEEEFloat>(getSemantics()))
-    return U.IEEE.convertFromString(Str, RM);
-  if (usesLayout<DoubleAPFloat>(getSemantics()))
-    return U.Double.convertFromString(Str, RM);
-  llvm_unreachable("Unexpected semantics");
+  APFLOAT_SINGLE_DISPATCH(convertFromString(Str, RM));
 }
 
 hash_code hash_value(const APFloat &Arg) {
   if (APFloat::usesLayout<detail::IEEEFloat>(Arg.getSemantics()))
     return hash_value(Arg.U.IEEE);
   if (APFloat::usesLayout<detail::DoubleAPFloat>(Arg.getSemantics()))
     return hash_value(Arg.U.Double);
   llvm_unreachable("Unexpected semantics");
APFloat::opStatus APFloat::convertToInteger(APSInt &result,
   opStatus status = convertToInteger(parts.data(), bitWidth, result.isSigned(),
                                      rounding_mode, isExact);
   // Keeps the original signed-ness.
   result = APInt(bitWidth, parts);
   return status;
 }
 
 } // End llvm namespace
+
+#undef APFLOAT_SINGLE_DISPATCH