Index: llvm/include/llvm/ADT/APFloat.h
===================================================================
--- llvm/include/llvm/ADT/APFloat.h
+++ llvm/include/llvm/ADT/APFloat.h
@@ -747,32 +747,28 @@
   }
 
   IEEEFloat &getIEEE() {
-    if (usesLayout<IEEEFloat>(*U.semantics)) {
+    if (usesLayout<IEEEFloat>(*U.semantics))
       return U.IEEE;
-    } else if (usesLayout<DoubleAPFloat>(*U.semantics)) {
+    if (usesLayout<DoubleAPFloat>(*U.semantics))
       return U.Double.getFirst().U.IEEE;
-    } else {
-      llvm_unreachable("Unexpected semantics");
-    }
+    llvm_unreachable("Unexpected semantics");
   }
 
   const IEEEFloat &getIEEE() const {
-    if (usesLayout<IEEEFloat>(*U.semantics)) {
+    if (usesLayout<IEEEFloat>(*U.semantics))
       return U.IEEE;
-    } else if (usesLayout<DoubleAPFloat>(*U.semantics)) {
+    if (usesLayout<DoubleAPFloat>(*U.semantics))
       return U.Double.getFirst().U.IEEE;
-    } else {
-      llvm_unreachable("Unexpected semantics");
-    }
+    llvm_unreachable("Unexpected semantics");
   }
 
   void makeZero(bool Neg) { getIEEE().makeZero(Neg); }
 
   void makeInf(bool Neg) {
     if (usesLayout<IEEEFloat>(*U.semantics)) {
-      return U.IEEE.makeInf(Neg);
+      U.IEEE.makeInf(Neg);
     } else if (usesLayout<DoubleAPFloat>(*U.semantics)) {
-      return U.Double.makeInf(Neg);
+      U.Double.makeInf(Neg);
     } else {
       llvm_unreachable("Unexpected semantics");
     }
@@ -803,13 +799,11 @@
 
   cmpResult compareAbsoluteValue(const APFloat &RHS) const {
     assert(&getSemantics() == &RHS.getSemantics());
-    if (usesLayout<IEEEFloat>(getSemantics())) {
+    if (usesLayout<IEEEFloat>(getSemantics()))
       return U.IEEE.compareAbsoluteValue(RHS.U.IEEE);
-    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+    if (usesLayout<DoubleAPFloat>(getSemantics()))
       return U.Double.compareAbsoluteValue(RHS.U.Double);
-    } else {
-      llvm_unreachable("Unexpected semantics");
-    }
+    llvm_unreachable("Unexpected semantics");
   }
 
 public:
@@ -828,13 +822,11 @@
   ~APFloat() = default;
 
   bool needsCleanup() const {
-    if (usesLayout<IEEEFloat>(getSemantics())) {
+    if (usesLayout<IEEEFloat>(getSemantics()))
       return U.IEEE.needsCleanup();
-    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+    if (usesLayout<DoubleAPFloat>(getSemantics()))
       return U.Double.needsCleanup();
-    } else {
-      llvm_unreachable("Unexpected semantics");
-    }
+    llvm_unreachable("Unexpected semantics");
   }
 
   /// Factory for Positive and Negative Zero.
@@ -925,22 +917,18 @@
   void Profile(FoldingSetNodeID &NID) const { getIEEE().Profile(NID); }
 
   opStatus add(const APFloat &RHS, roundingMode RM) {
-    if (usesLayout<IEEEFloat>(getSemantics())) {
+    if (usesLayout<IEEEFloat>(getSemantics()))
       return U.IEEE.add(RHS.U.IEEE, RM);
-    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+    if (usesLayout<DoubleAPFloat>(getSemantics()))
       return U.Double.add(RHS.U.Double, RM);
-    } else {
-      llvm_unreachable("Unexpected semantics");
-    }
+    llvm_unreachable("Unexpected semantics");
   }
   opStatus subtract(const APFloat &RHS, roundingMode RM) {
-    if (usesLayout<IEEEFloat>(getSemantics())) {
+    if (usesLayout<IEEEFloat>(getSemantics()))
       return U.IEEE.subtract(RHS.U.IEEE, RM);
-    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+    if (usesLayout<DoubleAPFloat>(getSemantics()))
       return U.Double.subtract(RHS.U.Double, RM);
-    } else {
-      llvm_unreachable("Unexpected semantics");
-    }
+    llvm_unreachable("Unexpected semantics");
   }
   opStatus multiply(const APFloat &RHS, roundingMode RM) {
     return getIEEE().multiply(RHS.getIEEE(), RM);
Index: llvm/lib/Support/APFloat.cpp
===================================================================
--- llvm/lib/Support/APFloat.cpp
+++ llvm/lib/Support/APFloat.cpp
@@ -4137,22 +4137,23 @@
   if (usesLayout<IEEEFloat>(getSemantics()) &&
       usesLayout<IEEEFloat>(ToSemantics)) {
     return U.IEEE.convert(ToSemantics, RM, losesInfo);
-  } else if (usesLayout<IEEEFloat>(getSemantics()) &&
-             usesLayout<DoubleAPFloat>(ToSemantics)) {
+  }
+  if (usesLayout<IEEEFloat>(getSemantics()) &&
+      usesLayout<DoubleAPFloat>(ToSemantics)) {
     assert(&ToSemantics == &semPPCDoubleDouble);
     auto Ret = U.IEEE.convert(semPPCDoubleDoubleImpl, RM, losesInfo);
-    *this = APFloat(
-        DoubleAPFloat(semPPCDoubleDouble, std::move(*this), APFloat(semIEEEdouble)),
-        ToSemantics);
+    *this = APFloat(DoubleAPFloat(semPPCDoubleDouble, std::move(*this),
+                                  APFloat(semIEEEdouble)),
+                    ToSemantics);
     return Ret;
-  } else if (usesLayout<DoubleAPFloat>(getSemantics()) &&
-             usesLayout<IEEEFloat>(ToSemantics)) {
+  }
+  if (usesLayout<DoubleAPFloat>(getSemantics()) &&
+      usesLayout<IEEEFloat>(ToSemantics)) {
     auto Ret = getIEEE().convert(ToSemantics, RM, losesInfo);
     *this = APFloat(std::move(getIEEE()), ToSemantics);
     return Ret;
-  } else {
-    llvm_unreachable("Unexpected semantics");
   }
+  llvm_unreachable("Unexpected semantics");
 }
 
 APFloat APFloat::getAllOnesValue(unsigned BitWidth, bool isIEEE) {