Remove interal use of float128. Fix whitespace in tests

Author: MDevereau

llvm/include/llvm/ADT/APFloat.h

@@ -300,9 +300,6 @@ class IEEEFloat final : public APFloatBase {
   IEEEFloat(const fltSemantics &, integerPart);
   IEEEFloat(const fltSemantics &, uninitializedTag);
   IEEEFloat(const fltSemantics &, const APInt &);
-#ifdef __FLOAT128__
-  explicit IEEEFloat(float128 ld);
-#endif
   explicit IEEEFloat(double d);
   explicit IEEEFloat(float f);
   IEEEFloat(const IEEEFloat &);
@@ -949,9 +946,6 @@ class APFloat : public APFloatBase {
   APFloat(const fltSemantics &Semantics, uninitializedTag)
       : U(Semantics, uninitialized) {}
   APFloat(const fltSemantics &Semantics, const APInt &I) : U(Semantics, I) {}
-#ifdef __FLOAT128__
-  explicit APFloat(float128 ld) : U(IEEEFloat(ld), IEEEquad()) {}
-#endif
   explicit APFloat(double d) : U(IEEEFloat(d), IEEEdouble()) {}
   explicit APFloat(float f) : U(IEEEFloat(f), IEEEsingle()) {}
   APFloat(const APFloat &RHS) = default;

llvm/include/llvm/ADT/APInt.h

@@ -1703,16 +1703,6 @@ class [[nodiscard]] APInt {
     return APInt(sizeof(float) * CHAR_BIT, llvm::bit_cast<uint32_t>(V));
   }
 
-#ifdef __FLOAT128__
-  static APInt longDoubleToBits(float128 V) {
-    const uint64_t Words[2] = {
-        static_cast<uint64_t>(V),
-        static_cast<uint64_t>(llvm::bit_cast<__uint128_t>(V) >> 64),
-    };
-    return APInt(sizeof(float128) * CHAR_BIT, 2, Words);
-  }
-#endif
-
   /// @}
   /// \name Mathematics Operations
   /// @{

llvm/lib/Analysis/ConstantFolding.cpp

@@ -1673,8 +1673,9 @@ bool llvm::canConstantFoldCallTo(const CallBase *Call, const Function *F) {
            Name == "floor" || Name == "floorf" ||
            Name == "fmod" || Name == "fmodf";
   case 'l':
-    return Name == "log" || Name == "logf" || Name == "log2" ||
-           Name == "log2f" || Name == "log10" || Name == "log10f";
+    return Name == "log" || Name == "logf" ||
+           Name == "log2" || Name == "log2f" ||
+           Name == "log10" || Name == "log10f";
   case 'n':
     return Name == "nearbyint" || Name == "nearbyintf";
   case 'p':

llvm/lib/Support/APFloat.cpp

@@ -3967,12 +3967,6 @@ IEEEFloat::IEEEFloat(double d) {
   initFromAPInt(&semIEEEdouble, APInt::doubleToBits(d));
 }
 
-#ifdef __FLOAT128__
-IEEEFloat::IEEEFloat(float128 ld) {
-  initFromAPInt(&semIEEEquad, APInt::longDoubleToBits(ld));
-}
-#endif
-
 namespace {
   void append(SmallVectorImpl<char> &Buffer, StringRef Str) {
     Buffer.append(Str.begin(), Str.end());

llvm/test/Transforms/InstSimplify/ConstProp/logf128.ll

@@ -38,79 +38,79 @@ define fp128 @log_e_smallest_positive_normal_number(){
   ret fp128 %A
 }
 
-define  fp128 @log_e_largest_normal_number(){
+define fp128 @log_e_largest_normal_number(){
 ; CHECK-LABEL: define fp128 @log_e_largest_normal_number() {
 ; CHECK-NEXT:    ret fp128 0xLF000000000000000400C62E42FEFA39E
 ;
   %A = call fp128 @llvm.log.f128(fp128 noundef 0xLFFFFFFFFFFFFFFFF7FFEFFFFFFFFFFFF)
   ret fp128 %A
 }
 
-define  fp128 @log_e_largest_number_less_than_one(){
+define fp128 @log_e_largest_number_less_than_one(){
 ; CHECK-LABEL: define fp128 @log_e_largest_number_less_than_one() {
 ; CHECK-NEXT:    ret fp128 0xL0000000000000000BF8E000000000000
 ;
   %A = call fp128 @llvm.log.f128(fp128 noundef 0xLFFFFFFFFFFFFFFFF3FFEFFFFFFFFFFFF)
   ret fp128 %A
 }
 
-define  fp128 @log_e_1(){
+define fp128 @log_e_1(){
 ; CHECK-LABEL: define fp128 @log_e_1() {
 ; CHECK-NEXT:    ret fp128 0xL00000000000000000000000000000000
 ;
   %A = call fp128 @llvm.log.f128(fp128 noundef 0xL00000000000000003FFF000000000000)
   ret fp128 %A
 }
 
-define  fp128 @log_e_smallest_number_larger_than_one(){
+define fp128 @log_e_smallest_number_larger_than_one(){
 ; CHECK-LABEL: define fp128 @log_e_smallest_number_larger_than_one() {
 ; CHECK-NEXT:    ret fp128 0xL00000000000000003F8F000000000000
 ;
   %A = call fp128 @llvm.log.f128(fp128 noundef 0xL00000000000000013FFF000000000000)
   ret fp128 %A
 }
 
-define  fp128 @log_e_negative_2(){
+define fp128 @log_e_negative_2(){
 ; CHECK-LABEL: define fp128 @log_e_negative_2() {
 ; CHECK-NEXT:    ret fp128 0xL00000000000000007FFF800000000000
 ;
   %A = call fp128 @llvm.log.f128(fp128 noundef 0xL0000000000000000C000000000000000)
   ret fp128 %A
 }
 
-define  fp128 @log_e_0(){
+define fp128 @log_e_0(){
 ; CHECK-LABEL: define fp128 @log_e_0() {
 ; CHECK-NEXT:    ret fp128 0xL0000000000000000FFFF000000000000
 ;
   %A = call fp128 @llvm.log.f128(fp128 noundef 0xL00000000000000000000000000000000)
   ret fp128 %A
 }
 
-define  fp128 @log_e_negative_0(){
+define fp128 @log_e_negative_0(){
 ; CHECK-LABEL: define fp128 @log_e_negative_0() {
 ; CHECK-NEXT:    ret fp128 0xL0000000000000000FFFF000000000000
 ;
   %A = call fp128 @llvm.log.f128(fp128 noundef 0xL00000000000000008000000000000000)
   ret fp128 %A
 }
 
-define  fp128 @log_e_infinity(){
+define fp128 @log_e_infinity(){
 ; CHECK-LABEL: define fp128 @log_e_infinity() {
 ; CHECK-NEXT:    ret fp128 0xL00000000000000007FFF000000000000
 ;
   %A = call fp128 @llvm.log.f128(fp128 noundef 0xL00000000000000007FFF000000000000)
   ret fp128 %A
 }
 
-define  fp128 @log_e_negative_infinity(){
+define fp128 @log_e_negative_infinity(){
 ; CHECK-LABEL: define fp128 @log_e_negative_infinity() {
 ; CHECK-NEXT:    ret fp128 0xL00000000000000007FFF800000000000
 ;
   %A = call fp128 @llvm.log.f128(fp128 noundef 0xL0000000000000000FFFF000000000000)
   ret fp128 %A
 }
 
-define  fp128 @log_e_nan(){
+define fp128 @log_e_nan(){
 ; CHECK-LABEL: define fp128 @log_e_nan() {
 ; CHECK-NEXT:    ret fp128 0xL00000000000000007FFF800000000001
 ;