PR feedback.

Author: codemzs

clang/include/clang/AST/ASTContext.h

@@ -3014,13 +3014,13 @@ class ASTContext : public RefCountedBase<ASTContext> {
   /// of \p LHS is less than \p RHS, return FRCR_Equal_Lesser_Subrank. Subrank
   /// and Unordered comparison were introduced in C++23.
   FloatConvRankCompareResult getFloatingTypeOrder(QualType LHS,
-                                                 QualType RHS) const;
+                                                  QualType RHS) const;
 
   /// Compare the rank of two floating point types as above, but compare equal
   /// if both types have the same floating-point semantics on the target (i.e.
   /// long double and double on AArch64 will return FRCR_Equal).
   FloatConvRankCompareResult getFloatingTypeSemanticOrder(QualType LHS,
-                                                         QualType RHS) const;
+                                                          QualType RHS) const;
 
   /// C++23 6.8.2p12 [basic.fundamental]
   /// Checks if extended floating point rules apply to a pair of types.

clang/lib/AST/ASTContext.cpp

@@ -65,6 +65,7 @@
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/XRayLists.h"
 #include "llvm/ADT/APFixedPoint.h"
+#include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/ArrayRef.h"
@@ -152,64 +153,50 @@ constexpr unsigned CXX23FloatRankToIndex(clang::BuiltinType::Kind Kind) {
 }
 
 // C++23 6.8.6p2 [conv.rank]
-// Grid to determine the rank of a floating point type when compared with
-// another floating point type.
-constexpr std::array<std::array<FloatConvRankCompareResult, 5>, 5>
-    CXX23FloatingPointConversionRankMap = {
-        {// Float16 x Float16
-         // Float16 x BFloat16
-         // Float16 x Float
-         // Float16 x Double
-         // Float16 x LongDouble
-         {{FloatConvRankCompareResult::FRCR_Equal,
-           FloatConvRankCompareResult::FRCR_Unordered,
-           FloatConvRankCompareResult::FRCR_Lesser,
-           FloatConvRankCompareResult::FRCR_Lesser,
-           FloatConvRankCompareResult::FRCR_Lesser}},
-
-         // BFloat16 x Float16
-         // BFloat16 x BFloat16
-         // BFloat16 x Float
-         // BFloat16 x Double
-         // BFloat16 x LongDouble
-         {{FloatConvRankCompareResult::FRCR_Unordered,
-           FloatConvRankCompareResult::FRCR_Equal,
-           FloatConvRankCompareResult::FRCR_Lesser,
-           FloatConvRankCompareResult::FRCR_Lesser,
-           FloatConvRankCompareResult::FRCR_Lesser}},
-
-         // Float x Float16
-         // Float x BFloat16
-         // Float x Float
-         // Float x Double
-         // Float x LongDouble
-         {{FloatConvRankCompareResult::FRCR_Greater,
-           FloatConvRankCompareResult::FRCR_Greater,
-           FloatConvRankCompareResult::FRCR_Equal,
-           FloatConvRankCompareResult::FRCR_Lesser,
-           FloatConvRankCompareResult::FRCR_Lesser}},
-
-         // Double x Float16
-         // Double x BFloat16
-         // Double x Float
-         // Double x Double
-         // Double x LongDouble
-         {{FloatConvRankCompareResult::FRCR_Greater,
-           FloatConvRankCompareResult::FRCR_Greater,
-           FloatConvRankCompareResult::FRCR_Greater,
-           FloatConvRankCompareResult::FRCR_Equal,
-           FloatConvRankCompareResult::FRCR_Lesser}},
-
-         // LongDouble x Float16
-         // LongDouble x BFloat16
-         // LongDouble x Float
-         // LongDouble x Double
-         // LongDouble x LongDouble
-         {{FloatConvRankCompareResult::FRCR_Greater,
-           FloatConvRankCompareResult::FRCR_Greater,
-           FloatConvRankCompareResult::FRCR_Greater,
-           FloatConvRankCompareResult::FRCR_Greater,
-           FloatConvRankCompareResult::FRCR_Equal}}}};
+FloatConvRankCompareResult
+CXX23CompareFpConversionRanks(BuiltinType::Kind LHSKind,
+                              BuiltinType::Kind RHSKind, QualType LHS,
+                              QualType RHS, const ASTContext &Ctx) {
+
+  // Same types.
+  if (LHSKind == RHSKind)
+    return FloatConvRankCompareResult::FRCR_Equal;
+
+  // Special case comparision between float, double and long double.
+  if (LHSKind == BuiltinType::Float && RHSKind == BuiltinType::Double)
+    return FloatConvRankCompareResult::FRCR_Lesser;
+  if (LHSKind == BuiltinType::Double && RHSKind == BuiltinType::Float)
+    return FloatConvRankCompareResult::FRCR_Greater;
+  if (LHSKind == BuiltinType::Float && RHSKind == BuiltinType::LongDouble)
+    return FloatConvRankCompareResult::FRCR_Lesser;
+  if (LHSKind == BuiltinType::LongDouble && RHSKind == BuiltinType::Float)
+    return FloatConvRankCompareResult::FRCR_Greater;
+  if (LHSKind == BuiltinType::Double && RHSKind == BuiltinType::LongDouble)
+    return FloatConvRankCompareResult::FRCR_Lesser;
+  if (LHSKind == BuiltinType::LongDouble && RHSKind == BuiltinType::Double)
+    return FloatConvRankCompareResult::FRCR_Greater;
+
+  const llvm::fltSemantics &LHSSemantics = Ctx.getFloatTypeSemantics(LHS);
+  const llvm::fltSemantics &RHSSemantics = Ctx.getFloatTypeSemantics(RHS);
+
+  bool LHSRepresentableByRHS =
+      llvm::APFloat::isRepresentableBy(LHSSemantics, RHSSemantics);
+  bool RHSRepresentableByLHS =
+      llvm::APFloat::isRepresentableBy(RHSSemantics, LHSSemantics);
+
+  if (LHSRepresentableByRHS && !RHSRepresentableByLHS)
+    return FloatConvRankCompareResult::FRCR_Lesser;
+  if (!LHSRepresentableByRHS && RHSRepresentableByLHS)
+    return FloatConvRankCompareResult::FRCR_Greater;
+
+  if (!LHSRepresentableByRHS && !RHSRepresentableByLHS)
+    return FloatConvRankCompareResult::FRCR_Unordered;
+
+  // Both types are representable by each other, compare sub-ranks, however, as
+  // of today this scenario doesn't exist.
+  llvm_unreachable(
+      "Both types are representable by each other, compare sub-ranks");
+}
 
 /// \returns The locations that are relevant when searching for Doc comments
 /// related to \p D.
