[Clang][C++23] Implement core language changes from P1467R9 extended

floating-point types and standard names.

This commit implements Core language changes based on P1467R9 Extended
floating-point types and standard names.

As per the proposal's definition the following two types are marked as
extended floating point: Float16 (aka _Float16) and
Bfloat16 (aka decltype (0.0bf16) or __bf16). Future work can extend this
to support other floating-point types such as Float32, Float64, and
Float128.

RFC: https://discourse.llvm.org/t/rfc-c-23-p1467r9-extended-floating-point-types-and-standard-names/70033

Differential Revision: https://reviews.llvm.org/D149573

Author: codemzs

clang/docs/ReleaseNotes.rst

@@ -248,6 +248,11 @@ C++ Language Changes
 - The builtin type alias ``__builtin_common_type`` has been added to improve the
   performance of ``std::common_type``.
 
+- Implemented `P1467R9: Extended floating-point types and standard names <https://wg21.link/P1467R9>`_. Enables
+  extended floating-point types beyond the three standard ones, establishing rules for their interactions and
+  conversions with each other and other types, while ensuring no alteration in the behavior of existing
+  standard types. The current implementation enables support for `std::float16_t` and `std::bfloat16_t` types.
+
 C++2c Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 

clang/include/clang/AST/ASTContext.h

