[clang] [CIR] Implement matrix scalar multiplication support (PR #230815)
via cfe-commits
cfe-commits at lists.llvm.org
Sat Oct 10 10:16:25 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clangir
Author: Amr Hesham (AmrDeveloper)
<details>
<summary>Changes</summary>
Implement multiplication op support between matrix and scalar types.
Issue https://github.com/llvm/llvm-project/issues/221772
---
Full diff: https://github.com/llvm/llvm-project/pull/230815.diff
3 Files Affected:
- (modified) clang/include/clang/CIR/Dialect/IR/CIROps.td (+8-5)
- (modified) clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp (+12-3)
- (modified) clang/test/CIR/CodeGen/matrix.cpp (+57)
``````````diff
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
index 6a7d8ca8f7fc9..b116f58813f58 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIROps.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -2859,12 +2859,12 @@ def CIR_SubOp
// MulOp
//===----------------------------------------------------------------------===//
-def CIR_MulOp : CIR_BinaryOp<"mul", CIR_AnyIntOrVecOfIntType> {
+def CIR_MulOp : CIR_BinaryOp<"mul", CIR_AnyIntOrVecOrMatrixOfIntType> {
let summary = "Integer multiplication";
let description = [{
The `cir.mul` operation performs multiplication on integer operands. Both
operands and the result must have the same integer or vector-of-integer
- type.
+ or matrix-of-integer type.
The optional `nsw` (no signed wrap) and `nuw` (no unsigned wrap) unit
attributes indicate that the result is poison if signed or unsigned
@@ -2877,11 +2877,13 @@ def CIR_MulOp : CIR_BinaryOp<"mul", CIR_AnyIntOrVecOfIntType> {
%1 = cir.mul nsw %a, %b : !s32i
%2 = cir.mul nuw %a, %b : !u32i
%3 = cir.mul %va, %vb : !cir.vector<4 x !s32i>
+ %4 = cir.mul %ma, %mb : !cir.matrix<3 x 3 x !s32i>
```
}];
let arguments = (ins
- CIR_AnyIntOrVecOfIntType:$lhs, CIR_AnyIntOrVecOfIntType:$rhs,
+ CIR_AnyIntOrVecOrMatrixOfIntType:$lhs,
+ CIR_AnyIntOrVecOrMatrixOfIntType:$rhs,
UnitProp:$no_signed_wrap,
UnitProp:$no_unsigned_wrap
);
@@ -2997,7 +2999,7 @@ def CIR_FSubOp : CIR_FPBinaryOp<"fsub"> {
let description = [{
The `cir.fsub` operation performs floating-point subtraction on its
operands. Both operands and the result must have the same floating-point
- scalar or vector-of-float type.
+ scalar or vector-of-float or matrix-of-float type..
Example:
@@ -3005,6 +3007,7 @@ def CIR_FSubOp : CIR_FPBinaryOp<"fsub"> {
%0 = cir.fsub %a, %b : !cir.float
%1 = cir.fsub %a, %b : !cir.double
%2 = cir.fsub %va, %vb : !cir.vector<4 x !cir.float>
+ %3 = cir.fsub %ma, %mb : !cir.matrix<3 x 3 x !cir.float>
```
}];
@@ -3015,7 +3018,7 @@ def CIR_FSubOp : CIR_FPBinaryOp<"fsub"> {
// FMulOp
//===----------------------------------------------------------------------===//
-def CIR_FMulOp : CIR_FPBinaryOp<"fmul"> {
+def CIR_FMulOp : CIR_FPBinaryOp<"fmul", [], CIR_AnyFloatOrVecOrMatrixOfFloatType> {
let summary = "Floating-point multiplication";
let description = [{
The `cir.fmul` operation performs floating-point multiplication on its
diff --git a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
index 5209ca959de1e..da248331ea9b6 100644
--- a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
@@ -2252,9 +2252,18 @@ mlir::Value ScalarExprEmitter::emitMul(const BinOpInfo &ops) {
}
}
if (ops.fullType->isConstantMatrixType()) {
- assert(!cir::MissingFeatures::matrixType());
- cgf.cgm.errorNYI("ScalarExprEmitter::emitMul: matrix types");
- return {};
+ if (isa<cir::MatrixType>(ops.lhs.getType()) &&
+ isa<cir::MatrixType>(ops.rhs.getType())) {
+ cgf.cgm.errorNYI("ScalarExprEmitter::emitMul: matrix matrix multiplication");
+ return {};
+ }
+
+ CIRGenFunction::CIRGenFPOptionsRAII fpOptsRAII(cgf, ops.fpFeatures);
+ auto [lhs, rhs] =
+ builder.splatMatrixOpOperandsIfNecessary(loc, ops.lhs, ops.rhs);
+ if (cir::isFPOrVectorOrMatrixOfFPType(lhs.getType()))
+ return builder.createFMul(loc, lhs, rhs);
+ return builder.createMul(loc, lhs, rhs);
}
if (ops.compType->isUnsignedIntegerType() &&
cgf.sanOpts.has(SanitizerKind::UnsignedIntegerOverflow) &&
diff --git a/clang/test/CIR/CodeGen/matrix.cpp b/clang/test/CIR/CodeGen/matrix.cpp
index 19d87a8829aab..b5a4dfe3e5391 100644
--- a/clang/test/CIR/CodeGen/matrix.cpp
+++ b/clang/test/CIR/CodeGen/matrix.cpp
@@ -8,6 +8,7 @@
typedef float matrix3x3 __attribute__((matrix_type(3, 3)));
typedef float matrix3x2 __attribute__((matrix_type(3, 2)));
typedef float matrix2x3 __attribute__((matrix_type(2, 3)));
+typedef int matrixi3x3 __attribute__((matrix_type(3, 3)));
matrix3x3 a;
@@ -213,3 +214,59 @@ void matrix_subscript_expr_non_const_indices() {
// LLVM: %[[ELEM:.*]] = extractelement <9 x float> %[[TMP_MATRIX]], i64 %[[FLAT_IDX]]
// LLVM: store float %[[ELEM]], ptr %[[B_ADDR]], align 4
+
+void fp_matrix_scalar_mul() {
+ matrix3x3 matrix;
+ float scalar = 3.0f;
+ matrix3x3 result = matrix * scalar;
+}
+
+// CIR: %[[MATRIX_ADDR:.*]] = cir.alloca "matrix" {{.*}} : !cir.ptr<!cir.matrix<3 x 3 x !cir.float>>
+// CIR: %[[SCALAR_ADDR:.*]] = cir.alloca "scalar" {{.*}} init : !cir.ptr<!cir.float>
+// CIR: %[[RESULT_ADDR:.*]] = cir.alloca "result" {{.*}} init : !cir.ptr<!cir.matrix<3 x 3 x !cir.float>>
+// CIR: %[[CONST_3:.*]] = cir.const #cir.fp<3.000000e+00> : !cir.float
+// CIR: cir.store {{.*}} %[[CONST_3]], %[[SCALAR_ADDR]] : !cir.float, !cir.ptr<!cir.float>
+// CIR: %[[TMP_MATRIX:.*]] = cir.load {{.*}} %[[MATRIX_ADDR]] : !cir.ptr<!cir.matrix<3 x 3 x !cir.float>>, !cir.matrix<3 x 3 x !cir.float>
+// CIR: %[[TMP_SCALAR:.*]] = cir.load {{.*}} %[[SCALAR_ADDR]] : !cir.ptr<!cir.float>, !cir.float
+// CIR: %[[SPLAT_SCALAR:.*]] = cir.vec.splat %[[TMP_SCALAR]] : !cir.float, !cir.matrix<3 x 3 x !cir.float>
+// CIR: %[[RESULT:.*]] = cir.fmul %[[TMP_MATRIX]], %[[SPLAT_SCALAR]] : !cir.matrix<3 x 3 x !cir.float>
+// CIR: cir.store {{.*}} %[[RESULT]], %[[RESULT_ADDR]] : !cir.matrix<3 x 3 x !cir.float>, !cir.ptr<!cir.matrix<3 x 3 x !cir.float>>
+
+// LLVM: %[[MATRIX_ADDR:.*]] = alloca [9 x float], align 4
+// LLVM: %[[SCALAR_ADDR:.*]] = alloca float, align 4
+// LLVM: %[[RESULT_ADDR:.*]] = alloca [9 x float], align 4
+// LLVM: store float 3.000000e+00, ptr %[[SCALAR_ADDR]], align 4
+// LLVM: %[[TMP_MATRIX:.*]] = load <9 x float>, ptr %[[MATRIX_ADDR]], align 4
+// LLVM: %[[TMP_SCALAR:.*]] = load float, ptr %[[SCALAR_ADDR]], align 4
+// LLVM: %[[SPLAT_SCALAR_INSERT:.*]] = insertelement <9 x float> poison, float %[[TMP_SCALAR]], i64 0
+// LLVM: %[[SPLAT_SCALAR:.*]] = shufflevector <9 x float> %[[SPLAT_SCALAR_INSERT]], <9 x float> poison, <9 x i32> zeroinitializer
+// LLVM: %[[RESULT:.*]] = fmul <9 x float> %[[TMP_MATRIX]], %[[SPLAT_SCALAR]]
+// LLVM: store <9 x float> %[[RESULT]], ptr %[[RESULT_ADDR]], align 4
+
+void int_matrix_scalar_mul() {
+ matrixi3x3 matrix;
+ int scalar = 3;
+ matrixi3x3 result = matrix * scalar;
+}
+
+// CIR: %[[MATRIX_ADDR:.*]] = cir.alloca "matrix" {{.*}} : !cir.ptr<!cir.matrix<3 x 3 x !s32i>>
+// CIR: %[[SCALAR_ADDR:.*]] = cir.alloca "scalar" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[RESULT_ADDR:.*]] = cir.alloca "result" {{.*}} init : !cir.ptr<!cir.matrix<3 x 3 x !s32i>>
+// CIR: %[[CONST_3:.*]] = cir.const #cir.int<3> : !s32i
+// CIR: cir.store {{.*}} %[[CONST_3]], %[[SCALAR_ADDR]] : !s32i, !cir.ptr<!s32i>
+// CIR: %[[TMP_MATRIX:.*]] = cir.load {{.*}} %[[MATRIX_ADDR]] : !cir.ptr<!cir.matrix<3 x 3 x !s32i>>, !cir.matrix<3 x 3 x !s32i>
+// CIR: %[[TMP_SCALAR:.*]] = cir.load {{.*}} %[[SCALAR_ADDR]] : !cir.ptr<!s32i>, !s32i
+// CIR: %[[SPLAT_SCALAR:.*]] = cir.vec.splat %[[TMP_SCALAR]] : !s32i, !cir.matrix<3 x 3 x !s32i>
+// CIR: %[[RESULT:.*]] = cir.mul %[[TMP_MATRIX]], %[[SPLAT_SCALAR]] : !cir.matrix<3 x 3 x !s32i>
+// CIR: cir.store {{.*}} %[[RESULT]], %[[RESULT_ADDR]] : !cir.matrix<3 x 3 x !s32i>, !cir.ptr<!cir.matrix<3 x 3 x !s32i>>
+
+// LLVM: %[[MATRIX_ADDR:.*]] = alloca [9 x i32], align 4
+// LLVM: %[[SCALAR_ADDR:.*]] = alloca i32, align 4
+// LLVM: %[[RESULT_ADDR:.*]] = alloca [9 x i32], align 4
+// LLVM: store i32 3, ptr %[[SCALAR_ADDR]], align 4
+// LLVM: %[[TMP_MATRIX:.*]] = load <9 x i32>, ptr %[[MATRIX_ADDR]], align 4
+// LLVM: %[[TMP_SCALAR:.*]] = load i32, ptr %[[SCALAR_ADDR]], align 4
+// LLVM: %[[SPLAT_SCALAR_INSERT:.*]] = insertelement <9 x i32> poison, i32 %[[TMP_SCALAR]], i64 0
+// LLVM: %[[SPLAT_SCALAR:.*]] = shufflevector <9 x i32> %[[SPLAT_SCALAR_INSERT]], <9 x i32> poison, <9 x i32> zeroinitializer
+// LLVM: %[[RESULT:.*]] = mul <9 x i32> %[[TMP_MATRIX]], %[[SPLAT_SCALAR]]
+// LLVM: store <9 x i32> %[[RESULT]], ptr %[[RESULT_ADDR]], align 4
``````````
</details>
https://github.com/llvm/llvm-project/pull/230815
More information about the cfe-commits
mailing list