@@ -7757,7 +7744,7 @@ static FloatingRank getFloatingRank(QualType T) {
 /// point types, ignoring the domain of the type (i.e. 'double' ==
 /// '_Complex double').
 /// If LHS > RHS, return FRCR_Greater.  If LHS == RHS, return FRCR_Equal. If
-/// LHS < RHS, return FRCR_Lesser. If the values representedable by the two
+/// LHS < RHS, return FRCR_Lesser. If the values representable by the two
 /// are not subset of each other, return FRCR_Unordered. If LHS == RHS but
 /// LHS has a higher subrank than RHS return FRCR_Equal_Greater_Subrank else
 /// return FRCR_Equal_Lesser_Subrank.
@@ -7775,8 +7762,7 @@ ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) const {
       RHSKind = CT->getElementType()->castAs<BuiltinType>()->getKind();
     else
       RHSKind = RHS->castAs<BuiltinType>()->getKind();
-    return CXX23FloatingPointConversionRankMap[CXX23FloatRankToIndex(LHSKind)]
-                                              [CXX23FloatRankToIndex(RHSKind)];
+    return CXX23CompareFpConversionRanks(LHSKind, RHSKind, LHS, RHS, *this);
   }
 
   FloatingRank LHSR = getFloatingRank(LHS);

clang/lib/AST/Type.cpp

