[CIR] Add support for float16 and bfloat

This patch adds two new CIR floating-point types, namely `!cir.f16` and
`!cir.bf16`, to represent the float16 format and bfloat format, respectively.
CIRGen for the two new types and scalar expressions involving these two new
types is also included in this patch.

This patch converts the clang extension type `_Float16` to `!cir.f16`, and
converts the clang extension type `__bf16` type to `!cir.bf16`.

Author: Lancern

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

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>())

clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

@@ -115,6 +115,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
   //===--------------------------------------------------------------------===//
@@ -478,14 +488,38 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
     } else if (type->isVectorType()) {
       llvm_unreachable("no vector inc/dec yet");
     } else if (type->isRealFloatingType()) {
-      auto isFloatOrDouble = type->isSpecificBuiltinType(BuiltinType::Float) ||
-                             type->isSpecificBuiltinType(BuiltinType::Double);
-      assert(isFloatOrDouble && "Non-float/double NYI");
-
-      // Create the inc/dec operation.
-      auto kind =
-          (isInc ? mlir::cir::UnaryOpKind::Inc : mlir::cir::UnaryOpKind::Dec);
-      value = buildUnaryOp(E, kind, input);
+      if (type->isHalfType())
+        llvm_unreachable("__fp16 type NYI");
+
+      if (value.getType().isa<mlir::cir::SingleType, mlir::cir::DoubleType>()) {
+        // Create the inc/dec operation.
+        auto kind =
+            (isInc ? mlir::cir::UnaryOpKind::Inc : mlir::cir::UnaryOpKind::Dec);
+        value = buildUnaryOp(E, kind, input);
+      } else {
+        // Remaining types are Half, Bfloat16, LongDouble, __ibm128 or
+        // __float128. Convert from float.
+
+        llvm::APFloat F(static_cast<float>(amount));
+        bool ignored;
+        const llvm::fltSemantics *FS;
+        // Don't use getFloatTypeSemantics because Half isn't
+        // necessarily represented using the "half" LLVM type.
+        if (value.getType().isa<mlir::cir::LongDoubleType>())
+          FS = &CGF.getTarget().getLongDoubleFormat();
+        else if (value.getType().isa<mlir::cir::FP16Type>())
+          FS = &CGF.getTarget().getHalfFormat();
+        else if (value.getType().isa<mlir::cir::BF16Type>())
+          FS = &CGF.getTarget().getBFloat16Format();
+        else
+          llvm_unreachable("fp128 / ppc_fp128 NYI");
+        F.convert(*FS, llvm::APFloat::rmTowardZero, &ignored);
+
+        auto loc = CGF.getLoc(E->getExprLoc());
+        auto amt = Builder.getConstant(
+            loc, mlir::cir::FPAttr::get(value.getType(), F));
+        value = Builder.createBinop(value, mlir::cir::BinOpKind::Add, amt);
+      }
 
     } else if (type->isFixedPointType()) {
       llvm_unreachable("no fixed point inc/dec yet");
@@ -549,21 +583,22 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
       return Visit(E->getSubExpr()); // the actual value should be unused
     return buildLoadOfLValue(E);
   }
-  mlir::Value VisitUnaryPlus(const UnaryOperator *E) {
-    // NOTE(cir): QualType function parameter still not used, so don´t replicate
-    // it here yet.
-    QualType promotionTy = getPromotionType(E->getSubExpr()->getType());
+  mlir::Value VisitUnaryPlus(const UnaryOperator *E,
+                             QualType PromotionType = QualType()) {
+    QualType promotionTy = PromotionType.isNull()
+                               ? getPromotionType(E->getSubExpr()->getType())
+                               : PromotionType;
     auto result = VisitPlus(E, promotionTy);
     if (result && !promotionTy.isNull())
-      assert(0 && "not implemented yet");
+      result = buildUnPromotedValue(result, E->getType());
     return buildUnaryOp(E, mlir::cir::UnaryOpKind::Plus, result);
   }
 
   mlir::Value VisitPlus(const UnaryOperator *E, QualType PromotionType) {
     // This differs from gcc, though, most likely due to a bug in gcc.
     TestAndClearIgnoreResultAssign();
     if (!PromotionType.isNull())
-      assert(0 && "scalar promotion not implemented yet");
+      return CGF.buildPromotedScalarExpr(E->getSubExpr(), PromotionType);
     return Visit(E->getSubExpr());
   }
 
@@ -573,14 +608,14 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
     QualType promotionTy = getPromotionType(E->getSubExpr()->getType());
     auto result = VisitMinus(E, promotionTy);
     if (result && !promotionTy.isNull())
-      assert(0 && "not implemented yet");
+      result = buildUnPromotedValue(result, E->getType());
     return buildUnaryOp(E, mlir::cir::UnaryOpKind::Minus, result);
   }
 
   mlir::Value VisitMinus(const UnaryOperator *E, QualType PromotionType) {
     TestAndClearIgnoreResultAssign();
     if (!PromotionType.isNull())
-      assert(0 && "scalar promotion not implemented yet");
+      return CGF.buildPromotedScalarExpr(E->getSubExpr(), PromotionType);
 
     // NOTE: LLVM codegen will lower this directly to either a FNeg
     // or a Sub instruction.  In CIR this will be handled later in LowerToLLVM.
@@ -752,13 +787,17 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
                               QualType DstType, mlir::Type SrcTy,
                               mlir::Type DstTy, ScalarConversionOpts Opts);
 
