llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang-codegen Author: Farzon Lotfi (farzonl) <details> <summary>Changes</summary> Make MatrixBuilder::CreateIndex always compute column-major indices and remove the row-major and column-major helper functions. Update matrix subscripting, row extraction, flattening, and elementwise casts to consistently construct and access matrices in canonical column-major register order. Keep matrix layout as a memory property by converting canonical values when storing to row-major memory. Route matrix prvalue materialization through the matrix-aware store path so element access on expressions such as transpose(m)._m01 observes the correct temporary layout. Update CodeGen tests to cover canonical indexing for both layout defaults, explicit row-major elementwise-cast destinations, and matrix swizzles on prvalue temporaries. Assisted by Copilot via GPT 5.6-sol --- Patch is 20.16 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/227087.diff 8 Files Affected: - (modified) clang/lib/CodeGen/CGExpr.cpp (+7-20) - (modified) clang/lib/CodeGen/CGExprScalar.cpp (+3-8) - (modified) clang/test/CodeGen/matrix-type-indexing.c (+6-9) - (modified) clang/test/CodeGenHLSL/BasicFeatures/MatrixElementRowColFlags.hlsl (+29) - (modified) clang/test/CodeGenHLSL/BasicFeatures/VectorElementwiseCast.hlsl (+2-4) - (modified) clang/test/CodeGenHLSL/BasicFeatures/matrix-type-indexing.hlsl (+3-6) - (modified) clang/test/CodeGenHLSL/matrix-layout-attr-overrides-default.hlsl (+17-2) - (modified) llvm/include/llvm/IR/MatrixBuilder.h (+3-23) ``````````diff diff --git a/clang/lib/CodeGen/CGExpr.cpp b/clang/lib/CodeGen/CGExpr.cpp index 25e775f8328b9..a826fa0089043 100644 --- a/clang/lib/CodeGen/CGExpr.cpp +++ b/clang/lib/CodeGen/CGExpr.cpp @@ -2364,11 +2364,8 @@ LValue CodeGenFunction::EmitMatrixElementExpr(const MatrixElementExpr *E) { llvm::Value *Mat = EmitScalarExpr(E->getBase()); Address MatMem = CreateMemTemp(E->getBase()->getType()); QualType Ty = E->getBase()->getType(); - llvm::Type *LTy = convertTypeForLoadStore(Ty, Mat->getType()); - if (LTy->getScalarSizeInBits() > Mat->getType()->getScalarSizeInBits()) - Mat = Builder.CreateZExt(Mat, LTy); - Builder.CreateStore(Mat, MatMem); Base = MakeAddrLValue(MatMem, Ty, AlignmentSource::Decl); + EmitStoreOfScalar(Mat, Base, /*isInit=*/true); } QualType ResultType = E->getType().withCVRQualifiers(Base.getQuals().getCVRQualifiers()); @@ -2430,7 +2427,8 @@ static void EmitStoreOfMatrixScalar(llvm::Value *value, LValue lvalue, const auto *MatrixTy = lvalue.getType()->castAs<ConstantMatrixType>(); llvm::MatrixBuilder MB(CGF.Builder); value = MB.CreateColumnMajorToRowMajorTransform( - value, MatrixTy->getNumRows(), MatrixTy->getNumColumns()); + value, MatrixTy->getNumRows(), MatrixTy->getNumColumns(), + "TEMP_ROW_MAJOR"); } Address Addr = MaybeConvertMatrixAddress(lvalue.getAddress(), CGF, value->getType()->isVectorTy()); @@ -2650,9 +2648,7 @@ RValue CodeGenFunction::EmitLoadOfLValue(LValue LV, SourceLocation Loc) { ColIdx = ColConstsIndices->getAggregateElement(Col); else ColIdx = llvm::ConstantInt::get(Row->getType(), Col); - bool IsMatrixRowMajor = isMatrixRowMajor(getLangOpts(), MatTy); - llvm::Value *EltIndex = - MB.CreateIndex(Row, ColIdx, NumRows, NumCols, IsMatrixRowMajor); + llvm::Value *EltIndex = MB.CreateIndex(Row, ColIdx, NumRows); llvm::Value *Elt = Builder.CreateExtractElement(MatrixVec, EltIndex); llvm::Value *Lane = llvm::ConstantInt::get(Builder.getInt32Ty(), Col); Result = Builder.CreateInsertElement(Result, Elt, Lane); @@ -2969,9 +2965,7 @@ void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst, ColIdx = ColConstsIndices->getAggregateElement(Col); else ColIdx = llvm::ConstantInt::get(Row->getType(), Col); - bool IsMatrixRowMajor = isMatrixRowMajor(getLangOpts(), Dst.getType()); - llvm::Value *EltIndex = - MB.CreateIndex(Row, ColIdx, NumRows, NumCols, IsMatrixRowMajor); + llvm::Value *EltIndex = MB.CreateIndex(Row, ColIdx, NumRows); llvm::Value *Lane = llvm::ConstantInt::get(Builder.getInt32Ty(), Col); llvm::Value *Zero = llvm::ConstantInt::get(Int32Ty, 0); llvm::Value *NewElt = Builder.CreateExtractElement(RowVal, Lane); @@ -5432,12 +5426,8 @@ LValue CodeGenFunction::EmitMatrixSubscriptExpr(const MatrixSubscriptExpr *E) { llvm::Value *ColIdx = EmitMatrixIndexExpr(E->getColumnIdx()); llvm::MatrixBuilder MB(Builder); const auto *MatrixTy = E->getBase()->getType()->castAs<ConstantMatrixType>(); - unsigned NumCols = MatrixTy->getNumColumns(); unsigned NumRows = MatrixTy->getNumRows(); - bool IsMatrixRowMajor = - isMatrixRowMajor(getLangOpts(), E->getBase()->getType()); - llvm::Value *FinalIdx = - MB.CreateIndex(RowIdx, ColIdx, NumRows, NumCols, IsMatrixRowMajor); + llvm::Value *FinalIdx = MB.CreateIndex(RowIdx, ColIdx, NumRows); return LValue::MakeMatrixElt( MaybeConvertMatrixAddress(Base.getAddress(), *this), FinalIdx, @@ -7662,15 +7652,12 @@ void CodeGenFunction::FlattenAccessAndTypeLValue( LValue Base = MakeAddrLValue(GEP, T); Address MatAddr = MaybeConvertMatrixAddress(Base.getAddress(), *this); unsigned NumRows = MT->getNumRows(); - unsigned NumCols = MT->getNumColumns(); - bool IsMatrixRowMajor = isMatrixRowMajor(getLangOpts(), T); llvm::MatrixBuilder MB(Builder); for (unsigned Row = 0; Row < MT->getNumRows(); Row++) { for (unsigned Col = 0; Col < MT->getNumColumns(); Col++) { llvm::Value *RowIdx = llvm::ConstantInt::get(IdxTy, Row); llvm::Value *ColIdx = llvm::ConstantInt::get(IdxTy, Col); - llvm::Value *Idx = MB.CreateIndex(RowIdx, ColIdx, NumRows, NumCols, - IsMatrixRowMajor); + llvm::Value *Idx = MB.CreateIndex(RowIdx, ColIdx, NumRows); LValue LV = LValue::MakeMatrixElt(MatAddr, Idx, MT->getElementType(), Base.getBaseInfo(), TBAAAccessInfo()); diff --git a/clang/lib/CodeGen/CGExprScalar.cpp b/clang/lib/CodeGen/CGExprScalar.cpp index 0c310816bc268..40306b1f20e28 100644 --- a/clang/lib/CodeGen/CGExprScalar.cpp +++ b/clang/lib/CodeGen/CGExprScalar.cpp @@ -2231,8 +2231,7 @@ Value *ScalarExprEmitter::VisitMatrixSingleSubscriptExpr( for (unsigned Col = 0; Col != NumColumns; ++Col) { Value *ColVal = llvm::ConstantInt::get(RowIdx->getType(), Col); - Value *EltIdx = MB.CreateIndex(RowIdx, ColVal, NumRows, NumColumns, - /*IsRowMajor=*/false, "matrix_row_idx"); + Value *EltIdx = MB.CreateIndex(RowIdx, ColVal, NumRows, "matrix_row_idx"); Value *Elt = Builder.CreateExtractElement(FlatMatrix, EltIdx, "matrix_elem"); Value *Lane = llvm::ConstantInt::get(Builder.getInt32Ty(), Col); @@ -2254,10 +2253,8 @@ Value *ScalarExprEmitter::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) { llvm::MatrixBuilder MB(Builder); Value *Idx; - unsigned NumCols = MatrixTy->getNumColumns(); unsigned NumRows = MatrixTy->getNumRows(); - Idx = MB.CreateIndex(RowIdx, ColumnIdx, NumRows, NumCols, - /*IsRowMajor=*/false); + Idx = MB.CreateIndex(RowIdx, ColumnIdx, NumRows); if (CGF.CGM.getCodeGenOpts().OptimizationLevel > 0) MB.CreateIndexAssumption(Idx, MatrixTy->getNumElementsFlattened()); @@ -2578,8 +2575,6 @@ static Value *EmitHLSLElementwiseCast(CodeGenFunction &CGF, LValue SrcVal, "Flattened type on RHS must have the same number or more elements " "than vector on LHS."); - bool IsRowMajor = isMatrixRowMajor(CGF.getLangOpts(), DestTy); - llvm::Value *V = CGF.Builder.CreateLoad( CGF.CreateIRTempWithoutCast(DestTy, "flatcast.tmp")); // V is an allocated temporary for constructing the matrix. @@ -2594,7 +2589,7 @@ static Value *EmitHLSLElementwiseCast(CodeGenFunction &CGF, LValue SrcVal, llvm::Value *Cast = CGF.EmitScalarConversion( RVal.getScalarVal(), LoadList[LoadIdx].getType(), MatTy->getElementType(), Loc); - unsigned MatrixIdx = MatTy->getFlattenedIndex(Row, Col, IsRowMajor); + unsigned MatrixIdx = MatTy->getColumnMajorFlattenedIndex(Row, Col); V = CGF.Builder.CreateInsertElement(V, Cast, MatrixIdx); } } diff --git a/clang/test/CodeGen/matrix-type-indexing.c b/clang/test/CodeGen/matrix-type-indexing.c index 20eece3d646d4..cc8117e043c55 100644 --- a/clang/test/CodeGen/matrix-type-indexing.c +++ b/clang/test/CodeGen/matrix-type-indexing.c @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -fenable-matrix -fmatrix-memory-layout=row-major -triple x86_64-apple-darwin %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s --check-prefixes=CHECK,ROW-CHECK -// RUN: %clang_cc1 -fenable-matrix -fmatrix-memory-layout=column-major -triple x86_64-apple-darwin %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s --check-prefixes=CHECK,COL-CHECK -// RUN: %clang_cc1 -fenable-matrix -triple x86_64-apple-darwin %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s --check-prefixes=CHECK,COL-CHECK +// RUN: %clang_cc1 -fenable-matrix -fmatrix-memory-layout=row-major -triple x86_64-apple-darwin %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s +// RUN: %clang_cc1 -fenable-matrix -fmatrix-memory-layout=column-major -triple x86_64-apple-darwin %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s +// RUN: %clang_cc1 -fenable-matrix -triple x86_64-apple-darwin %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s typedef float fx2x3_t __attribute__((matrix_type(2, 3))); float Out[6]; @@ -42,13 +42,10 @@ float returnMatrixSubscriptExpr(int row, int col, fx2x3_t M) { void storeAtMatrixSubscriptExpr(int row, int col, float value) { // CHECK-LABEL: storeAtMatrixSubscriptExpr // CHECK: [[value_load:%.*]] = load float, ptr [[value_ptr:%.*]], align 4 - // ROW-CHECK: [[row_offset:%.*]] = mul i64 [[row_load:%.*]], 3 - // ROW-CHECK-NEXT: [[row_major_index:%.*]] = add i64 [[row_offset]], [[col_load:%.*]] - // COL-CHECK: [[col_offset:%.*]] = mul i64 [[col_load:%.*]], 2 - // COL-CHECK-NEXT: [[col_major_index:%.*]] = add i64 [[col_offset]], [[row_load:%.*]] + // CHECK: [[col_offset:%.*]] = mul i64 [[col_load:%.*]], 2 + // CHECK-NEXT: [[col_major_index:%.*]] = add i64 [[col_offset]], [[row_load:%.*]] // CHECK-NEXT: [[matrix_as_vec:%.*]] = load <6 x float>, ptr @gM, align 4 - // ROW-CHECK-NEXT: [[matrix_after_insert:%.*]] = insertelement <6 x float> [[matrix_as_vec]], float [[value_load]], i64 [[row_major_index]] - // COL-CHECK-NEXT: [[matrix_after_insert:%.*]] = insertelement <6 x float> [[matrix_as_vec]], float [[value_load]], i64 [[col_major_index]] + // CHECK-NEXT: [[matrix_after_insert:%.*]] = insertelement <6 x float> [[matrix_as_vec]], float [[value_load]], i64 [[col_major_index]] // CHECK-NEXT: store <6 x float> [[matrix_after_insert]], ptr @gM, align 4 gM[row][col] = value; } diff --git a/clang/test/CodeGenHLSL/BasicFeatures/MatrixElementRowColFlags.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/MatrixElementRowColFlags.hlsl index 666a387a8450a..ce14a04fe80ff 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/MatrixElementRowColFlags.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/MatrixElementRowColFlags.hlsl @@ -13,6 +13,8 @@ // CHECK-LABEL: define {{.*}} @_Z16getScalarElementu11matrix_typeILm3ELm2EfE +// ROW: [[TEMP_ROW_MAJOR:%.*]] = call {{.*}} <6 x float> @llvm.matrix.transpose.v6f32(<6 x float> %{{.*}}, i32 3, i32 2) +// ROW-NEXT: store <6 x float> [[TEMP_ROW_MAJOR]], ptr // CHECK: load <6 x float>, ptr // COL-NEXT: extractelement <6 x float> {{.*}}, i32 4 // ROW-NEXT: extractelement <6 x float> {{.*}}, i32 3 @@ -21,6 +23,8 @@ export float getScalarElement(float3x2 M) { } // CHECK-LABEL: define {{.*}} @_Z18getSwizzleElementsu11matrix_typeILm3ELm2EfE +// ROW: [[TEMP_ROW_MAJOR:%.*]] = call {{.*}} <6 x float> @llvm.matrix.transpose.v6f32(<6 x float> %{{.*}}, i32 3, i32 2) +// ROW-NEXT: store <6 x float> [[TEMP_ROW_MAJOR]], ptr // CHECK: load <6 x float>, ptr // COL-NEXT: shufflevector <6 x float> {{.*}}, <6 x float> poison, <4 x i32> <i32 0, i32 3, i32 1, i32 4> // ROW-NEXT: shufflevector <6 x float> {{.*}}, <6 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 3> @@ -29,9 +33,34 @@ export float4 getSwizzleElements(float3x2 M) { } // CHECK-LABEL: define {{.*}} @_Z22getZeroBasedSwizzleEltu11matrix_typeILm3ELm2EfE +// ROW: [[TEMP_ROW_MAJOR:%.*]] = call {{.*}} <6 x float> @llvm.matrix.transpose.v6f32(<6 x float> %{{.*}}, i32 3, i32 2) +// ROW-NEXT: store <6 x float> [[TEMP_ROW_MAJOR]], ptr // CHECK: load <6 x float>, ptr // COL-NEXT: shufflevector <6 x float> {{.*}}, <6 x float> poison, <2 x i32> <i32 1, i32 3> // ROW-NEXT: shufflevector <6 x float> {{.*}}, <6 x float> poison, <2 x i32> <i32 2, i32 1> export float2 getZeroBasedSwizzleElt(float3x2 M) { return M._m10_m01; } + +// transpose(m) produces a canonical column-major register value. Matrix +// element access materializes that prvalue in a matrix-typed temporary, which +// must use the selected memory layout. +export float swizzle_prvalue(float2x3 m) { + return transpose(m)._m01; +} + +// COL-LABEL: define {{.*}} float @_Z15swizzle_prvalue +// COL: [[TEMP:%.*]] = alloca [2 x <3 x float>] +// COL: [[RESULT_COL_MAJOR:%.*]] = call {{.*}} <6 x float> @llvm.matrix.transpose.v6f32(<6 x float> %{{.*}}, i32 2, i32 3) +// COL: store <6 x float> [[RESULT_COL_MAJOR]], ptr [[TEMP]] +// COL: [[FROM_TEMP:%.*]] = load <6 x float>, ptr [[TEMP]] +// COL: extractelement <6 x float> [[FROM_TEMP]], i32 3 + +// ROW-LABEL: define {{.*}} float @_Z15swizzle_prvalue +// ROW: [[TEMP:%.*]] = alloca [3 x <2 x float>] +// ROW: [[INPUT_COL_MAJOR:%.*]] = call {{.*}} <6 x float> @llvm.matrix.transpose.v6f32(<6 x float> %{{.*}}, i32 3, i32 2) +// ROW: [[RESULT_COL_MAJOR:%.*]] = call {{.*}} <6 x float> @llvm.matrix.transpose.v6f32(<6 x float> [[INPUT_COL_MAJOR]], i32 2, i32 3) +// ROW: [[TEMP_ROW_MAJOR:%.*]] = call {{.*}} <6 x float> @llvm.matrix.transpose.v6f32(<6 x float> [[RESULT_COL_MAJOR]], i32 3, i32 2) +// ROW: store <6 x float> [[TEMP_ROW_MAJOR]], ptr [[TEMP]] +// ROW: [[FROM_TEMP:%.*]] = load <6 x float>, ptr [[TEMP]] +// ROW: extractelement <6 x float> [[FROM_TEMP]], i32 1 diff --git a/clang/test/CodeGenHLSL/BasicFeatures/VectorElementwiseCast.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/VectorElementwiseCast.hlsl index 5156dccb26eca..90a4fa61bd1e3 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/VectorElementwiseCast.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/VectorElementwiseCast.hlsl @@ -147,12 +147,10 @@ export void call6(Derived D) { // CHECK-NEXT: [[MATRIXEXT:%.*]] = extractelement <4 x float> [[TMP2]], i32 0 // CHECK-NEXT: [[TMP3:%.*]] = insertelement <4 x float> [[TMP1]], float [[MATRIXEXT]], i64 0 // CHECK-NEXT: [[TMP4:%.*]] = load <4 x float>, ptr [[MATRIX_GEP]], align 4 -// COL-CHECK-NEXT: [[MATRIXEXT1:%.*]] = extractelement <4 x float> [[TMP4]], i32 2 -// ROW-CHECK-NEXT: [[MATRIXEXT1:%.*]] = extractelement <4 x float> [[TMP4]], i32 1 +// CHECK-NEXT: [[MATRIXEXT1:%.*]] = extractelement <4 x float> [[TMP4]], i32 2 // CHECK-NEXT: [[TMP5:%.*]] = insertelement <4 x float> [[TMP3]], float [[MATRIXEXT1]], i64 1 // CHECK-NEXT: [[TMP6:%.*]] = load <4 x float>, ptr [[MATRIX_GEP]], align 4 -// COL-CHECK-NEXT: [[MATRIXEXT2:%.*]] = extractelement <4 x float> [[TMP6]], i32 1 -// ROW-CHECK-NEXT: [[MATRIXEXT2:%.*]] = extractelement <4 x float> [[TMP6]], i32 2 +// CHECK-NEXT: [[MATRIXEXT2:%.*]] = extractelement <4 x float> [[TMP6]], i32 1 // CHECK-NEXT: [[TMP7:%.*]] = insertelement <4 x float> [[TMP5]], float [[MATRIXEXT2]], i64 2 // CHECK-NEXT: [[TMP8:%.*]] = load <4 x float>, ptr [[MATRIX_GEP]], align 4 // CHECK-NEXT: [[MATRIXEXT3:%.*]] = extractelement <4 x float> [[TMP8]], i32 3 diff --git a/clang/test/CodeGenHLSL/BasicFeatures/matrix-type-indexing.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/matrix-type-indexing.hlsl index 85c65d14616a5..12425033abea1 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/matrix-type-indexing.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/matrix-type-indexing.hlsl @@ -38,12 +38,9 @@ half returnMatrixSubscriptExpr(int row, int col, half2x3 M) { void storeAtMatrixSubscriptExpr(int row, int col, half value) { // CHECK-LABEL: storeAtMatrixSubscriptExpr // CHECK: [[value_load:%.*]] = load half, ptr [[value_ptr:%.*]], align 2 - // ROW-CHECK: [[row_offset:%.*]] = mul i32 [[row_load:%.*]], 3 - // ROW-CHECK-NEXT: [[row_major_index:%.*]] = add i32 [[row_offset]], [[col_load:%.*]] - // COL-CHECK: [[col_offset:%.*]] = mul i32 [[col_load:%.*]], 2 - // COL-CHECK-NEXT: [[col_major_index:%.*]] = add i32 [[col_offset]], [[row_load:%.*]] - // ROW-CHECK-NEXT: [[matrix_gep:%.*]] = getelementptr <6 x half>, ptr addrspace(2) @gM, i32 0, i32 [[row_major_index]] - // COL-CHECK-NEXT: [[matrix_gep:%.*]] = getelementptr <6 x half>, ptr addrspace(2) @gM, i32 0, i32 [[col_major_index]] + // CHECK: [[col_offset:%.*]] = mul i32 [[col_load:%.*]], 2 + // CHECK-NEXT: [[col_major_index:%.*]] = add i32 [[col_offset]], [[row_load:%.*]] + // CHECK-NEXT: [[matrix_gep:%.*]] = getelementptr <6 x half>, ptr addrspace(2) @gM, i32 0, i32 [[col_major_index]] // CHECK-NEXT: store half [[value_load]], ptr addrspace(2) [[matrix_gep]], align 2 gM[row][col] = value; } diff --git a/clang/test/CodeGenHLSL/matrix-layout-attr-overrides-default.hlsl b/clang/test/CodeGenHLSL/matrix-layout-attr-overrides-default.hlsl index a04cf58b45b7c..cb73364bd6e0e 100644 --- a/clang/test/CodeGenHLSL/matrix-layout-attr-overrides-default.hlsl +++ b/clang/test/CodeGenHLSL/matrix-layout-attr-overrides-default.hlsl @@ -7,6 +7,7 @@ // // * `MatrixSubscriptExpr` index computation // * `MatrixSingleSubscriptExpr` row extraction +// * `CK_HLSLElementwiseCast` matrix construction // * `__builtin_hlsl_mul` matrix-multiply transpose insertion // * `__builtin_hlsl_transpose` row/col dimension swap // * `CK_HLSLMatrixTruncation` shuffle mask @@ -40,8 +41,8 @@ export float subscript_cm(int row, int col, column_major float2x3 m) { // CHECK: extractelement <6 x float> %{{.*}}, i32 [[IDX]] // ----------------------------------------------------------------------------- -// MatrixSingleSubscriptExpr (row extraction): attribute selects the per-element -// index formula even when the TU default disagrees. +// MatrixSingleSubscriptExpr (row extraction) uses canonical column-major +// indexing even when the destination storage layout is row-major. // ----------------------------------------------------------------------------- // Row extraction also indexes the canonical column-major prvalue. @@ -66,6 +67,20 @@ export float3 row_extract_cm(int row, column_major float2x3 m) { // CHECK: add i32 2, [[ROW]] // CHECK: add i32 4, [[ROW]] +// ----------------------------------------------------------------------------- +// CK_HLSLElementwiseCast produces a canonical column-major register value. +// An explicit row-major destination affects only the subsequent memory store. +// ----------------------------------------------------------------------------- +typedef row_major float2x2 RowMajorMatrix; + +export float cast_row_major(float4 v) { + RowMajorMatrix m = (RowMajorMatrix)v; + return m[0][1]; +} +// CHECK-LABEL: define {{.*}} float @_Z14cast_row_major +// CHECK: [[SECOND:%.*]] = extractelement <4 x float> %{{.*}}, i32 1 +// CHECK: insertelement <4 x float> %{{.*}}, float [[SECOND]], i64 2 + // ----------------------------------------------------------------------------- // __builtin_hlsl_mul (vector * matrix): row-major operand triggers a transpose // before the column-major matrix.multiply intrinsic. diff --git a/llvm/include/llvm/IR/MatrixBuilder.h b/llvm/include/llvm/IR/MatrixBuilder.h index 41cd5ea0efd93..8c0609401ebd6 100644 --- a/llvm/include/llvm/IR/MatrixBuilder.h +++ b/llvm/include/llvm/IR/MatrixBuilder.h @@ -260,39 +260,19 @@ class MatrixBuilder { else B.CreateAssumption(Cmp); } - /// Compute the index to access the element at (\p RowIdx, \p ColumnIdx) from - /// a matrix with \p NumRows or \p NumCols embedded in a vector depending - /// on matrix major ordering. + /// Compute the column-major index to access the element at + /// (\p RowIdx, \p ColumnIdx) from a matrix with \p NumRows embedded in a + /// vector. Value *CreateIndex(Value *RowIdx, Value *ColumnIdx, unsigned NumRows, - unsigned NumCols, bool IsMatrixRowMajor = false, Twine const &Name = "") { unsigned MaxWidth = std::max(RowIdx->getType()->getScalarSizeInBits(), ColumnIdx->getType()->getScalarSizeInBits()); Type *IntTy = IntegerType::get(RowIdx->getType()->getContext(), MaxWidth); RowIdx = B.CreateZExt(RowIdx, IntTy); ColumnIdx = B.CreateZExt(ColumnIdx, IntTy); - if (IsMatrixRowMajor) { - Value *NumColsV = B.getIntN(MaxWidth, NumCols); - return CreateRowMajorIndex(RowIdx, ColumnIdx, NumColsV, Name); - } Value *NumRowsV = B.getIntN(MaxWidth, NumRows); - return CreateColumnMajorIndex(RowIdx, ColumnIdx, NumRowsV, Name); - } - -private: - /// Compute the index to access the element at (\p RowIdx, \p ColumnIdx) from - /// a matrix with \p NumRows embedded in a vector. - Value *CreateColumnMajorIndex(Value *RowIdx, Value *ColumnIdx, - Value *NumRowsV, Twine const &Name) { return B.CreateAdd(B.CreateMul(ColumnIdx, NumRowsV), RowIdx); } - - /// Compute the index to access the element at (\p RowIdx, \p ColumnIdx) from - /// a matrix with \p NumCols embedded in a vector. - Value *CreateRowMajorIndex(Value *RowIdx, Value *ColumnIdx, Valu... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/227087 _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