@@ -2304,8 +2304,10 @@ bool Type::isCXX23ExtendedFloatingPointType(const ASTContext &Ctx) const {
   if (!Ctx.getLangOpts().CPlusPlus23)
     return false;
   if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
-    return BT->getKind() == BuiltinType::Float16 ||
-           BT->getKind() == BuiltinType::BFloat16;
+    return (BT->getKind() == BuiltinType::Float16 &&
+            Ctx.getTargetInfo().hasFloat16Type()) ||
+           (BT->getKind() == BuiltinType::BFloat16 &&
+            Ctx.getTargetInfo().hasFullBFloat16Type());
   if (const auto *CT = dyn_cast<ComplexType>(CanonicalType))
     return CT->getElementType()->isCXX23ExtendedFloatingPointType(Ctx);
   return false;

clang/lib/Frontend/InitPreprocessor.cpp

@@ -473,8 +473,12 @@ static void InitializeStandardPredefinedMacros(const TargetInfo &TI,
     else if (LangOpts.CPlusPlus23) {
       Builder.defineMacro("__cplusplus", "202302L");
       // [C++23] 15.11p2 [cpp.predefined]
-      Builder.defineMacro("__STDCPP_FLOAT16_T__", "1");
-      Builder.defineMacro("__STDCPP_BFLOAT16_T__", "1");
+      if (TI.hasFloat16Type()) {
+        Builder.defineMacro("__STDCPP_FLOAT16_T__", "1");
+      }
+      if (TI.hasFullBFloat16Type()) {
+        Builder.defineMacro("__STDCPP_BFLOAT16_T__", "1");
+      }
     }
     //      [C++20] The integer literal 202002L.
     else if (LangOpts.CPlusPlus20)

clang/lib/Lex/LiteralSupport.cpp

@@ -23,6 +23,7 @@
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Error.h"
@@ -1038,14 +1039,17 @@ NumericLiteralParser::NumericLiteralParser(StringRef TokSpelling,
     case 'B':
       if (!isFPConstant)
         break; // Error for integer constant.
-      if (s + 3 < ThisTokEnd && (s[1] == 'f' || s[1] == 'F') && s[2] == '1' &&
-          s[3] == '6') {
-        if (HasSize)
-          break;
-        HasSize = true;
-        s += 3;
-        isBFloat16 = true;
-        continue;
+      if (HasSize)
+        break;
+      HasSize = true;
+
+      if ((s + 3 < ThisTokEnd) && Target.hasFullBFloat16Type()) {
+        StringRef suffix(s, 4);
+        if (suffix == "bf16" || suffix == "BF16") {
+          s += 3;
+          isBFloat16 = true;
+          continue;
+        }
       }
       break;
     case 'q':    // FP Suffix for "__float128"

clang/lib/Sema/SemaChecking.cpp

@@ -7445,7 +7445,8 @@ isArithmeticArgumentPromotion(Sema &S, const ImplicitCastExpr *ICE) {
   if (const auto *VecTy = To->getAs<ExtVectorType>())
     To = VecTy->getElementType();
   // It's a floating promotion if the source type is float.
-  // [7.3.8p1][conv.fpprom] https://eel.is/c++draft/conv.fpprom
+  // [7.3.8p1][conv.fpprom] A prvalue of type float can be converted to a
+  // prvalue of type double. The value is unchanged.
   return (ICE->getCastKind() == CK_FloatingCast &&
           S.Context.isPromotableFloatingType(From) &&
           S.Context.getPromotedFloatingType(From) == To);

clang/lib/Sema/SemaOverload.cpp

@@ -4455,7 +4455,7 @@ CompareStandardConversionSequences(Sema &S, SourceLocation Loc,
                ? ImplicitConversionSequence::Better
                : ImplicitConversionSequence::Worse;
 
-  // C++23 12.2.4.3p4:
+  // C++23 [over.ics.rank]p4b3:
   // A conversion in either direction between floating-point type FP1 and
   // floating-point type FP2 is better than a conversion in the same direction
   // between FP1 and arithmetic type T3 if:

clang/test/CodeGenCXX/cxx23-fp-ext-std-names-p1467r9.cpp

@@ -1,5 +1,5 @@
 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature
-// RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-linux-gnu -target-feature +fullbf16 -emit-llvm %s -o - | FileCheck %s  --check-prefix=CHECK
+// RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown -target-feature +fullbf16 -emit-llvm %s -o - | FileCheck %s  --check-prefix=CHECK
 
 // CHECK-LABEL: define {{[^@]+}}@_Z1fDF16b
 // CHECK-SAME: (bfloat noundef [[V:%.*]]) #[[ATTR0:[0-9]+]] {
@@ -497,3 +497,67 @@ void test9_7() {
     // User-defined overload cases
     decltype(0.BF16) bfloat16_val_2(user_defined_val_2); // calls operator int()
 }
+
+template <typename T>
+T passThrough(T x) { return x; }
+
+template <typename T>
+void acceptSameType(T, T) {}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z8test10_1v
+// CHECK-SAME: () #[[ATTR0:[0-9]+]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[HF:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[BF:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[RES1:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[RES2:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[F:%.*]] = alloca float, align 4
+// CHECK-NEXT:    [[D:%.*]] = alloca double, align 8
+// CHECK-NEXT:    [[LD:%.*]] = alloca x86_fp80, align 16
+// CHECK-NEXT:    [[R3:%.*]] = alloca float, align 4
+// CHECK-NEXT:    [[R4:%.*]] = alloca double, align 8
+// CHECK-NEXT:    [[R5:%.*]] = alloca x86_fp80, align 16
+// CHECK-NEXT:    store half 0xH3C00, ptr [[HF]], align 2
+// CHECK-NEXT:    store bfloat 0xR4000, ptr [[BF]], align 2
+// CHECK-NEXT:    [[TMP0:%.*]] = load half, ptr [[HF]], align 2
+// CHECK-NEXT:    [[CALL:%.*]] = call noundef half @_Z11passThroughIDF16_ET_S0_(half noundef [[TMP0]])
+// CHECK-NEXT:    store half [[CALL]], ptr [[RES1]], align 2
+// CHECK-NEXT:    [[TMP1:%.*]] = load bfloat, ptr [[BF]], align 2
+// CHECK-NEXT:    [[CALL1:%.*]] = call noundef bfloat @_Z11passThroughIDF16bET_S0_(bfloat noundef [[TMP1]])
+// CHECK-NEXT:    store bfloat [[CALL1]], ptr [[RES2]], align 2
+// CHECK-NEXT:    store float 3.000000e+00, ptr [[F]], align 4
+// CHECK-NEXT:    store double 4.000000e+00, ptr [[D]], align 8
+// CHECK-NEXT:    store x86_fp80 0xK4001A000000000000000, ptr [[LD]], align 16
+// CHECK-NEXT:    [[TMP2:%.*]] = load half, ptr [[HF]], align 2
+// CHECK-NEXT:    call void @_Z14acceptSameTypeIDF16_EvT_S0_(half noundef [[TMP2]], half noundef 0xH4600)
+// CHECK-NEXT:    [[TMP3:%.*]] = load bfloat, ptr [[BF]], align 2
+// CHECK-NEXT:    call void @_Z14acceptSameTypeIDF16bEvT_S0_(bfloat noundef [[TMP3]], bfloat noundef 0xR40E0)
+// CHECK-NEXT:    [[TMP4:%.*]] = load float, ptr [[F]], align 4
+// CHECK-NEXT:    [[CALL2:%.*]] = call noundef float @_Z11passThroughIfET_S0_(float noundef [[TMP4]])
+// CHECK-NEXT:    store float [[CALL2]], ptr [[R3]], align 4
+// CHECK-NEXT:    [[TMP5:%.*]] = load double, ptr [[D]], align 8
+// CHECK-NEXT:    [[CALL3:%.*]] = call noundef double @_Z11passThroughIdET_S0_(double noundef [[TMP5]])
+// CHECK-NEXT:    store double [[CALL3]], ptr [[R4]], align 8
+// CHECK-NEXT:    [[TMP6:%.*]] = load x86_fp80, ptr [[LD]], align 16
+// CHECK-NEXT:    [[CALL4:%.*]] = call noundef x86_fp80 @_Z11passThroughIeET_S0_(x86_fp80 noundef [[TMP6]])
+// CHECK-NEXT:    store x86_fp80 [[CALL4]], ptr [[R5]], align 16
+// CHECK-NEXT:    ret void
+//
+void test10_1() {
+  _Float16 hf = 1.0f16;
+  decltype(0.BF16) bf = 2.0bf16;
+
+  auto res1 = passThrough(hf);
+  auto res2 = passThrough(bf);
+
+  float f = 3.0f;
+  double d = 4.0;
+  long double ld = 5.0L;
+
+  acceptSameType(hf, _Float16(6.0f16));
+  acceptSameType(bf, decltype(0.BF16)(7.0bf16));
+
+  auto r3 = passThrough(f);
+  auto r4 = passThrough(d);
+  auto r5 = passThrough(ld);
+}

clang/test/Sema/cxx23-fp-ext-std-names-p1467r9.cpp

@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -fsyntax-only -std=c++23 -target-feature +fullbf16 -verify -ast-dump %s | FileCheck %s
+// RUN: %clang_cc1 -fsyntax-only -std=c++23 -triple x86_64-unknown-unknown -target-feature +fullbf16 -verify -ast-dump %s | FileCheck %s
 #include <stdarg.h>
 _Float16 f16_val_1 = 1.0bf16; // expected-error {{cannot initialize a variable of type '_Float16' with an rvalue of type '__bf16'}}
 _Float16 f16_val_2 = 1.0f; // expected-error {{cannot initialize a variable of type '_Float16' with an rvalue of type 'float'}}

llvm/include/llvm/ADT/APFloat.h

@@ -1370,6 +1370,9 @@ class APFloat : public APFloatBase {
   /// shorter semantics, like IEEEhalf.
   float convertToFloat() const;
 
+  static bool isRepresentableBy(const fltSemantics &Sem,
+                                const fltSemantics &Other);
+
   bool operator==(const APFloat &RHS) const { return compare(RHS) == cmpEqual; }
 
   bool operator!=(const APFloat &RHS) const { return compare(RHS) != cmpEqual; }