[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, LLVMIR lowering, and MLIR lowering for the two new types are 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`. The type conversion for clang extension type `__fp16` is not included in this patch since it requires additional work during CIRGen.
llvm · May 2, 2024 · fa1f731 · fa1f731
1 parent bdfdb22
commit fa1f731
Show file tree

Hide file tree

Showing 11 changed files with 438 additions and 71 deletions.
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,8 @@ 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_FP16, CIR_BFloat16, 
+                             CIR_FP80, CIR_LongDouble]>;
 def CIR_AnyIntOrFloat: AnyTypeOf<[CIR_AnyFloat, CIR_IntType]>;
 
 //===----------------------------------------------------------------------===//

diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.cpp b/clang/lib/CIR/CodeGen/CIRGenModule.cpp
@@ -131,8 +131,8 @@ 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());

diff --git a/clang/lib/CIR/CodeGen/CIRGenTypeCache.h b/clang/lib/CIR/CodeGen/CIRGenTypeCache.h
@@ -35,9 +35,10 @@ struct CIRGenTypeCache {
   // 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.
+  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/Dialect/IR/CIRTypes.cpp b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp
@@ -692,6 +692,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();
 }

diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
@@ -3021,6 +3021,12 @@ void prepareTypeConverter(mlir::LLVMTypeConverter &converter,
   converter.addConversion([&](mlir::cir::DoubleType type) -> mlir::Type {
     return mlir::FloatType::getF64(type.getContext());
   });
+  converter.addConversion([&](mlir::cir::FP16Type type) -> mlir::Type {
+    return mlir::FloatType::getF16(type.getContext());
+  });
+  converter.addConversion([&](mlir::cir::BF16Type type) -> mlir::Type {
+    return mlir::FloatType::getBF16(type.getContext());
+  });
   converter.addConversion([&](mlir::cir::FP80Type type) -> mlir::Type {
     return mlir::FloatType::getF80(type.getContext());
   });

diff --git a/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRToMLIR.cpp b/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRToMLIR.cpp
@@ -753,6 +753,12 @@ static mlir::TypeConverter prepareTypeConverter() {
   converter.addConversion([&](mlir::cir::DoubleType type) -> mlir::Type {
     return mlir::FloatType::getF64(type.getContext());
   });
+  converter.addConversion([&](mlir::cir::FP16Type type) -> mlir::Type {
+    return mlir::FloatType::getF16(type.getContext());
+  });
+  converter.addConversion([&](mlir::cir::BF16Type type) -> mlir::Type {
+    return mlir::FloatType::getBF16(type.getContext());
+  });
   converter.addConversion([&](mlir::cir::FP80Type type) -> mlir::Type {
     return mlir::FloatType::getF80(type.getContext());
   });

diff --git a/clang/test/CIR/CodeGen/bfloat16-arithmetic.c b/clang/test/CIR/CodeGen/bfloat16-arithmetic.c
@@ -0,0 +1,99 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s
+
+__bf16 add1(__bf16 a, __bf16 b) {
+  return a + b;
+}
+
+//      CHECK: cir.func @add1(%{{.+}}: !cir.bf16 loc({{.+}}), %{{.+}}: !cir.bf16 loc({{.+}})) -> !cir.bf16
+//      CHECK:   %[[#A:]] = cir.load %{{.+}} : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %[[#B:]] = cir.load %{{.+}} : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %{{.+}} = cir.binop(add, %[[#A]], %[[#B]]) : !cir.bf16
+//      CHECK: }
+
+__bf16 add2(__bf16 a, __bf16 b, __bf16 c) {
+  return a + b + c;
+}
+
+//      CHECK: cir.func @add2(%{{.+}}: !cir.bf16 loc({{.+}}), %{{.+}}: !cir.bf16 loc({{.+}}), %{{.+}}: !cir.bf16 loc({{.+}})) -> !cir.bf16
+//      CHECK:   %[[#A:]] = cir.load %{{.+}} : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %[[#B:]] = cir.load %{{.+}} : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %[[#A_B:]] = cir.binop(add, %[[#A]], %[[#B]]) : !cir.bf16
+// CHECK-NEXT:   %[[#C:]] = cir.load %{{.+}} : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %{{.+}} = cir.binop(add, %[[#A_B]], %[[#C]]) : !cir.bf16
+//      CHECK: }
+
+__bf16 div(__bf16 a, __bf16 b) {
+  return a / b;
+}
+
+//      CHECK: cir.func @div(%{{.+}}: !cir.bf16 loc({{.+}}), %{{.+}}: !cir.bf16 loc({{.+}})) -> !cir.bf16
+//      CHECK:   %[[#A:]] = cir.load %{{.+}} : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %[[#B:]] = cir.load %{{.+}} : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %{{.+}} = cir.binop(div, %[[#A]], %[[#B]]) : !cir.bf16
+//      CHECK: }
+
+__bf16 mul(__bf16 a, __bf16 b) {
+  return a * b;
+}
+
+//      CHECK: cir.func @mul(%{{.+}}: !cir.bf16 loc({{.+}}), %{{.+}}: !cir.bf16 loc({{.+}})) -> !cir.bf16
+//      CHECK:   %[[#A:]] = cir.load %{{.+}} : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %[[#B:]] = cir.load %{{.+}} : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %{{.+}} = cir.binop(mul, %[[#A]], %[[#B]]) : !cir.bf16
+//      CHECK: }
+
+__bf16 add_and_mul1(__bf16 a, __bf16 b, __bf16 c, __bf16 d) {
+  return a * b + c * d;
+}
+
+//      CHECK: cir.func @add_and_mul1(%{{.+}}: !cir.bf16 loc({{.+}}), %{{.+}}: !cir.bf16 loc({{.+}}), %{{.+}}: !cir.bf16 loc({{.+}}), %{{.+}}: !cir.bf16 loc({{.+}}])) -> !cir.bf16
+//      CHECK:   %[[#A:]] = cir.load %{{.+}} : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %[[#B:]] = cir.load %{{.+}} : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %[[#A_B:]] = cir.binop(mul, %[[#A]], %[[#B]]) : !cir.bf16
+// CHECK-NEXT:   %[[#C:]] = cir.load %2 : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %[[#D:]] = cir.load %3 : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %[[#C_D:]] = cir.binop(mul, %[[#C]], %[[#D]]) : !cir.bf16
+// CHECK-NEXT:   %{{.+}} = cir.binop(add, %[[#A_B]], %[[#C_D]]) : !cir.bf16
+//      CHECK: }
+
+__bf16 add_and_mul2(__bf16 a, __bf16 b, __bf16 c) {
+  return (a - 6 * b) + c;
+}
+
+//      CHECK: cir.func @add_and_mul2(%{{.+}}: !cir.bf16 loc({{.+}}), %{{.+}}: !cir.bf16 loc({{.+}}), %{{.+}}: !cir.bf16 loc({{.+}})) -> !cir.bf16
+//      CHECK:   %[[#A:]] = cir.load %{{.+}} : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %[[#SIX:]] = cir.const(#cir.int<6> : !s32i) : !s32i
+// CHECK-NEXT:   %[[#SIX_FP:]] = cir.cast(int_to_float, %[[#SIX]] : !s32i), !cir.bf16
+// CHECK-NEXT:   %[[#B:]] = cir.load %{{.+}} : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %[[#SIX_B:]] = cir.binop(mul, %[[#SIX_FP]], %[[#B]]) : !cir.bf16
+// CHECK-NEXT:   %[[#ADD_LHS:]] = cir.binop(sub, %[[#A]], %[[#SIX_B]]) : !cir.bf16
+// CHECK-NEXT:   %[[#C:]] = cir.load %2 : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %{{.+}} = cir.binop(add, %[[#ADD_LHS]], %[[#C]]) : !cir.bf16
+//      CHECK: }
+
+__bf16 addcompound(__bf16 a, __bf16 c) {
+  c += a;
+  return c;
+}
+
+//      CHECK: cir.func @addcompound(%{{.+}}: !cir.bf16 loc({{.+}}), %{{.+}}: !cir.bf16 loc({{.+}})) -> !cir.bf16
+//      CHECK:   %[[#A:]] = cir.load %{{.+}} : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %[[#C_OLD:]] = cir.load %[[#C_PTR:]] : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %[[#C_NEW:]] = cir.binop(add, %[[#C_OLD]], %[[#A]]) : !cir.bf16
+// CHECK-NEXT:   cir.store %[[#C_NEW]], %[[#C_PTR]] : !cir.bf16, !cir.ptr<!cir.bf16>
+//      CHECK: }
+
+__bf16 mulcompound_int__bf16(int a, __bf16 c) {
+  a *= c;
+  return c;
+}
+
+//      CHECK: cir.func @mulcompound_int__bf16(%{{.+}}: !s32i loc({{.+}}), %{{.+}}: !cir.bf16 loc({{.+}})) -> !cir.bf16
+//      CHECK:   %[[#C:]] = cir.load %{{.+}} : !cir.ptr<!cir.bf16>, !cir.bf16
+// CHECK-NEXT:   %[[#A_OLD:]] = cir.load %[[#A_PTR:]] : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:   %[[#A_FP:]] = cir.cast(int_to_float, %[[#A_OLD]] : !s32i), !cir.bf16
+// CHECK-NEXT:   %[[#A_NEW_FP:]] = cir.binop(mul, %[[#A_FP]], %[[#C]]) : !cir.bf16
+// CHECK-NEXT:   %[[#A_NEW:]] = cir.cast(float_to_int, %[[#A_NEW_FP]] : !cir.bf16), !s32i
+// CHECK-NEXT:   cir.store %[[#A_NEW]], %[[#A_PTR]] : !s32i, !cir.ptr<!s32i>
+//      CHECK: }
diff --git a/clang/test/CIR/CodeGen/float16-arithmetic.c b/clang/test/CIR/CodeGen/float16-arithmetic.c
@@ -0,0 +1,99 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s
+
+_Float16 add1(_Float16 a, _Float16 b) {
+  return a + b;
+}
+
+//      CHECK: cir.func @add1(%{{.+}}: !cir.f16 loc({{.+}}), %{{.+}}: !cir.f16 loc({{.+}})) -> !cir.f16
+//      CHECK:   %[[#A:]] = cir.load %{{.+}} : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %[[#B:]] = cir.load %{{.+}} : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %{{.+}} = cir.binop(add, %[[#A]], %[[#B]]) : !cir.f16
+//      CHECK: }
+
+_Float16 add2(_Float16 a, _Float16 b, _Float16 c) {
+  return a + b + c;
+}
+
+//      CHECK: cir.func @add2(%{{.+}}: !cir.f16 loc({{.+}}), %{{.+}}: !cir.f16 loc({{.+}}), %{{.+}}: !cir.f16 loc({{.+}})) -> !cir.f16
+//      CHECK:   %[[#A:]] = cir.load %{{.+}} : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %[[#B:]] = cir.load %{{.+}} : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %[[#A_B:]] = cir.binop(add, %[[#A]], %[[#B]]) : !cir.f16
+// CHECK-NEXT:   %[[#C:]] = cir.load %{{.+}} : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %{{.+}} = cir.binop(add, %[[#A_B]], %[[#C]]) : !cir.f16
+//      CHECK: }
+
+_Float16 div(_Float16 a, _Float16 b) {
+  return a / b;
+}
+
+//      CHECK: cir.func @div(%{{.+}}: !cir.f16 loc({{.+}}), %{{.+}}: !cir.f16 loc({{.+}})) -> !cir.f16
+//      CHECK:   %[[#A:]] = cir.load %{{.+}} : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %[[#B:]] = cir.load %{{.+}} : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %{{.+}} = cir.binop(div, %[[#A]], %[[#B]]) : !cir.f16
+//      CHECK: }
+
+_Float16 mul(_Float16 a, _Float16 b) {
+  return a * b;
+}
+
+//      CHECK: cir.func @mul(%{{.+}}: !cir.f16 loc({{.+}}), %{{.+}}: !cir.f16 loc({{.+}})) -> !cir.f16
+//      CHECK:   %[[#A:]] = cir.load %{{.+}} : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %[[#B:]] = cir.load %{{.+}} : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %{{.+}} = cir.binop(mul, %[[#A]], %[[#B]]) : !cir.f16
+//      CHECK: }
+
+_Float16 add_and_mul1(_Float16 a, _Float16 b, _Float16 c, _Float16 d) {
+  return a * b + c * d;
+}
+
+//      CHECK: cir.func @add_and_mul1(%{{.+}}: !cir.f16 loc({{.+}}), %{{.+}}: !cir.f16 loc({{.+}}), %{{.+}}: !cir.f16 loc({{.+}}), %{{.+}}: !cir.f16 loc({{.+}}])) -> !cir.f16
+//      CHECK:   %[[#A:]] = cir.load %{{.+}} : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %[[#B:]] = cir.load %{{.+}} : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %[[#A_B:]] = cir.binop(mul, %[[#A]], %[[#B]]) : !cir.f16
+// CHECK-NEXT:   %[[#C:]] = cir.load %2 : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %[[#D:]] = cir.load %3 : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %[[#C_D:]] = cir.binop(mul, %[[#C]], %[[#D]]) : !cir.f16
+// CHECK-NEXT:   %{{.+}} = cir.binop(add, %[[#A_B]], %[[#C_D]]) : !cir.f16
+//      CHECK: }
+
+_Float16 add_and_mul2(_Float16 a, _Float16 b, _Float16 c) {
+  return (a - 6 * b) + c;
+}
+
+//      CHECK: cir.func @add_and_mul2(%{{.+}}: !cir.f16 loc({{.+}}), %{{.+}}: !cir.f16 loc({{.+}}), %{{.+}}: !cir.f16 loc({{.+}})) -> !cir.f16
+//      CHECK:   %[[#A:]] = cir.load %{{.+}} : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %[[#SIX:]] = cir.const(#cir.int<6> : !s32i) : !s32i
+// CHECK-NEXT:   %[[#SIX_FP:]] = cir.cast(int_to_float, %[[#SIX]] : !s32i), !cir.f16
+// CHECK-NEXT:   %[[#B:]] = cir.load %{{.+}} : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %[[#SIX_B:]] = cir.binop(mul, %[[#SIX_FP]], %[[#B]]) : !cir.f16
+// CHECK-NEXT:   %[[#ADD_LHS:]] = cir.binop(sub, %[[#A]], %[[#SIX_B]]) : !cir.f16
+// CHECK-NEXT:   %[[#C:]] = cir.load %2 : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %{{.+}} = cir.binop(add, %[[#ADD_LHS]], %[[#C]]) : !cir.f16
+//      CHECK: }
+
+_Float16 addcompound(_Float16 a, _Float16 c) {
+  c += a;
+  return c;
+}
+
+//      CHECK: cir.func @addcompound(%{{.+}}: !cir.f16 loc({{.+}}), %{{.+}}: !cir.f16 loc({{.+}})) -> !cir.f16
+//      CHECK:   %[[#A:]] = cir.load %{{.+}} : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %[[#C_OLD:]] = cir.load %[[#C_PTR:]] : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %[[#C_NEW:]] = cir.binop(add, %[[#C_OLD]], %[[#A]]) : !cir.f16
+// CHECK-NEXT:   cir.store %[[#C_NEW]], %[[#C_PTR]] : !cir.f16, !cir.ptr<!cir.f16>
+//      CHECK: }
+
+_Float16 mulcompound_int_float16(int a, _Float16 c) {
+  a *= c;
+  return c;
+}
+
+//      CHECK: cir.func @mulcompound_int_float16(%{{.+}}: !s32i loc({{.+}}), %{{.+}}: !cir.f16 loc({{.+}})) -> !cir.f16
+//      CHECK:   %[[#C:]] = cir.load %{{.+}} : !cir.ptr<!cir.f16>, !cir.f16
+// CHECK-NEXT:   %[[#A_OLD:]] = cir.load %[[#A_PTR:]] : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:   %[[#A_FP:]] = cir.cast(int_to_float, %[[#A_OLD]] : !s32i), !cir.f16
+// CHECK-NEXT:   %[[#A_NEW_FP:]] = cir.binop(mul, %[[#A_FP]], %[[#C]]) : !cir.f16
+// CHECK-NEXT:   %[[#A_NEW:]] = cir.cast(float_to_int, %[[#A_NEW_FP]] : !cir.f16), !s32i
+// CHECK-NEXT:   cir.store %[[#A_NEW]], %[[#A_PTR]] : !s32i, !cir.ptr<!s32i>
+//      CHECK: }