[CIR][CIRGen] Add CIRGen support for float16 and bfloat (llvm#571)

Lancern · xlauko · commit 99c3011bac1a · 2025-03-28T12:55:23.000+01:00
This PR adds two new CIR floating-point types, namely `!cir.f16` and
`!cir.bf16`, to represent the float16 format and bfloat format,
respectively.

This PR converts the clang extension type `_Float16` to `!cir.f16`, and
converts the clang extension type `__bf16` type to `!cir.bf16`. The type
conversion for clang extension type `__fp16` is not included in this PR
since it requires additional work during CIRGen.

Only CIRGen is implemented here, LLVMIR lowering / MLIR lowering should
come next.
diff --git a/clang/include/clang/CIR/Dialect/IR/CIRTypes.td b/clang/include/clang/CIR/Dialect/IR/CIRTypes.td
@@ -150,6 +150,20 @@ def CIR_Double : CIR_FloatType<"Double", "double"> {
   }];
 }
 
+def CIR_FP16 : CIR_FloatType<"FP16", "f16"> {
+  let summary = "CIR type that represents IEEE-754 binary16 format";
+  let description = [{
+    Floating-point type that represents the IEEE-754 binary16 format.
+  }];
+}
+
+def CIR_BFloat16 : CIR_FloatType<"BF16", "bf16"> {
+  let summary = "CIR type that represents";
+  let description = [{
+    Floating-point type that represents the bfloat16 format.
+  }];
+}
+
 def CIR_FP80 : CIR_FloatType<"FP80", "f80"> {
   let summary = "CIR type that represents x87 80-bit floating-point format";
   let description = [{
@@ -179,7 +193,7 @@ def CIR_LongDouble : CIR_FloatType<"LongDouble", "long_double"> {
 
 // Constraints
 
-def CIR_AnyFloat: AnyTypeOf<[CIR_Single, CIR_Double, CIR_LongDouble]>;
+def CIR_AnyFloat: AnyTypeOf<[CIR_Single, CIR_Double, CIR_FP80, CIR_LongDouble]>;
 def CIR_AnyIntOrFloat: AnyTypeOf<[CIR_AnyFloat, CIR_IntType]>;
 
 //===----------------------------------------------------------------------===//
@@ -475,7 +489,7 @@ def CIR_StructType : Type<CPred<"$_self.isa<::mlir::cir::StructType>()">,
 def CIR_AnyType : AnyTypeOf<[
   CIR_IntType, CIR_PointerType, CIR_DataMemberType, CIR_BoolType, CIR_ArrayType,
   CIR_VectorType, CIR_FuncType, CIR_VoidType, CIR_StructType, CIR_ExceptionInfo,
-  CIR_AnyFloat,
+  CIR_AnyFloat, CIR_FP16, CIR_BFloat16
 ]>;
 
 #endif // MLIR_CIR_DIALECT_CIR_TYPES
diff --git a/clang/lib/CIR/CodeGen/CIRGenBuilder.h b/clang/lib/CIR/CodeGen/CIRGenBuilder.h
@@ -250,6 +250,10 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
       return mlir::cir::FPAttr::getZero(fltType);
     if (auto fltType = ty.dyn_cast<mlir::cir::DoubleType>())
       return mlir::cir::FPAttr::getZero(fltType);
+    if (auto fltType = ty.dyn_cast<mlir::cir::FP16Type>())
+      return mlir::cir::FPAttr::getZero(fltType);
+    if (auto fltType = ty.dyn_cast<mlir::cir::BF16Type>())
+      return mlir::cir::FPAttr::getZero(fltType);
     if (auto arrTy = ty.dyn_cast<mlir::cir::ArrayType>())
       return getZeroAttr(arrTy);
     if (auto ptrTy = ty.dyn_cast<mlir::cir::PointerType>())
diff --git a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
@@ -132,6 +132,16 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
   /// Emit a value that corresponds to null for the given type.
   mlir::Value buildNullValue(QualType Ty, mlir::Location loc);
 
+  mlir::Value buildPromotedValue(mlir::Value result, QualType PromotionType) {
+    return Builder.createFloatingCast(result, ConvertType(PromotionType));
+  }
+
+  mlir::Value buildUnPromotedValue(mlir::Value result, QualType ExprType) {
+    return Builder.createFloatingCast(result, ConvertType(ExprType));
+  }
+
+  mlir::Value buildPromoted(const Expr *E, QualType PromotionType);
+
   //===--------------------------------------------------------------------===//
   //                            Visitor Methods
   //===--------------------------------------------------------------------===//
@@ -896,8 +906,11 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
     if (auto *CT = Ty->getAs<ComplexType>()) {
       llvm_unreachable("NYI");
     }
-    if (Ty.UseExcessPrecision(CGF.getContext()))
-      llvm_unreachable("NYI");
+    if (Ty.UseExcessPrecision(CGF.getContext())) {
+      if (auto *VT = Ty->getAs<VectorType>())
+        llvm_unreachable("NYI");
+      return CGF.getContext().FloatTy;
+    }
     return QualType();
   }
 
diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.cpp b/clang/lib/CIR/CodeGen/CIRGenModule.cpp
@@ -131,13 +131,11 @@ CIRGenModule::CIRGenModule(mlir::MLIRContext &context,
   // Initialize CIR pointer types cache.
   VoidPtrTy = ::mlir::cir::PointerType::get(builder.getContext(), VoidTy);
 
-  // TODO: HalfTy
-  // TODO: BFloatTy
+  FP16Ty = ::mlir::cir::FP16Type::get(builder.getContext());
+  BFloat16Ty = ::mlir::cir::BF16Type::get(builder.getContext());
   FloatTy = ::mlir::cir::SingleType::get(builder.getContext());
   DoubleTy = ::mlir::cir::DoubleType::get(builder.getContext());
   FP80Ty = ::mlir::cir::FP80Type::get(builder.getContext());
-  // TODO(cir): perhaps we should abstract long double variations into a custom
-  // cir.long_double type. Said type would also hold the semantics for lowering.
 
   // TODO: PointerWidthInBits
   PointerAlignInBytes =
diff --git a/clang/lib/CIR/CodeGen/CIRGenTypeCache.h b/clang/lib/CIR/CodeGen/CIRGenTypeCache.h
@@ -34,10 +34,9 @@ struct CIRGenTypeCache {
   mlir::cir::IntType SInt8Ty, SInt16Ty, SInt32Ty, SInt64Ty;
   // usigned char, unsigned, unsigned short, unsigned long
   mlir::cir::IntType UInt8Ty, UInt16Ty, UInt32Ty, UInt64Ty;
-  /// half, bfloat, float, double
-  // mlir::Type HalfTy, BFloatTy;
-  // TODO(cir): perhaps we should abstract long double variations into a custom
-  // cir.long_double type. Said type would also hold the semantics for lowering.
+  /// half, bfloat, float, double, fp80
+  mlir::cir::FP16Type FP16Ty;
+  mlir::cir::BF16Type BFloat16Ty;
   mlir::cir::SingleType FloatTy;
   mlir::cir::DoubleType DoubleTy;
   mlir::cir::FP80Type FP80Ty;
diff --git a/clang/lib/CIR/CodeGen/CIRGenTypes.cpp b/clang/lib/CIR/CodeGen/CIRGenTypes.cpp
@@ -464,14 +464,14 @@ mlir::Type CIRGenTypes::ConvertType(QualType T) {
       break;
 
     case BuiltinType::Float16:
-      ResultType = Builder.getF16Type();
+      ResultType = CGM.FP16Ty;
       break;
     case BuiltinType::Half:
       // Should be the same as above?
       assert(0 && "not implemented");
       break;
     case BuiltinType::BFloat16:
-      ResultType = Builder.getBF16Type();
+      ResultType = CGM.BFloat16Ty;
       break;
     case BuiltinType::Float:
       ResultType = CGM.FloatTy;
diff --git a/clang/lib/CIR/CodeGen/UnimplementedFeatureGuarding.h b/clang/lib/CIR/CodeGen/UnimplementedFeatureGuarding.h
@@ -130,6 +130,8 @@ struct UnimplementedFeature {
   static bool shouldEmitLifetimeMarkers() { return false; }
   static bool peepholeProtection() { return false; }
   static bool CGCapturedStmtInfo() { return false; }
+  static bool CGFPOptionsRAII() { return false; }
+  static bool getFPFeaturesInEffect() { return false; }
   static bool cxxABI() { return false; }
   static bool openCL() { return false; }
   static bool CUDA() { return false; }
diff --git a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp
@@ -691,6 +691,48 @@ DoubleType::getPreferredAlignment(const ::mlir::DataLayout &dataLayout,
   return (uint64_t)(getWidth() / 8);
 }
 
+const llvm::fltSemantics &FP16Type::getFloatSemantics() const {
+  return llvm::APFloat::IEEEhalf();
+}
+
+llvm::TypeSize
+FP16Type::getTypeSizeInBits(const mlir::DataLayout &dataLayout,
+                            mlir::DataLayoutEntryListRef params) const {
+  return llvm::TypeSize::getFixed(getWidth());
+}
+
+uint64_t FP16Type::getABIAlignment(const mlir::DataLayout &dataLayout,
+                                   mlir::DataLayoutEntryListRef params) const {
+  return (uint64_t)(getWidth() / 8);
+}
+
+uint64_t
+FP16Type::getPreferredAlignment(const ::mlir::DataLayout &dataLayout,
+                                ::mlir::DataLayoutEntryListRef params) const {
+  return (uint64_t)(getWidth() / 8);
+}
+
+const llvm::fltSemantics &BF16Type::getFloatSemantics() const {
+  return llvm::APFloat::BFloat();
+}
+
+llvm::TypeSize
+BF16Type::getTypeSizeInBits(const mlir::DataLayout &dataLayout,
+                            mlir::DataLayoutEntryListRef params) const {
+  return llvm::TypeSize::getFixed(getWidth());
+}
+
+uint64_t BF16Type::getABIAlignment(const mlir::DataLayout &dataLayout,
+                                   mlir::DataLayoutEntryListRef params) const {
+  return (uint64_t)(getWidth() / 8);
+}
+
+uint64_t
+BF16Type::getPreferredAlignment(const ::mlir::DataLayout &dataLayout,
+                                ::mlir::DataLayoutEntryListRef params) const {
+  return (uint64_t)(getWidth() / 8);
+}
+
 const llvm::fltSemantics &FP80Type::getFloatSemantics() const {
   return llvm::APFloat::x87DoubleExtended();
 }