@@ -55,6 +55,16 @@ template <typename T, unsigned N> class SmallPtrSet;
 
 namespace clang {
 
+// Conversion ranks introduced in C++23 6.8.6p2 [conv.rank]
+enum FloatConvRankCompareResult {
+  FRCR_Unordered,
+  FRCR_Lesser,
+  FRCR_Greater,
+  FRCR_Equal,
+  FRCR_Equal_Lesser_Subrank,
+  FRCR_Equal_Greater_Subrank,
+};
+
 class APValue;
 class ASTMutationListener;
 class ASTRecordLayout;
@@ -1182,8 +1192,8 @@ class ASTContext : public RefCountedBase<ASTContext> {
   CanQualType SatUnsignedShortFractTy, SatUnsignedFractTy,
       SatUnsignedLongFractTy;
   CanQualType HalfTy; // [OpenCL 6.1.1.1], ARM NEON
-  CanQualType BFloat16Ty;
-  CanQualType Float16Ty; // C11 extension ISO/IEC TS 18661-3
+  CanQualType BFloat16Ty; // [C++23 6.8.3p5][basic.extended.fp]
+  CanQualType Float16Ty; // C11 extension ISO/IEC TS 18661-3 and [C++23 6.8.3p1][basic.extended.fp]
   CanQualType VoidPtrTy, NullPtrTy;
   CanQualType DependentTy, OverloadTy, BoundMemberTy, UnresolvedTemplateTy,
       UnknownAnyTy;
@@ -2563,6 +2573,9 @@ class ASTContext : public RefCountedBase<ASTContext> {
   /// More type predicates useful for type checking/promotion
   bool isPromotableIntegerType(QualType T) const; // C99 6.3.1.1p2
 
+  /// Determine if a floating type can be promoted to another floating type.
+  bool isPromotableFloatingType(QualType T) const;
+
   /// Return the "preferred" alignment of the specified type \p T for
   /// the current target, in bits.
   ///
@@ -2970,6 +2983,9 @@ class ASTContext : public RefCountedBase<ASTContext> {
   /// 6.3.1.1p2, assuming that \p PromotableType is a promotable integer type.
   QualType getPromotedIntegerType(QualType PromotableType) const;
 
+  /// Determines the promoted floating point type.
+  QualType getPromotedFloatingType(QualType PromotableType) const;
+
   /// Recurses in pointer/array types until it finds an Objective-C
   /// retainable type and returns its ownership.
   Qualifiers::ObjCLifetime getInnerObjCOwnership(QualType T) const;
@@ -2990,14 +3006,38 @@ class ASTContext : public RefCountedBase<ASTContext> {
   /// Compare the rank of the two specified floating point types,
   /// ignoring the domain of the type (i.e. 'double' == '_Complex double').
   ///
-  /// If \p LHS > \p RHS, returns 1.  If \p LHS == \p RHS, returns 0.  If
-  /// \p LHS < \p RHS, return -1.
-  int getFloatingTypeOrder(QualType LHS, QualType RHS) const;
+  /// If \p LHS > \p RHS, returns FRCR_Greater. If \p LHS == \p RHS, returns
+  /// FRCR_Equal.  If \p LHS < \p RHS, return FRCR_Lesser. If \p LHS and \p RHS
+  /// are unordered, return FRCR_Unordered. If \p LHS and \p RHS are equal but
+  /// the subrank of \p LHS is greater than \p RHS, return
+  /// FRCR_Equal_Greater_Subrank. If \p LHS and \p RHS are equal but the subrank
+  /// 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;
 
   /// 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 0).
-  int getFloatingTypeSemanticOrder(QualType LHS, QualType RHS) const;
+  /// long double and double on AArch64 will return FRCR_Equal).
+  FloatConvRankCompareResult getFloatingTypeSemanticOrder(QualType LHS,
+                                                         QualType RHS) const;
+
+  /// C++23 6.8.2p12 [basic.fundamental]
+  /// Checks if extended floating point rules apply to a pair of types.
+  /// It returns true if both the types are C++23 floating point types and
+  /// at least one of them is a C++23 extended floating point type. It returns
+  /// false for pairs of standard C++23 floating point types.
+  bool doCXX23ExtendedFpTypesRulesApply(QualType T1, QualType T2) const;
+
+  /// C++23 6.8.2p12 [basic.fundamental]
+  /// Returns true if \p Result is FRCR_Lesser or FRCR_Unordered rank.
+  bool
+  isCXX23SmallerOrUnorderedFloatingPointRank(FloatConvRankCompareResult Result) const;
+
+  /// C++23 6.8.2p12 [basic.fundamental]
+  /// Returns true if \p Result is FRCR_Equal, FRCR_Equal_Lesser_Subrank or
+  /// FRCR_Equal_Greater_Subrank.
+  bool isCXX23EqualFloatingPointRank(FloatConvRankCompareResult Result) const;
 
   unsigned getTargetAddressSpace(LangAS AS) const;
 

clang/include/clang/AST/BuiltinTypes.def

@@ -209,10 +209,10 @@ FLOATING_TYPE(Double, DoubleTy)
 // 'long double'
 FLOATING_TYPE(LongDouble, LongDoubleTy)
 
-// '_Float16'
+// '_Float16', 'std::float16_t'
 FLOATING_TYPE(Float16, HalfTy)
 
-// '__bf16'
+// '__bf16', 'std::bfloat16_t'
 FLOATING_TYPE(BFloat16, BFloat16Ty)
 
 // '__float128'

clang/include/clang/AST/Type.h

@@ -2513,6 +2513,13 @@ class alignas(TypeAlignment) Type : public ExtQualsTypeCommonBase {
   bool isComplexType() const;      // C99 6.2.5p11 (complex)
   bool isAnyComplexType() const;   // C99 6.2.5p11 (complex) + Complex Int.
   bool isFloatingType() const;     // C99 6.2.5p11 (real floating + complex)
+  /// C++23 6.8.2p12 [basic.fundamental] (standard floating point + extended
+  /// floating point)
+  bool isCXX23FloatingPointType(const ASTContext &Ctx) const;
+  /// C++23 6.8.2p12 [basic.fundamental] (standard floating point)
+  bool isCXX23StandardFloatingPointType(const ASTContext &Ctx) const;
+  /// C++23 6.8.2p12 [basic.fundamental] (extended floating point)
+  bool isCXX23ExtendedFloatingPointType(const ASTContext &Ctx) const;
   bool isHalfType() const;         // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
   bool isFloat16Type() const;      // C11 extension ISO/IEC TS 18661
   bool isFloat32Type() const;

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -9278,6 +9278,8 @@ def err_cast_pointer_to_non_pointer_int : Error<
 def err_nullptr_cast : Error<
   "cannot cast an object of type %select{'nullptr_t' to %1|%1 to 'nullptr_t'}0"
 >;
+def err_invalid_implicit_floating_point_cast : Error<
+  "floating-point type %0 cannot be implicitly converted to type %1">;
 def err_typecheck_expect_scalar_operand : Error<
   "operand of type %0 where arithmetic or pointer type is required">;
 def err_typecheck_cond_incompatible_operands : Error<

clang/include/clang/Lex/LiteralSupport.h

@@ -82,6 +82,7 @@ class NumericLiteralParser {
   bool isAccum : 1;         // 1.0hk/k/lk/uhk/uk/ulk
   bool isBitInt : 1;        // 1wb, 1uwb (C23) or 1__wb, 1__uwb (Clang extension in C++
                             // mode)
+  bool isBFloat16 : 1;      // 1.0bf
   uint8_t MicrosoftInteger; // Microsoft suffix extension i8, i16, i32, or i64.
 
 

clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConv.h

@@ -13,6 +13,7 @@
 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SMTCONV_H
 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SMTCONV_H
 
+#include "clang/AST/ASTContext.h"
 #include "clang/AST/Expr.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h"
@@ -774,16 +775,24 @@ class SMTConv {
 
     // If we have two real floating types, convert the smaller operand to the
     // bigger result
+    // FIXME: It isn't clear how unordered and equal floating-point ranks should
+    // FIXME: be handled here. For now, they are arbitrarily handled by adding a
+    // FIXME: cast to the RHS to match the LHS.
     // Note: Safe to skip updating bitwidth because this must terminate
-    int order = Ctx.getFloatingTypeOrder(LTy, RTy);
-    if (order > 0) {
+    FloatConvRankCompareResult order = Ctx.getFloatingTypeOrder(LTy, RTy);
+    switch (order) {
+    case FRCR_Unordered:
+    case FRCR_Greater:
+    case FRCR_Equal:
+    case FRCR_Equal_Greater_Subrank:
       RHS = (*doCast)(Solver, RHS, LTy, LBitWidth, RTy, RBitWidth);
       RTy = LTy;
-    } else if (order == 0) {
+      break;
+    case FRCR_Lesser:
+    case FRCR_Equal_Lesser_Subrank:
       LHS = (*doCast)(Solver, LHS, RTy, RBitWidth, LTy, LBitWidth);
       LTy = RTy;
-    } else {
-      llvm_unreachable("Unsupported floating-point type cast!");
+      break;
     }
   }
 };

clang/lib/AST/ASTContext.cpp

@@ -132,6 +132,84 @@ template <> struct llvm::DenseMapInfo<llvm::FoldingSetNodeID> {
     return LHS == RHS;
   }
 };
+constexpr unsigned CXX23FloatRankToIndex(clang::BuiltinType::Kind Kind) {
+  switch (Kind) {
+  case clang::BuiltinType::Float16:
+    return 0;
+  case clang::BuiltinType::BFloat16:
+    return 1;
+  case clang::BuiltinType::Float:
+    return 2;
+  case clang::BuiltinType::Double:
+    return 3;
+  case clang::BuiltinType::LongDouble:
+    return 4;
+  default:
+    // Both __float128 and __ibm128 are compiler extensions, not extended floating points.
+    // __float128 also predates the invention of floating-point types.
+    llvm_unreachable("Not a CXX23+ floating point builtin type");
+  }
+}
+
+// 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}}}};
 
 /// \returns The locations that are relevant when searching for Doc comments
 /// related to \p D.
@@ -1917,6 +1995,10 @@ bool ASTContext::isPromotableIntegerType(QualType T) const {
   return false;
 }
 
+bool ASTContext::isPromotableFloatingType(QualType T) const {
+  return T->getAs<BuiltinType>()->getKind() == BuiltinType::Float;
+}
+
 bool ASTContext::isAlignmentRequired(const Type *T) const {
   return getTypeInfo(T).AlignRequirement != AlignRequirementKind::None;
 }
@@ -7670,27 +7752,69 @@ static FloatingRank getFloatingRank(QualType T) {
   }
 }
 
+/// C++23 6.8.5 [conv.rank]
 /// getFloatingTypeOrder - Compare the rank of the two specified floating
 /// point types, ignoring the domain of the type (i.e. 'double' ==
-/// '_Complex double').  If LHS > RHS, return 1.  If LHS == RHS, return 0. If
-/// LHS < RHS, return -1.
-int ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) const {
+/// '_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
+/// 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.
+FloatConvRankCompareResult
+ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) const {
+  if (LHS->isCXX23FloatingPointType(*this) &&
+      RHS->isCXX23FloatingPointType(*this)) {
+    BuiltinType::Kind LHSKind;
+    BuiltinType::Kind RHSKind;
+    if (const auto *CT = LHS->getAs<ComplexType>())
+      LHSKind = CT->getElementType()->castAs<BuiltinType>()->getKind();
+    else
+      LHSKind = LHS->castAs<BuiltinType>()->getKind();
+    if (const auto *CT = RHS->getAs<ComplexType>())
+      RHSKind = CT->getElementType()->castAs<BuiltinType>()->getKind();
+    else
+      RHSKind = RHS->castAs<BuiltinType>()->getKind();
+    return CXX23FloatingPointConversionRankMap[CXX23FloatRankToIndex(LHSKind)]
+                                              [CXX23FloatRankToIndex(RHSKind)];
+  }
+
   FloatingRank LHSR = getFloatingRank(LHS);
   FloatingRank RHSR = getFloatingRank(RHS);
 
   if (LHSR == RHSR)
-    return 0;
+    return FRCR_Equal;
   if (LHSR > RHSR)
-    return 1;
-  return -1;
+    return FRCR_Greater;
+  return FRCR_Lesser;
 }
 
-int ASTContext::getFloatingTypeSemanticOrder(QualType LHS, QualType RHS) const {
+FloatConvRankCompareResult
+ASTContext::getFloatingTypeSemanticOrder(QualType LHS, QualType RHS) const {
   if (&getFloatTypeSemantics(LHS) == &getFloatTypeSemantics(RHS))
-    return 0;
+    return FRCR_Equal;
   return getFloatingTypeOrder(LHS, RHS);
 }
 
+bool ASTContext::doCXX23ExtendedFpTypesRulesApply(QualType T1,
+                                                  QualType T2) const {
+  return (((T1->isCXX23FloatingPointType(*this) &&
+            T2->isCXX23FloatingPointType(*this))) &&
+          (T1->isCXX23ExtendedFloatingPointType(*this) ||
+           T2->isCXX23ExtendedFloatingPointType(*this)));
+}
+
+bool ASTContext::isCXX23SmallerOrUnorderedFloatingPointRank(
+    FloatConvRankCompareResult Result) const {
+  return (Result == FRCR_Lesser) || (Result == FRCR_Unordered);
+}
+
+bool ASTContext::isCXX23EqualFloatingPointRank(
+    FloatConvRankCompareResult Result) const {
+  return (Result == FRCR_Equal) || (Result == FRCR_Equal_Greater_Subrank) ||
+         (Result == FRCR_Equal_Lesser_Subrank);
+}
+
 /// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This
 /// routine will assert if passed a built-in type that isn't an integer or enum,
 /// or if it is not canonicalized.
@@ -7853,6 +7977,13 @@ QualType ASTContext::getPromotedIntegerType(QualType Promotable) const {
   return (PromotableSize != IntSize) ? IntTy : UnsignedIntTy;
 }
 
+QualType ASTContext::getPromotedFloatingType(QualType Promotable) const {
+  assert(!Promotable.isNull());
+  assert(isPromotableFloatingType(Promotable));
+  assert(Promotable->getAs<BuiltinType>()->getKind() == BuiltinType::Float);
+  return DoubleTy;
+}
+
 /// Recurses in pointer/array types until it finds an objc retainable
 /// type and returns its ownership.
 Qualifiers::ObjCLifetime ASTContext::getInnerObjCOwnership(QualType T) const {

clang/lib/AST/StmtPrinter.cpp

@@ -1458,6 +1458,7 @@ static void PrintFloatingLiteral(raw_ostream &OS, FloatingLiteral *Node,
   case BuiltinType::Float:      OS << 'F'; break;
   case BuiltinType::LongDouble: OS << 'L'; break;
   case BuiltinType::Float128:   OS << 'Q'; break;
+  case BuiltinType::BFloat16:   OS << "BF16"; break;
   }
 }