-  BinOpInfo buildBinOps(const BinaryOperator *E) {
+  BinOpInfo buildBinOps(const BinaryOperator *E,
+                        QualType PromotionType = QualType()) {
     BinOpInfo Result;
-    Result.LHS = Visit(E->getLHS());
-    Result.RHS = Visit(E->getRHS());
-    Result.FullType = E->getType();
-    Result.CompType = E->getType();
-    if (auto VecType = dyn_cast_or_null<VectorType>(E->getType())) {
+    Result.LHS = CGF.buildPromotedScalarExpr(E->getLHS(), PromotionType);
+    Result.RHS = CGF.buildPromotedScalarExpr(E->getRHS(), PromotionType);
+    if (!PromotionType.isNull())
+      Result.FullType = PromotionType;
+    else
+      Result.FullType = E->getType();
+    Result.CompType = Result.FullType;
+    if (const auto *VecType = dyn_cast_or_null<VectorType>(Result.FullType)) {
       Result.CompType = VecType->getElementType();
     }
     Result.Opcode = E->getOpcode();
@@ -793,15 +832,22 @@ 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();
   }
 
   // Binary operators and binary compound assignment operators.
 #define HANDLEBINOP(OP)                                                        \
   mlir::Value VisitBin##OP(const BinaryOperator *E) {                          \
-    return build##OP(buildBinOps(E));                                          \
+    QualType promotionTy = getPromotionType(E->getType());                     \
+    auto result = build##OP(buildBinOps(E, promotionTy));                      \
+    if (result && !promotionTy.isNull())                                       \
+      result = buildUnPromotedValue(result, E->getType());                     \
+    return result;                                                             \
   }                                                                            \
   mlir::Value VisitBin##OP##Assign(const CompoundAssignOperator *E) {          \
     return buildCompoundAssign(E, &ScalarExprEmitter::build##OP);              \
@@ -1053,6 +1099,13 @@ mlir::Value CIRGenFunction::buildScalarExpr(const Expr *E) {
   return ScalarExprEmitter(*this, builder).Visit(const_cast<Expr *>(E));
 }
 
+mlir::Value CIRGenFunction::buildPromotedScalarExpr(const Expr *E,
+                                                    QualType PromotionType) {
+  if (!PromotionType.isNull())
+    return ScalarExprEmitter(*this, builder).buildPromoted(E, PromotionType);
+  return ScalarExprEmitter(*this, builder).Visit(const_cast<Expr *>(E));
+}
+
 [[maybe_unused]] static bool MustVisitNullValue(const Expr *E) {
   // If a null pointer expression's type is the C++0x nullptr_t, then
   // it's not necessarily a simple constant and it must be evaluated
@@ -1885,8 +1938,20 @@ LValue ScalarExprEmitter::buildCompoundAssignLValue(
 
   // Emit the RHS first.  __block variables need to have the rhs evaluated
   // first, plus this should improve codegen a little.
-  OpInfo.RHS = Visit(E->getRHS());
-  OpInfo.FullType = E->getComputationResultType();
+
+  QualType PromotionTypeCR = getPromotionType(E->getComputationResultType());
+  if (PromotionTypeCR.isNull())
+    PromotionTypeCR = E->getComputationResultType();
+
+  QualType PromotionTypeLHS = getPromotionType(E->getComputationLHSType());
+  QualType PromotionTypeRHS = getPromotionType(E->getRHS()->getType());
+
+  if (!PromotionTypeRHS.isNull())
+    OpInfo.RHS = CGF.buildPromotedScalarExpr(E->getRHS(), PromotionTypeRHS);
+  else
+    OpInfo.RHS = Visit(E->getRHS());
+
+  OpInfo.FullType = PromotionTypeCR;
   OpInfo.CompType = OpInfo.FullType;
   if (auto VecType = dyn_cast_or_null<VectorType>(OpInfo.FullType)) {
     OpInfo.CompType = VecType->getElementType();
@@ -1908,16 +1973,20 @@ LValue ScalarExprEmitter::buildCompoundAssignLValue(
   CIRGenFunction::SourceLocRAIIObject sourceloc{
       CGF, CGF.getLoc(E->getSourceRange())};
   SourceLocation Loc = E->getExprLoc();
-  OpInfo.LHS =
-      buildScalarConversion(OpInfo.LHS, LHSTy, E->getComputationLHSType(), Loc);
+  if (!PromotionTypeLHS.isNull())
+    OpInfo.LHS = buildScalarConversion(OpInfo.LHS, LHSTy, PromotionTypeLHS,
+                                       E->getExprLoc());
+  else
+    OpInfo.LHS = buildScalarConversion(OpInfo.LHS, LHSTy,
+                                       E->getComputationLHSType(), Loc);
 
   // Expand the binary operator.
   Result = (this->*Func)(OpInfo);
 
   // Convert the result back to the LHS type,
   // potentially with Implicit Conversion sanitizer check.
-  Result = buildScalarConversion(Result, E->getComputationResultType(), LHSTy,
-                                 Loc, ScalarConversionOpts(CGF.SanOpts));
+  Result = buildScalarConversion(Result, PromotionTypeCR, LHSTy, Loc,
+                                 ScalarConversionOpts(CGF.SanOpts));
 
   // Store the result value into the LHS lvalue. Bit-fields are handled
   // specially because the result is altered by the store, i.e., [C99 6.5.16p1]
@@ -1938,6 +2007,44 @@ mlir::Value ScalarExprEmitter::buildNullValue(QualType Ty, mlir::Location loc) {
   return CGF.buildFromMemory(CGF.CGM.buildNullConstant(Ty, loc), Ty);
 }
 
+mlir::Value ScalarExprEmitter::buildPromoted(const Expr *E,
+                                             QualType PromotionType) {
+  E = E->IgnoreParens();
+  if (const auto *BO = dyn_cast<BinaryOperator>(E)) {
+    switch (BO->getOpcode()) {
+#define HANDLE_BINOP(OP)                                                       \
+  case BO_##OP:                                                                \
+    return build##OP(buildBinOps(BO, PromotionType));
+      HANDLE_BINOP(Add)
+      HANDLE_BINOP(Sub)
+      HANDLE_BINOP(Mul)
+      HANDLE_BINOP(Div)
+#undef HANDLE_BINOP
+    default:
+      break;
+    }
+  } else if (const auto *UO = dyn_cast<UnaryOperator>(E)) {
+    switch (UO->getOpcode()) {
+    case UO_Imag:
+    case UO_Real:
+      llvm_unreachable("NYI");
+    case UO_Minus:
+      return VisitMinus(UO, PromotionType);
+    case UO_Plus:
+      return VisitPlus(UO, PromotionType);
+    default:
+      break;
+    }
+  }
+  auto result = Visit(const_cast<Expr *>(E));
+  if (result) {
+    if (!PromotionType.isNull())
+      return buildPromotedValue(result, PromotionType);
+    return buildUnPromotedValue(result, E->getType());
+  }
+  return result;
+}
+
 mlir::Value ScalarExprEmitter::buildCompoundAssign(
     const CompoundAssignOperator *E,
     mlir::Value (ScalarExprEmitter::*Func)(const BinOpInfo &)) {

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -1086,6 +1086,9 @@ class CIRGenFunction : public CIRGenTypeCache {
   mlir::Value buildScalarExpr(const clang::Expr *E);
   mlir::Value buildScalarConstant(const ConstantEmission &Constant, Expr *E);
 
+  mlir::Value buildPromotedScalarExpr(const clang::Expr *E,
+                                      QualType PromotionType);
+
   mlir::Type getCIRType(const clang::QualType &type);
 
   const CaseStmt *foldCaseStmt(const clang::CaseStmt &S, mlir::Type condType,

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 =

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;

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;