diff --git a/include/dxc/dxcapi.internal.h b/include/dxc/dxcapi.internal.h index 28bd3e7066..41891338e6 100644 --- a/include/dxc/dxcapi.internal.h +++ b/include/dxc/dxcapi.internal.h @@ -133,11 +133,15 @@ enum LEGAL_INTRINSIC_COMPTYPES { LICOMPTYPE_HIT_OBJECT = 51, LICOMPTYPE_RAY_QUERY = 52, + LICOMPTYPE_LINALG = 53, // f32, partial-precision-f32, f16, + // i32, i16, u32, u16, + // int8_4packed, uint8_4packed + #ifdef ENABLE_SPIRV_CODEGEN - LICOMPTYPE_VK_BUFFER_POINTER = 53, - LICOMPTYPE_COUNT = 54 + LICOMPTYPE_VK_BUFFER_POINTER = 54, + LICOMPTYPE_COUNT = 55 #else - LICOMPTYPE_COUNT = 53 + LICOMPTYPE_COUNT = 54 #endif }; diff --git a/tools/clang/include/clang/Basic/DiagnosticSemaKinds.td b/tools/clang/include/clang/Basic/DiagnosticSemaKinds.td index ae7e777180..6209726773 100644 --- a/tools/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/tools/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -8013,6 +8013,43 @@ def err_hlsl_reorder_unsupported_stage : Error< "dx::MaybeReorderThread is unavailable in shader stage '%0' (requires 'raygeneration')">; def err_hlsl_hitobject_unsupported_stage : Error< "dx::HitObject is unavailable in shader stage '%0' (requires 'raygeneration', 'closesthit' or 'miss')">; + +// Linear Algebra Operations +def err_hlsl_linalg_isunsigned_incorrect_for_given_type : Error< + "%0 must be %select{false|true}1 for vector of " + "%select{floating point|signed integer|unsigned integer}2 type">; +def err_hlsl_linalg_interpretation_value_incorrect : Error< + "%0 is an invalid %select{memory|register}1 interpretation value">; +def err_hlsl_linalg_matrix_layout_is_not_transposable : Error< + "RowMajor and ColumnMajor matrices are not transposable">; +def err_hlsl_linalg_optimal_matrix_layout_matrix_stride_must_be_zero : Error< + "for optimal matrix layout, matrix stride must be 0">; +def err_hlsl_linalg_matrix_dim_must_be_greater_than_zero: Error< + "matrix dimension must be greater than 0">; +def err_hlsl_linalg_matrix_layout_invalid : Error< + "matrix layout %0 is not valid, must be in the range [%1, %2]">; + +def err_hlsl_linalg_mul_muladd_output_vector_size_not_equal_to_matrix_M : Error< + "output vector length must be equal to Matrix M dimension in a linalg Mul/MulAdd operation">; +def err_hlsl_linalg_mul_muladd_unpacked_input_vector_size_not_equal_to_matrix_K : Error< + "unpacked input vector length must be equal to Matrix K dimension in a linalg Mul/MulAdd operation">; +def err_hlsl_linalg_mul_muladd_packed_input_vector_size_incorrect : Error< + "packed input vector length must be the smallest number that can hold matrix dim K values of the " + "packed(smaller) type in linalg mul/muladd operations">; +def err_hlsl_linalg_mul_muladd_isUnsigned_for_packed_input_must_be_true : Error< + "IsInputUnsigned must be true for packed input interpretations in linalg mul/muladd operations">; +def err_hlsl_linalg_mul_muladd_packed_input_vector_must_be_uint : Error< + "packed input vector type must be a 32-bit unsigned int type in linalg mul/muladd operations">; +def err_hlsl_linalg_mul_muladd_invalid_dim: Error< + "matrix dimension %select{M|K when using unpacked input vectors|K " + "when using packed input vectors}0 must be less than %1, in a linalg " + "Mul/MulAdd operation">; + +def err_hlsl_linalg_outer_prod_acc_vector_type_mismatch : Error< + "input vectors of outerproductaccumulate must have the same element type">; +def err_hlsl_linalg_outer_prod_acc_matrix_layout_must_be_outer_prod_acc_optimal : Error< + "matrix layout for outerproductaccumulate must be %0">; + // HLSL Change Ends // SPIRV Change Starts diff --git a/tools/clang/lib/Headers/hlsl/dx/linalg.h b/tools/clang/lib/Headers/hlsl/dx/linalg.h index 51e662bbc9..4f5e62070d 100644 --- a/tools/clang/lib/Headers/hlsl/dx/linalg.h +++ b/tools/clang/lib/Headers/hlsl/dx/linalg.h @@ -43,14 +43,30 @@ enum MatrixLayout { // Helper for signedness // namespace details { -template bool IsUnsigned() { return false; } + +template struct IsUnsigned {}; + +#define _SPECIALIZE_ISUNSIGNED(type, value) \ + template <> struct IsUnsigned { \ + static const bool Value = value; \ + } + +_SPECIALIZE_ISUNSIGNED(uint8_t4_packed, true); +_SPECIALIZE_ISUNSIGNED(int8_t4_packed, true); +_SPECIALIZE_ISUNSIGNED(uint32_t, true); +_SPECIALIZE_ISUNSIGNED(int32_t, false); +_SPECIALIZE_ISUNSIGNED(float32_t, false); #ifdef __HLSL_ENABLE_16_BIT -template <> bool IsUnsigned() { return true; } -#endif +_SPECIALIZE_ISUNSIGNED(uint16_t, true); +_SPECIALIZE_ISUNSIGNED(int16_t, false); +_SPECIALIZE_ISUNSIGNED(float16_t, false); +#else // //__HLSL_ENABLE_16_BIT +_SPECIALIZE_ISUNSIGNED(half, false); +#endif //__HLSL_ENABLE_16_BIT + +#undef _SPECIALIZE_ISUNSIGNED -template <> bool IsUnsigned() { return true; } -template <> bool IsUnsigned() { return true; } } // namespace details // @@ -116,10 +132,10 @@ Mul(MatrixRefImpl OutputVector; __builtin_MatVecMul( - /*out*/ OutputVector, details::IsUnsigned(), InputVector.Data, - details::IsUnsigned(), InputDT, Matrix.Buffer, - Matrix.StartOffset, MatrixDT, MatrixM, MatrixK, MatrixLayout, - MatrixTranspose, Matrix.Stride); + /*out*/ OutputVector, details::IsUnsigned::Value, + InputVector.Data, details::IsUnsigned::Value, InputDT, + Matrix.Buffer, Matrix.StartOffset, MatrixDT, MatrixM, MatrixK, + MatrixLayout, MatrixTranspose, Matrix.Stride); return OutputVector; } @@ -143,11 +159,11 @@ MulAdd(MatrixRefImpl OutputVector; __builtin_MatVecMulAdd( - /*out*/ OutputVector, details::IsUnsigned(), InputVector.Data, - details::IsUnsigned(), InputDT, Matrix.Buffer, - Matrix.StartOffset, MatrixDT, MatrixM, MatrixK, MatrixLayout, - MatrixTranspose, Matrix.Stride, BiasVector.Buffer, BiasVector.StartOffset, - BiasVectorDT); + /*out*/ OutputVector, details::IsUnsigned::Value, + InputVector.Data, details::IsUnsigned::Value, InputDT, + Matrix.Buffer, Matrix.StartOffset, MatrixDT, MatrixM, MatrixK, + MatrixLayout, MatrixTranspose, Matrix.Stride, BiasVector.Buffer, + BiasVector.StartOffset, BiasVectorDT); return OutputVector; } diff --git a/tools/clang/lib/Sema/SemaHLSL.cpp b/tools/clang/lib/Sema/SemaHLSL.cpp index b15068638d..fe5dfa222b 100644 --- a/tools/clang/lib/Sema/SemaHLSL.cpp +++ b/tools/clang/lib/Sema/SemaHLSL.cpp @@ -15,6 +15,7 @@ #include "clang/Sema/SemaHLSL.h" #include "VkConstantsTables.h" +#include "dxc/DXIL/DxilConstants.h" #include "dxc/DXIL/DxilFunctionProps.h" #include "dxc/DXIL/DxilShaderModel.h" #include "dxc/DXIL/DxilUtil.h" @@ -1138,6 +1139,14 @@ static const ArBasicKind g_RayDescCT[] = {AR_OBJECT_RAY_DESC, AR_BASIC_UNKNOWN}; static const ArBasicKind g_RayQueryCT[] = {AR_OBJECT_RAY_QUERY, AR_BASIC_UNKNOWN}; +static const ArBasicKind g_LinAlgCT[] = { + AR_BASIC_FLOAT32, AR_BASIC_FLOAT32_PARTIAL_PRECISION, + AR_BASIC_FLOAT16, AR_BASIC_INT32, + AR_BASIC_INT16, AR_BASIC_UINT32, + AR_BASIC_UINT16, AR_BASIC_INT8_4PACKED, + AR_BASIC_UINT8_4PACKED, AR_BASIC_NOCAST, + AR_BASIC_UNKNOWN}; + static const ArBasicKind g_AccelerationStructCT[] = { AR_OBJECT_ACCELERATION_STRUCT, AR_BASIC_UNKNOWN}; @@ -1301,6 +1310,7 @@ const ArBasicKind *g_LegalIntrinsicCompTypes[] = { g_ThreadNodeOutputRecordsCT, // LICOMPTYPE_THREAD_NODE_OUTPUT_RECORDS g_DxHitObjectCT, // LICOMPTYPE_HIT_OBJECT g_RayQueryCT, // LICOMPTYPE_RAY_QUERY + g_LinAlgCT, // LICOMPTYPE_LINALG #ifdef ENABLE_SPIRV_CODEGEN g_VKBufferPointerCT, // LICOMPTYPE_VK_BUFFER_POINTER #endif @@ -11663,6 +11673,537 @@ static bool CheckBarrierCall(Sema &S, FunctionDecl *FD, CallExpr *CE, return false; } +// MatVec Ops +static const unsigned kMatVecMulOutputVectorIdx = 0; +static const unsigned kMatVecMulOutputIsUnsignedIdx = 1; +static const unsigned kMatVecMulInputVectorIdx = 2; +static const unsigned kMatVecMulIsInputUnsignedIdx = 3; +static const unsigned kMatVecMulInputInterpretationIdx = 4; +// static const unsigned kMatVecMulMatrixBufferIdx = 5; +// static const unsigned kMatVecMulMatrixOffsetIdx = 6; +static const unsigned kMatVecMulMatrixInterpretationIdx = 7; +static const unsigned kMatVecMulMatrixMIdx = 8; +static const unsigned kMatVecMulMatrixKIdx = 9; +static const unsigned kMatVecMulMatrixLayoutIdx = 10; +static const unsigned kMatVecMulMatrixTransposeIdx = 11; +static const unsigned kMatVecMulMatrixStrideIdx = 12; + +// MatVecAdd +const unsigned kMatVecMulAddBiasInterpretation = 15; + +static bool IsValidMatrixLayoutForMulAndMulAddOps(unsigned Layout) { + return Layout <= + static_cast(DXIL::LinalgMatrixLayout::OuterProductOptimal); +} + +static bool IsOptimalTypeMatrixLayout(unsigned Layout) { + return ( + Layout == (static_cast(DXIL::LinalgMatrixLayout::MulOptimal)) || + (Layout == + (static_cast(DXIL::LinalgMatrixLayout::OuterProductOptimal)))); +} + +static bool IsValidTransposeForMatrixLayout(unsigned Layout, bool Transposed) { + switch (static_cast(Layout)) { + case DXIL::LinalgMatrixLayout::RowMajor: + case DXIL::LinalgMatrixLayout::ColumnMajor: + return !Transposed; + + default: + return true; + } +} + +static bool IsPackedType(unsigned type) { + return (type == static_cast(DXIL::ComponentType::PackedS8x32) || + type == static_cast(DXIL::ComponentType::PackedU8x32)); +} + +static bool IsValidLinalgTypeInterpretation(uint32_t Input, bool InRegister) { + + switch (static_cast(Input)) { + case DXIL::ComponentType::I16: + case DXIL::ComponentType::U16: + case DXIL::ComponentType::I32: + case DXIL::ComponentType::U32: + case DXIL::ComponentType::F16: + case DXIL::ComponentType::F32: + case DXIL::ComponentType::U8: + case DXIL::ComponentType::I8: + case DXIL::ComponentType::F8_E4M3: + case DXIL::ComponentType::F8_E5M2: + return true; + case DXIL::ComponentType::PackedS8x32: + case DXIL::ComponentType::PackedU8x32: + return InRegister; + default: + return false; + } +} + +static bool IsValidVectorAndMatrixDimensions(Sema &S, CallExpr *CE, + unsigned InputVectorSize, + unsigned OutputVectorSize, + unsigned MatrixK, unsigned MatrixM, + bool isInputPacked) { + // Check if output vector size equals to matrix dimension M + if (OutputVectorSize != MatrixM) { + Expr *OutputVector = CE->getArg(kMatVecMulOutputVectorIdx); + S.Diags.Report( + OutputVector->getExprLoc(), + diag:: + err_hlsl_linalg_mul_muladd_output_vector_size_not_equal_to_matrix_M); + return false; + } + + // Check if input vector size equals to matrix dimension K in the unpacked + // case. + // Check if input vector size equals the smallest number that can hold + // matrix dimension K values + const unsigned PackingFactor = isInputPacked ? 4 : 1; + unsigned MinInputVectorSize = (MatrixK + PackingFactor - 1) / PackingFactor; + if (InputVectorSize != MinInputVectorSize) { + Expr *InputVector = CE->getArg(kMatVecMulInputVectorIdx); + if (isInputPacked) { + S.Diags.Report( + InputVector->getExprLoc(), + diag::err_hlsl_linalg_mul_muladd_packed_input_vector_size_incorrect); + return false; + } else { + S.Diags.Report( + InputVector->getExprLoc(), + diag:: + err_hlsl_linalg_mul_muladd_unpacked_input_vector_size_not_equal_to_matrix_K); + return false; + } + } + + return true; +} + +static void CheckCommonMulAndMulAddParameters(Sema &S, CallExpr *CE, + const hlsl::ShaderModel *SM) { + // Check if IsOutputUnsigned is a const parameter + bool IsOutputUnsignedFlagValue = false; + Expr *IsOutputUnsignedExpr = CE->getArg(kMatVecMulOutputIsUnsignedIdx); + llvm::APSInt IsOutputUnsignedExprVal; + if (IsOutputUnsignedExpr->isIntegerConstantExpr(IsOutputUnsignedExprVal, + S.Context)) { + IsOutputUnsignedFlagValue = IsOutputUnsignedExprVal.getBoolValue(); + } else { + S.Diags.Report(IsOutputUnsignedExpr->getExprLoc(), diag::err_expr_not_ice) + << 0; + return; + } + + Expr *OutputVectorExpr = CE->getArg(kMatVecMulOutputVectorIdx); + unsigned OutputVectorSizeValue = 0; + if (IsHLSLVecType(OutputVectorExpr->getType())) { + OutputVectorSizeValue = GetHLSLVecSize(OutputVectorExpr->getType()); + QualType OutputVectorType = + GetHLSLVecElementType(OutputVectorExpr->getType()); + const Type *OutputVectorTypePtr = OutputVectorType.getTypePtr(); + + // Check if IsOutputUnsigned flag matches output vector type. + // Must be true for unsigned int outputs, false for signed int/float + // outputs. + if (IsOutputUnsignedFlagValue && + !OutputVectorTypePtr->isUnsignedIntegerType()) { + DXASSERT_NOMSG(OutputVectorTypePtr->isSignedIntegerType() || + OutputVectorTypePtr->isFloatingType()); + S.Diags.Report(IsOutputUnsignedExpr->getExprLoc(), + diag::err_hlsl_linalg_isunsigned_incorrect_for_given_type) + << "IsOuputUnsigned" << false + << (OutputVectorTypePtr->isSignedIntegerType() ? 1 : 0); + return; + } else if (!IsOutputUnsignedFlagValue && + OutputVectorTypePtr->isUnsignedIntegerType()) { + S.Diags.Report(IsOutputUnsignedExpr->getExprLoc(), + diag::err_hlsl_linalg_isunsigned_incorrect_for_given_type) + << "IsOuputUnsigned" << true << 2; + return; + } + } + + // Check if isInputUnsigned parameter is a constant + bool IsInputUnsignedFlagValue = false; + Expr *IsInputUnsignedExpr = CE->getArg(kMatVecMulIsInputUnsignedIdx); + llvm::APSInt IsInputUnsignedExprVal; + if (IsInputUnsignedExpr->isIntegerConstantExpr(IsInputUnsignedExprVal, + S.Context)) { + IsInputUnsignedFlagValue = IsInputUnsignedExprVal.getBoolValue(); + } else { + S.Diags.Report(IsInputUnsignedExpr->getExprLoc(), diag::err_expr_not_ice) + << 0; + return; + } + + // Get InputInterpretation, check if it is constant + Expr *InputInterpretationExpr = CE->getArg(kMatVecMulInputInterpretationIdx); + llvm::APSInt InputInterpretationExprVal; + unsigned InputInterpretationValue = 0; + if (InputInterpretationExpr->isIntegerConstantExpr(InputInterpretationExprVal, + S.Context)) { + InputInterpretationValue = InputInterpretationExprVal.getLimitedValue(); + const bool InRegisterInterpretation = true; + if (!IsValidLinalgTypeInterpretation(InputInterpretationValue, + InRegisterInterpretation)) { + S.Diags.Report(InputInterpretationExpr->getExprLoc(), + diag::err_hlsl_linalg_interpretation_value_incorrect) + << std::to_string(InputInterpretationValue) + << InRegisterInterpretation; + return; + } + } else { + S.Diags.Report(InputInterpretationExpr->getExprLoc(), + diag::err_expr_not_ice) + << 0; + return; + } + + bool IsInputVectorPacked = IsPackedType(InputInterpretationValue); + + // For packed types input vector type must be uint and isUnsigned must be + // true. The signedness is determined from the InputInterpretation + Expr *InputVectorExpr = CE->getArg(kMatVecMulInputVectorIdx); + unsigned InputVectorSizeValue = 0; + if (IsHLSLVecType(InputVectorExpr->getType())) { + InputVectorSizeValue = GetHLSLVecSize(InputVectorExpr->getType()); + QualType InputVectorType = + GetHLSLVecElementType(InputVectorExpr->getType()); + unsigned BitWidth = S.Context.getTypeSize(InputVectorType); + bool Is32Bit = (BitWidth == 32); + const Type *InputVectorTypePtr = InputVectorType.getTypePtr(); + + // Check if the isUnsigned flag setting + if (IsInputVectorPacked) { + // Check that the input vector element type is "32bit" + if (!Is32Bit) { + S.Diags.Report( + InputVectorExpr->getExprLoc(), + diag::err_hlsl_linalg_mul_muladd_packed_input_vector_must_be_uint); + return; + } + + // Check that the input vector element type is an unsigned int + if (!InputVectorTypePtr->isUnsignedIntegerType()) { + S.Diags.Report( + InputVectorExpr->getExprLoc(), + diag::err_hlsl_linalg_mul_muladd_packed_input_vector_must_be_uint); + return; + } + + // Check that isInputUnsigned is always true + // Actual signedness is inferred from the InputInterpretation + if (!IsInputUnsignedFlagValue) { + S.Diags.Report( + IsInputUnsignedExpr->getExprLoc(), + diag:: + err_hlsl_linalg_mul_muladd_isUnsigned_for_packed_input_must_be_true); + return; + } + } else { + if (IsInputUnsignedFlagValue && + !InputVectorTypePtr->isUnsignedIntegerType()) { + DXASSERT_NOMSG(InputVectorTypePtr->isSignedIntegerType() || + InputVectorTypePtr->isFloatingType()); + S.Diags.Report( + IsInputUnsignedExpr->getExprLoc(), + diag::err_hlsl_linalg_isunsigned_incorrect_for_given_type) + << "IsInputUnsigned" << false + << (InputVectorTypePtr->isSignedIntegerType() ? 1 : 0); + return; + } else if (!IsInputUnsignedFlagValue && + InputVectorTypePtr->isUnsignedIntegerType()) { + S.Diags.Report( + IsInputUnsignedExpr->getExprLoc(), + diag::err_hlsl_linalg_isunsigned_incorrect_for_given_type) + << "IsInputUnsigned" << true << 2; + return; + } + } + } + + // Get Matrix Dimensions M and K, check if they are constants + Expr *MatrixKExpr = CE->getArg(kMatVecMulMatrixKIdx); + llvm::APSInt MatrixKExprVal; + unsigned MatrixKValue = 0; + if (MatrixKExpr->isIntegerConstantExpr(MatrixKExprVal, S.Context)) { + MatrixKValue = MatrixKExprVal.getLimitedValue(); + } else { + S.Diags.Report(MatrixKExpr->getExprLoc(), diag::err_expr_not_ice) << 0; + return; + } + + Expr *MatrixMExpr = CE->getArg(kMatVecMulMatrixMIdx); + llvm::APSInt MatrixMExprVal; + unsigned MatrixMValue = 0; + if (MatrixMExpr->isIntegerConstantExpr(MatrixMExprVal, S.Context)) { + MatrixMValue = MatrixMExprVal.getLimitedValue(); + } else { + S.Diags.Report(MatrixMExpr->getExprLoc(), diag::err_expr_not_ice) << 0; + return; + } + + // Check MatrixM and MatrixK values are non-zero + if (MatrixMValue == 0) { + S.Diags.Report(MatrixMExpr->getExprLoc(), + diag::err_hlsl_linalg_matrix_dim_must_be_greater_than_zero) + << std::to_string(DXIL::kSM69MaxVectorLength); + return; + } + + if (MatrixKValue == 0) { + S.Diags.Report(MatrixKExpr->getExprLoc(), + diag::err_hlsl_linalg_matrix_dim_must_be_greater_than_zero) + << std::to_string(DXIL::kSM69MaxVectorLength); + return; + } + + // Check MatrixM and MatrixK values are less than max + // Matrix dimension cannot exceed largest vector length in a Mul/MulAdd + // operation. + if (MatrixMValue > DXIL::kSM69MaxVectorLength) { + S.Diags.Report(MatrixMExpr->getExprLoc(), + diag::err_hlsl_linalg_mul_muladd_invalid_dim) + << 0 << std::to_string(DXIL::kSM69MaxVectorLength); + return; + } + + // For packed input vectors 4 values are packed in a uint, so max Matrix K + // can be 4096 + if (IsInputVectorPacked) { + const unsigned PackingFactor = + 4; // Only supported packed formats: DATA_TYPE_(U)SINT8_T4_PACKED + if (MatrixKValue > DXIL::kSM69MaxVectorLength * PackingFactor) { + S.Diags.Report(MatrixKExpr->getExprLoc(), + diag::err_hlsl_linalg_mul_muladd_invalid_dim) + << 2 << std::to_string(DXIL::kSM69MaxVectorLength * PackingFactor); + return; + } + } else { + if (MatrixKValue > DXIL::kSM69MaxVectorLength) { + S.Diags.Report(MatrixKExpr->getExprLoc(), + diag::err_hlsl_linalg_mul_muladd_invalid_dim) + << 1 << std::to_string(DXIL::kSM69MaxVectorLength); + return; + } + } + + if (!IsValidVectorAndMatrixDimensions(S, CE, InputVectorSizeValue, + OutputVectorSizeValue, MatrixKValue, + MatrixMValue, IsInputVectorPacked)) { + return; + } + + // Get MatrixInterpretation, check if it is constant + // Make sure it is a valid value + Expr *MatrixInterpretationExpr = + CE->getArg(kMatVecMulMatrixInterpretationIdx); + llvm::APSInt MatrixInterpretationExprVal; + unsigned MatrixInterpretationValue = 0; + if (MatrixInterpretationExpr->isIntegerConstantExpr( + MatrixInterpretationExprVal, S.Context)) { + MatrixInterpretationValue = MatrixInterpretationExprVal.getLimitedValue(); + const bool InRegisterInterpretation = false; + if (!IsValidLinalgTypeInterpretation(MatrixInterpretationValue, + InRegisterInterpretation)) { + S.Diags.Report(MatrixInterpretationExpr->getExprLoc(), + diag::err_hlsl_linalg_interpretation_value_incorrect) + << std::to_string(MatrixInterpretationValue) + << InRegisterInterpretation; + return; + } + } else { + S.Diags.Report(MatrixInterpretationExpr->getExprLoc(), + diag::err_expr_not_ice) + << 0; + return; + } + + // Get MatrixLayout, check if it is constant and valid value + Expr *MatrixLayoutExpr = CE->getArg(kMatVecMulMatrixLayoutIdx); + llvm::APSInt MatrixLayoutExprVal; + unsigned MatrixLayoutValue = 0; + if (MatrixLayoutExpr->isIntegerConstantExpr(MatrixLayoutExprVal, S.Context)) { + MatrixLayoutValue = MatrixLayoutExprVal.getLimitedValue(); + if (!IsValidMatrixLayoutForMulAndMulAddOps(MatrixLayoutValue)) { + S.Diags.Report(MatrixLayoutExpr->getExprLoc(), + diag::err_hlsl_linalg_matrix_layout_invalid) + << std::to_string(MatrixLayoutValue) + << std::to_string( + static_cast(DXIL::LinalgMatrixLayout::RowMajor)) + << std::to_string(static_cast( + DXIL::LinalgMatrixLayout::OuterProductOptimal)); + return; + } + } else { + S.Diags.Report(MatrixLayoutExpr->getExprLoc(), diag::err_expr_not_ice) << 0; + return; + } + + // Get MatrixTranspose, check if it is constant + Expr *MatrixTransposeExpr = CE->getArg(kMatVecMulMatrixTransposeIdx); + llvm::APSInt MatrixTransposeExprVal; + unsigned MatrixTransposeValue = 0; + if (MatrixTransposeExpr->isIntegerConstantExpr(MatrixTransposeExprVal, + S.Context)) { + MatrixTransposeValue = MatrixTransposeExprVal.getBoolValue(); + if (!IsValidTransposeForMatrixLayout(MatrixLayoutValue, + MatrixTransposeValue)) { + + S.Diags.Report(MatrixTransposeExpr->getExprLoc(), + diag::err_hlsl_linalg_matrix_layout_is_not_transposable); + return; + } + } else { + S.Diags.Report(MatrixTransposeExpr->getExprLoc(), diag::err_expr_not_ice) + << 0; + return; + } + + // Get MatrixStride, check if it is constant, if yes it should be zero + // for optimal layouts + Expr *MatrixStrideExpr = CE->getArg(kMatVecMulMatrixStrideIdx); + llvm::APSInt MatrixStrideExprVal; + unsigned MatrixStrideValue = 0; + if (MatrixStrideExpr->isIntegerConstantExpr(MatrixStrideExprVal, S.Context)) { + MatrixStrideValue = MatrixStrideExprVal.getLimitedValue(); + if (IsOptimalTypeMatrixLayout(MatrixLayoutValue) && + MatrixStrideValue != 0) { + S.Diags.Report( + MatrixStrideExpr->getExprLoc(), + diag:: + err_hlsl_linalg_optimal_matrix_layout_matrix_stride_must_be_zero); + return; + } + } +} + +static void CheckMulCall(Sema &S, FunctionDecl *FD, CallExpr *CE, + const hlsl::ShaderModel *SM) { + CheckCommonMulAndMulAddParameters(S, CE, SM); +} + +static void CheckMulAddCall(Sema &S, FunctionDecl *FD, CallExpr *CE, + const hlsl::ShaderModel *SM) { + CheckCommonMulAndMulAddParameters(S, CE, SM); + + // Check if BiasInterpretation is constant and a valid value + Expr *BiasInterpretationExpr = CE->getArg(kMatVecMulAddBiasInterpretation); + llvm::APSInt BiasInterpretationExprVal; + unsigned BiasInterpretationValue = 0; + if (BiasInterpretationExpr->isIntegerConstantExpr(BiasInterpretationExprVal, + S.Context)) { + BiasInterpretationValue = BiasInterpretationExprVal.getLimitedValue(); + const bool InRegisterInterpretation = false; + if (!IsValidLinalgTypeInterpretation(BiasInterpretationValue, + InRegisterInterpretation)) { + S.Diags.Report(BiasInterpretationExpr->getExprLoc(), + diag::err_hlsl_linalg_interpretation_value_incorrect) + << std::to_string(BiasInterpretationValue) + << InRegisterInterpretation; + return; + } + } else { + S.Diags.Report(BiasInterpretationExpr->getExprLoc(), diag::err_expr_not_ice) + << 0; + return; + } +} + +// Linalg Outer Product Accumulate +// OuterProductAccumulate builtin function parameters +static const unsigned kOuterProdAccInputVector1Idx = 0; +static const unsigned kOuterProdAccInputVector2Idx = 1; +// static const unsigned kOuterProdAccMatrixBufferIdx = 2; +// static const unsigned kOuterProdAccMatrixOffsetIdx = 3; +static const unsigned kOuterProdAccMatrixInterpretationIdx = 4; +static const unsigned kOuterProdAccMatrixLayoutIdx = 5; +static const unsigned kOuterProdAccMatrixStrideIdx = 6; + +static void CheckOuterProductAccumulateCall(Sema &S, FunctionDecl *FD, + CallExpr *CE) { + // Check InputVector1 and InputVector2 are the same type + const Expr *InputVector1Expr = CE->getArg(kOuterProdAccInputVector1Idx); + const Expr *InputVector2Expr = CE->getArg(kOuterProdAccInputVector2Idx); + QualType InputVector1Type = InputVector1Expr->getType(); + QualType InputVector2Type = InputVector2Expr->getType(); + + // Get the element types of the vectors + const QualType InputVector1ElementType = + GetHLSLVecElementType(InputVector1Type); + const QualType InputVector2ElementType = + GetHLSLVecElementType(InputVector2Type); + + if (!S.Context.hasSameType(InputVector1ElementType, + InputVector2ElementType)) { + S.Diags.Report(InputVector2Expr->getExprLoc(), + diag::err_hlsl_linalg_outer_prod_acc_vector_type_mismatch); + return; + } + + // Check Matrix Interpretation is a constant and a valid value + Expr *MatrixInterpretationExpr = + CE->getArg(kOuterProdAccMatrixInterpretationIdx); + llvm::APSInt MatrixInterpretationExprVal; + unsigned MatrixInterpretationValue = 0; + if (MatrixInterpretationExpr->isIntegerConstantExpr( + MatrixInterpretationExprVal, S.Context)) { + MatrixInterpretationValue = MatrixInterpretationExprVal.getLimitedValue(); + const bool InRegisterInterpretation = false; + if (!IsValidLinalgTypeInterpretation(MatrixInterpretationValue, + InRegisterInterpretation)) { + S.Diags.Report(MatrixInterpretationExpr->getExprLoc(), + diag::err_hlsl_linalg_interpretation_value_incorrect) + << std::to_string(MatrixInterpretationValue) + << InRegisterInterpretation; + return; + } + } else { + S.Diags.Report(MatrixInterpretationExpr->getExprLoc(), + diag::err_expr_not_ice) + << 0; + return; + } + + // Check Matrix Layout must be a constant and Training Optimal + Expr *MatrixLayoutExpr = CE->getArg(kOuterProdAccMatrixLayoutIdx); + llvm::APSInt MatrixLayoutExprVal; + unsigned MatrixLayoutValue = 0; + if (MatrixLayoutExpr->isIntegerConstantExpr(MatrixLayoutExprVal, S.Context)) { + MatrixLayoutValue = MatrixLayoutExprVal.getLimitedValue(); + if (MatrixLayoutValue != + static_cast(DXIL::LinalgMatrixLayout::OuterProductOptimal)) { + S.Diags.Report( + MatrixLayoutExpr->getExprLoc(), + diag:: + err_hlsl_linalg_outer_prod_acc_matrix_layout_must_be_outer_prod_acc_optimal) + << std::to_string(static_cast( + DXIL::LinalgMatrixLayout::OuterProductOptimal)); + return; + } + } else { + S.Diags.Report(MatrixLayoutExpr->getExprLoc(), diag::err_expr_not_ice) << 0; + return; + } + + // Matrix Stride must be zero (Training Optimal matrix layout) + Expr *MatrixStrideExpr = CE->getArg(kOuterProdAccMatrixStrideIdx); + llvm::APSInt MatrixStrideExprVal; + unsigned MatrixStrideValue = 0; + if (MatrixStrideExpr->isIntegerConstantExpr(MatrixStrideExprVal, S.Context)) { + MatrixStrideValue = MatrixStrideExprVal.getLimitedValue(); + if (MatrixStrideValue != 0) { + S.Diags.Report( + MatrixStrideExpr->getExprLoc(), + diag:: + err_hlsl_linalg_optimal_matrix_layout_matrix_stride_must_be_zero); + return; + } + } +} + #ifdef ENABLE_SPIRV_CODEGEN static bool CheckVKBufferPointerCast(Sema &S, FunctionDecl *FD, CallExpr *CE, bool isStatic) { @@ -11710,6 +12251,15 @@ void Sema::CheckHLSLFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall, case hlsl::IntrinsicOp::IOP_Barrier: CheckBarrierCall(*this, FDecl, TheCall, SM); break; + case hlsl::IntrinsicOp::IOP___builtin_MatVecMul: + CheckMulCall(*this, FDecl, TheCall, SM); + break; + case hlsl::IntrinsicOp::IOP___builtin_MatVecMulAdd: + CheckMulAddCall(*this, FDecl, TheCall, SM); + break; + case hlsl::IntrinsicOp::IOP___builtin_OuterProductAccumulate: + CheckOuterProductAccumulateCall(*this, FDecl, TheCall); + break; #ifdef ENABLE_SPIRV_CODEGEN case hlsl::IntrinsicOp::IOP_Vkreinterpret_pointer_cast: CheckVKBufferPointerCast(*this, FDecl, TheCall, false); @@ -12108,18 +12658,6 @@ void Sema::DiagnoseReachableHLSLCall(CallExpr *CE, const hlsl::ShaderModel *SM, break; case hlsl::IntrinsicOp::IOP_DxMaybeReorderThread: DiagnoseReachableSERCall(*this, CE, EntrySK, EntryDecl, true); - break; - case hlsl::IntrinsicOp::IOP___builtin_MatVecMul: - case hlsl::IntrinsicOp::IOP___builtin_MatVecMulAdd: - case hlsl::IntrinsicOp::IOP___builtin_OuterProductAccumulate: - case hlsl::IntrinsicOp::IOP___builtin_VectorAccumulate: - if (!SM->IsSM69Plus()) { - Diags.Report(CE->getExprLoc(), - diag::warn_hlsl_intrinsic_in_wrong_shader_model) - << FD->getNameAsString() << EntryDecl->getNameAsString() << "6.9"; - return; - } - break; default: break; diff --git a/tools/clang/test/CodeGenDXIL/hlsl/intrinsics/linalg_builtins/mat-vec-mul-add_multioverload.hlsl b/tools/clang/test/CodeGenDXIL/hlsl/intrinsics/linalg_builtins/mat-vec-mul-add_multioverload.hlsl index 98a568fa22..de811982d6 100644 --- a/tools/clang/test/CodeGenDXIL/hlsl/intrinsics/linalg_builtins/mat-vec-mul-add_multioverload.hlsl +++ b/tools/clang/test/CodeGenDXIL/hlsl/intrinsics/linalg_builtins/mat-vec-mul-add_multioverload.hlsl @@ -1,43 +1,57 @@ -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DII=F16 -DMI=F16 -DML=RowMajor -DMT=0 -DBI=F16 | FileCheck %s --check-prefixes COMMON,DXIL-0 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DII=F8_E4M3 -DMI=F8_E4M3 -DML=MulOptimal -DMT=0 -DBI=F16 | FileCheck %s --check-prefixes COMMON,DXIL-1 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DII=F8_E5M2 -DMI=F8_E5M2 -DML=MulOptimal -DMT=1 -DBI=F16 | FileCheck %s --check-prefixes COMMON,DXIL-2 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=uint -DII=PackedS8x32 -DMI=I8 -DML=OuterProductOptimal -DMT=1 -DBI=I32 | FileCheck %s --check-prefixes COMMON,DXIL-3 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=float -DII=I8 -DMI=I8 -DML=RowMajor -DMT=0 -DBI=I32 | FileCheck %s --check-prefixes COMMON,DXIL-4 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=1 -DOTY=uint -DIU=0 -DITY=float -DII=I8 -DMI=F16 -DML=RowMajor -DMT=0 -DBI=I8 | FileCheck %s --check-prefixes COMMON,DXIL-5 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=1 -DITY=uint -DII=U8 -DMI=I8 -DML=ColumnMajor -DMT=0 -DBI=I8 | FileCheck %s --check-prefixes COMMON,DXIL-6 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=int -DII=U8 -DMI=U8 -DML=MulOptimal -DMT=1 -DBI=I8 | FileCheck %s --check-prefixes COMMON,DXIL-7 - -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DII=F16 -DMI=F16 -DML=RowMajor -DMT=0 -DBI=F16 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-0 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DII=F8_E4M3 -DMI=F8_E4M3 -DML=MulOptimal -DMT=0 -DBI=F16 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-1 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DII=F8_E5M2 -DMI=F8_E5M2 -DML=MulOptimal -DMT=1 -DBI=F16 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-2 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=uint -DII=PackedS8x32 -DMI=I8 -DML=OuterProductOptimal -DMT=1 -DBI=I32 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-3 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=float -DII=I8 -DMI=I8 -DML=RowMajor -DMT=0 -DBI=I32 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-4 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=1 -DOTY=uint -DIU=0 -DITY=float -DII=I8 -DMI=F16 -DML=RowMajor -DMT=0 -DBI=I8 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-5 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=1 -DITY=uint -DII=U8 -DMI=I8 -DML=ColumnMajor -DMT=0 -DBI=I8 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-6 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=int -DII=U8 -DMI=U8 -DML=MulOptimal -DMT=1 -DBI=I8 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-7 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DINUM=8 -DII=F16 -DMI=F16 -DML=RowMajor -DMT=0 -DBI=F16 -DMST=64 | FileCheck %s --check-prefixes COMMON,DXIL-0 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DINUM=8 -DII=F8_E4M3 -DMI=F8_E4M3 -DML=MulOptimal -DMT=0 -DBI=F16 -DMST=0 | FileCheck %s --check-prefixes COMMON,DXIL-1 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DINUM=8 -DII=F8_E5M2 -DMI=F8_E5M2 -DML=MulOptimal -DMT=1 -DBI=F16 -DMST=0 | FileCheck %s --check-prefixes COMMON,DXIL-2 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=1 -DITY=uint -DINUM=2 -DII=PackedS8x32 -DMI=I8 -DML=OuterProductOptimal -DMT=1 -DBI=I32 -DMST=0 | FileCheck %s --check-prefixes COMMON,DXIL-3 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=float -DINUM=8 -DII=I8 -DMI=I8 -DML=RowMajor -DMT=0 -DBI=I32 -DMST=64 | FileCheck %s --check-prefixes COMMON,DXIL-4 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=1 -DOTY=uint -DIU=0 -DITY=float -DINUM=8 -DII=I8 -DMI=F16 -DML=RowMajor -DMT=0 -DBI=I8 -DMST=64 | FileCheck %s --check-prefixes COMMON,DXIL-5 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=1 -DITY=uint -DINUM=8 -DII=U8 -DMI=I8 -DML=ColumnMajor -DMT=0 -DBI=I8 -DMST=64 | FileCheck %s --check-prefixes COMMON,DXIL-6 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=int -DINUM=8 -DII=U8 -DMI=U8 -DML=MulOptimal -DMT=1 -DBI=I8 -DMST=0 | FileCheck %s --check-prefixes COMMON,DXIL-7 + +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DINUM=8 -DII=F16 -DMI=F16 -DML=RowMajor -DMT=0 -DBI=F16 -DMST=64 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-0 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DINUM=8 -DII=F8_E4M3 -DMI=F8_E4M3 -DML=MulOptimal -DMT=0 -DBI=F16 -DMST=0 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-1 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DINUM=8 -DII=F8_E5M2 -DMI=F8_E5M2 -DML=MulOptimal -DMT=1 -DBI=F16 -DMST=0 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-2 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=1 -DITY=uint -DINUM=2 -DII=PackedS8x32 -DMI=I8 -DML=OuterProductOptimal -DMT=1 -DBI=I32 -DMST=0 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-3 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=float -DINUM=8 -DII=I8 -DMI=I8 -DML=RowMajor -DMT=0 -DBI=I32 -DMST=64 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-4 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=1 -DOTY=uint -DIU=0 -DITY=float -DINUM=8 -DII=I8 -DMI=F16 -DML=RowMajor -DMT=0 -DBI=I8 -DMST=64 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-5 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=1 -DITY=uint -DINUM=8 -DII=U8 -DMI=I8 -DML=ColumnMajor -DMT=0 -DBI=I8 -DMST=64 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-6 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=int -DINUM=8 -DII=U8 -DMI=U8 -DML=MulOptimal -DMT=1 -DBI=I8 -DMST=0 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-7 // COMMON: define void @main() // Test minimum support set of combinations for matVecMul -// HLOP-0: call void @"dx.hl.op..void (i32, <4 x half>*, i1, <8 x half>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32, %dx.types.Handle, i32, i32)"(i32 391, <4 x half>* %output_vector, i1 false, <8 x half> %{{[^ ]+}}, i1 false, i32 8, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 8, i32 8, i32 8, i32 0, i1 false, i32 64, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 8) -// DXIL-0: call <4 x half> @dx.op.matVecMulAdd.v4f16.v8f16(i32 306, <8 x half> {{[^ ]+}}, i1 false, i32 8, %dx.types.Handle {{[^ ]+}}, i32 0, i32 8, i32 8, i32 8, i32 0, i1 false, i32 64, %dx.types.Handle {{[^ ]+}}, i32 0, i32 8, i1 false) ; MatVecMulAdd(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,biasBuffer,biasOffset,biasIntepretation,isOutputUnsigned) -// HLOP-1: call void @"dx.hl.op..void (i32, <4 x half>*, i1, <8 x half>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32, %dx.types.Handle, i32, i32)"(i32 391, <4 x half>* %output_vector, i1 false, <8 x half> %{{[^ ]+}}, i1 false, i32 21, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 21, i32 8, i32 8, i32 2, i1 false, i32 64, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 8) -// DXIL-1: call <4 x half> @dx.op.matVecMulAdd.v4f16.v8f16(i32 306, <8 x half> {{[^ ]+}}, i1 false, i32 21, %dx.types.Handle {{[^ ]+}}, i32 0, i32 21, i32 8, i32 8, i32 2, i1 false, i32 64, %dx.types.Handle {{[^ ]+}}, i32 0, i32 8, i1 false) ; MatVecMulAdd(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,biasBuffer,biasOffset,biasIntepretation,isOutputUnsigned) -// HLOP-2: call void @"dx.hl.op..void (i32, <4 x half>*, i1, <8 x half>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32, %dx.types.Handle, i32, i32)"(i32 391, <4 x half>* %output_vector, i1 false, <8 x half> %{{[^ ]+}}, i1 false, i32 22, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 22, i32 8, i32 8, i32 2, i1 true, i32 64, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 8) -// DXIL-2: call <4 x half> @dx.op.matVecMulAdd.v4f16.v8f16(i32 306, <8 x half> {{[^ ]+}}, i1 false, i32 22, %dx.types.Handle {{[^ ]+}}, i32 0, i32 22, i32 8, i32 8, i32 2, i1 true, i32 64, %dx.types.Handle {{[^ ]+}}, i32 0, i32 8, i1 false) ; MatVecMulAdd(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,biasBuffer,biasOffset,biasIntepretation,isOutputUnsigned) -// HLOP-3: call void @"dx.hl.op..void (i32, <4 x i32>*, i1, <8 x i32>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32, %dx.types.Handle, i32, i32)"(i32 391, <4 x i32>* %output_vector, i1 false, <8 x i32> %{{[^ ]+}}, i1 false, i32 17, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 3, i1 true, i32 64, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 4) -// DXIL-3: call <4 x i32> @dx.op.matVecMulAdd.v4i32.v8i32(i32 306, <8 x i32> {{[^ ]+}}, i1 false, i32 17, %dx.types.Handle {{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 3, i1 true, i32 64, %dx.types.Handle {{[^ ]+}}, i32 0, i32 4, i1 false) ; MatVecMulAdd(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,biasBuffer,biasOffset,biasIntepretation,isOutputUnsigned) -// HLOP-4: call void @"dx.hl.op..void (i32, <4 x i32>*, i1, <8 x float>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32, %dx.types.Handle, i32, i32)"(i32 391, <4 x i32>* %output_vector, i1 false, <8 x float> %{{[^ ]+}}, i1 false, i32 20, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 0, i1 false, i32 64, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 4) -// DXIL-4: call <4 x i32> @dx.op.matVecMulAdd.v4i32.v8f32(i32 306, <8 x float> {{[^ ]+}}, i1 false, i32 20, %dx.types.Handle {{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 0, i1 false, i32 64, %dx.types.Handle {{[^ ]+}}, i32 0, i32 4, i1 false) ; MatVecMulAdd(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,biasBuffer,biasOffset,biasIntepretation,isOutputUnsigned) +// HLOP-0: call void @"dx.hl.op..void (i32, <8 x half>*, i1, <8 x half>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32, %dx.types.Handle, i32, i32)"(i32 391, <8 x half>* %output_vector, i1 false, <8 x half> %{{[^ ]+}}, i1 false, i32 8, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 8, i32 8, i32 8, i32 0, i1 false, i32 64, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 8) + +// DXIL-0: call <8 x half> @dx.op.matVecMulAdd.v8f16.v8f16(i32 306, <8 x half> {{[^ ]+}}, i1 false, i32 8, %dx.types.Handle {{[^ ]+}}, i32 0, i32 8, i32 8, i32 8, i32 0, i1 false, i32 64, %dx.types.Handle {{[^ ]+}}, i32 0, i32 8, i1 false) ; MatVecMulAdd(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,biasBuffer,biasOffset,biasIntepretation,isOutputUnsigned) + +// HLOP-1: call void @"dx.hl.op..void (i32, <8 x half>*, i1, <8 x half>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32, %dx.types.Handle, i32, i32)"(i32 391, <8 x half>* %output_vector, i1 false, <8 x half> %{{[^ ]+}}, i1 false, i32 21, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 21, i32 8, i32 8, i32 2, i1 false, i32 0, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 8) + +// DXIL-1: call <8 x half> @dx.op.matVecMulAdd.v8f16.v8f16(i32 306, <8 x half> {{[^ ]+}}, i1 false, i32 21, %dx.types.Handle {{[^ ]+}}, i32 0, i32 21, i32 8, i32 8, i32 2, i1 false, i32 0, %dx.types.Handle {{[^ ]+}}, i32 0, i32 8, i1 false) ; MatVecMulAdd(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,biasBuffer,biasOffset,biasIntepretation,isOutputUnsigned) + +// HLOP-2: call void @"dx.hl.op..void (i32, <8 x half>*, i1, <8 x half>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32, %dx.types.Handle, i32, i32)"(i32 391, <8 x half>* %output_vector, i1 false, <8 x half> %{{[^ ]+}}, i1 false, i32 22, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 22, i32 8, i32 8, i32 2, i1 true, i32 0, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 8) + +// DXIL-2: call <8 x half> @dx.op.matVecMulAdd.v8f16.v8f16(i32 306, <8 x half> {{[^ ]+}}, i1 false, i32 22, %dx.types.Handle {{[^ ]+}}, i32 0, i32 22, i32 8, i32 8, i32 2, i1 true, i32 0, %dx.types.Handle {{[^ ]+}}, i32 0, i32 8, i1 false) ; MatVecMulAdd(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,biasBuffer,biasOffset,biasIntepretation,isOutputUnsigned) + +// HLOP-3: call void @"dx.hl.op..void (i32, <8 x i32>*, i1, <2 x i32>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32, %dx.types.Handle, i32, i32)"(i32 391, <8 x i32>* %output_vector, i1 false, <2 x i32> %{{[^ ]+}}, i1 true, i32 17, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 3, i1 true, i32 0, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 4) + +// DXIL-3: call <8 x i32> @dx.op.matVecMulAdd.v8i32.v2i32(i32 306, <2 x i32> {{[^ ]+}}, i1 true, i32 17, %dx.types.Handle {{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 3, i1 true, i32 0, %dx.types.Handle {{[^ ]+}}, i32 0, i32 4, i1 false) ; MatVecMulAdd(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,biasBuffer,biasOffset,biasIntepretation,isOutputUnsigned) + +// HLOP-4: call void @"dx.hl.op..void (i32, <8 x i32>*, i1, <8 x float>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32, %dx.types.Handle, i32, i32)"(i32 391, <8 x i32>* %output_vector, i1 false, <8 x float> %{{[^ ]+}}, i1 false, i32 20, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 0, i1 false, i32 64, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 4) + +// DXIL-4: call <8 x i32> @dx.op.matVecMulAdd.v8i32.v8f32(i32 306, <8 x float> {{[^ ]+}}, i1 false, i32 20, %dx.types.Handle {{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 0, i1 false, i32 64, %dx.types.Handle {{[^ ]+}}, i32 0, i32 4, i1 false) ; MatVecMulAdd(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,biasBuffer,biasOffset,biasIntepretation,isOutputUnsigned) // Test unsigned variations -// HLOP-5: call void @"dx.hl.op..void (i32, <4 x i32>*, i1, <8 x float>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32, %dx.types.Handle, i32, i32)"(i32 391, <4 x i32>* %output_vector, i1 true, <8 x float> %{{[^ ]+}}, i1 false, i32 20, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 8, i32 8, i32 8, i32 0, i1 false, i32 64, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 20) -// DXIL-5: call <4 x i32> @dx.op.matVecMulAdd.v4i32.v8f32(i32 306, <8 x float> {{[^ ]+}}, i1 false, i32 20, %dx.types.Handle {{[^ ]+}}, i32 0, i32 8, i32 8, i32 8, i32 0, i1 false, i32 64, %dx.types.Handle {{[^ ]+}}, i32 0, i32 20, i1 true) ; MatVecMulAdd(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,biasBuffer,biasOffset,biasIntepretation,isOutputUnsigned) -// HLOP-6: call void @"dx.hl.op..void (i32, <4 x i32>*, i1, <8 x i32>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32, %dx.types.Handle, i32, i32)"(i32 391, <4 x i32>* %output_vector, i1 false, <8 x i32> %{{[^ ]+}}, i1 true, i32 19, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 1, i1 false, i32 64, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 20) -// DXIL-6: call <4 x i32> @dx.op.matVecMulAdd.v4i32.v8i32(i32 306, <8 x i32> {{[^ ]+}}, i1 true, i32 19, %dx.types.Handle {{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 1, i1 false, i32 64, %dx.types.Handle {{[^ ]+}}, i32 0, i32 20, i1 false) ; MatVecMulAdd(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,biasBuffer,biasOffset,biasIntepretation,isOutputUnsigned) -// HLOP-7: call void @"dx.hl.op..void (i32, <4 x i32>*, i1, <8 x i32>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32, %dx.types.Handle, i32, i32)"(i32 391, <4 x i32>* %output_vector, i1 false, <8 x i32> %{{[^ ]+}}, i1 false, i32 19, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 19, i32 8, i32 8, i32 2, i1 true, i32 64, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 20) -// DXIL-7: call <4 x i32> @dx.op.matVecMulAdd.v4i32.v8i32(i32 306, <8 x i32> {{[^ ]+}}, i1 false, i32 19, %dx.types.Handle {{[^ ]+}}, i32 0, i32 19, i32 8, i32 8, i32 2, i1 true, i32 64, %dx.types.Handle {{[^ ]+}}, i32 0, i32 20, i1 false) ; MatVecMulAdd(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,biasBuffer,biasOffset,biasIntepretation,isOutputUnsigned) +// HLOP-5: call void @"dx.hl.op..void (i32, <8 x i32>*, i1, <8 x float>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32, %dx.types.Handle, i32, i32)"(i32 391, <8 x i32>* %output_vector, i1 true, <8 x float> %{{[^ ]+}}, i1 false, i32 20, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 8, i32 8, i32 8, i32 0, i1 false, i32 64, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 20) + +// DXIL-5: call <8 x i32> @dx.op.matVecMulAdd.v8i32.v8f32(i32 306, <8 x float> {{[^ ]+}}, i1 false, i32 20, %dx.types.Handle {{[^ ]+}}, i32 0, i32 8, i32 8, i32 8, i32 0, i1 false, i32 64, %dx.types.Handle {{[^ ]+}}, i32 0, i32 20, i1 true) ; MatVecMulAdd(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,biasBuffer,biasOffset,biasIntepretation,isOutputUnsigned) + +// HLOP-6: call void @"dx.hl.op..void (i32, <8 x i32>*, i1, <8 x i32>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32, %dx.types.Handle, i32, i32)"(i32 391, <8 x i32>* %output_vector, i1 false, <8 x i32> %{{[^ ]+}}, i1 true, i32 19, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 1, i1 false, i32 64, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 20) + +// DXIL-6: call <8 x i32> @dx.op.matVecMulAdd.v8i32.v8i32(i32 306, <8 x i32> {{[^ ]+}}, i1 true, i32 19, %dx.types.Handle {{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 1, i1 false, i32 64, %dx.types.Handle {{[^ ]+}}, i32 0, i32 20, i1 false) ; MatVecMulAdd(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,biasBuffer,biasOffset,biasIntepretation,isOutputUnsigned) + +// HLOP-7: call void @"dx.hl.op..void (i32, <8 x i32>*, i1, <8 x i32>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32, %dx.types.Handle, i32, i32)"(i32 391, <8 x i32>* %output_vector, i1 false, <8 x i32> %{{[^ ]+}}, i1 false, i32 19, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 19, i32 8, i32 8, i32 2, i1 true, i32 0, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 20) + +// DXIL-7: call <8 x i32> @dx.op.matVecMulAdd.v8i32.v8i32(i32 306, <8 x i32> {{[^ ]+}}, i1 false, i32 19, %dx.types.Handle {{[^ ]+}}, i32 0, i32 19, i32 8, i32 8, i32 2, i1 true, i32 0, %dx.types.Handle {{[^ ]+}}, i32 0, i32 20, i1 false) ; MatVecMulAdd(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,biasBuffer,biasOffset,biasIntepretation,isOutputUnsigned) ByteAddressBuffer input_vector_buffer; @@ -84,10 +98,10 @@ enum MatLayout { [NumThreads(1,1,1)] void main() { - vector output_vector; + vector output_vector; static const uint is_output_unsigned = OU; - vector input_vector = input_vector_buffer.Load >(0); + vector input_vector = input_vector_buffer.Load >(0); const uint is_input_unsigned = IU; const uint input_interpretation = II; @@ -97,7 +111,7 @@ void main() const uint matrix_dimK = 8; const uint matrix_layout = ML; const bool matrix_is_transposed = (bool) MT; - const uint matrix_stride = 64; + const uint matrix_stride = MST; const uint bias_offset = 0; const uint bias_interpretation = BI; diff --git a/tools/clang/test/CodeGenDXIL/hlsl/intrinsics/linalg_builtins/mat-vec-mul_multioverload.hlsl b/tools/clang/test/CodeGenDXIL/hlsl/intrinsics/linalg_builtins/mat-vec-mul_multioverload.hlsl index 2ca2648503..8b14fb4cf1 100644 --- a/tools/clang/test/CodeGenDXIL/hlsl/intrinsics/linalg_builtins/mat-vec-mul_multioverload.hlsl +++ b/tools/clang/test/CodeGenDXIL/hlsl/intrinsics/linalg_builtins/mat-vec-mul_multioverload.hlsl @@ -1,42 +1,56 @@ -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DII=F16 -DMI=F16 -DML=RowMajor -DMT=0 | FileCheck %s --check-prefixes COMMON,DXIL-0 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DII=F8_E4M3 -DMI=F8_E4M3 -DML=MulOptimal -DMT=0 | FileCheck %s --check-prefixes COMMON,DXIL-1 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DII=F8_E5M2 -DMI=F8_E5M2 -DML=MulOptimal -DMT=1 | FileCheck %s --check-prefixes COMMON,DXIL-2 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=uint -DII=PackedS8x32 -DMI=I8 -DML=OuterProductOptimal -DMT=1 | FileCheck %s --check-prefixes COMMON,DXIL-3 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=float -DII=I8 -DMI=I8 -DML=RowMajor -DMT=0 | FileCheck %s --check-prefixes COMMON,DXIL-4 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=1 -DOTY=uint -DIU=0 -DITY=float -DII=I8 -DMI=F16 -DML=RowMajor -DMT=0 | FileCheck %s --check-prefixes COMMON,DXIL-5 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=1 -DITY=uint -DII=U8 -DMI=I8 -DML=ColumnMajor -DMT=0 | FileCheck %s --check-prefixes COMMON,DXIL-6 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=int -DII=U8 -DMI=U8 -DML=MulOptimal -DMT=1 | FileCheck %s --check-prefixes COMMON,DXIL-7 - -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DII=F16 -DMI=F16 -DML=RowMajor -DMT=0 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-0 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DII=F8_E4M3 -DMI=F8_E4M3 -DML=MulOptimal -DMT=0 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-1 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DII=F8_E5M2 -DMI=F8_E5M2 -DML=MulOptimal -DMT=1 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-2 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=uint -DII=PackedS8x32 -DMI=I8 -DML=OuterProductOptimal -DMT=1 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-3 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=float -DII=I8 -DMI=I8 -DML=RowMajor -DMT=0 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-4 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=1 -DOTY=uint -DIU=0 -DITY=float -DII=I8 -DMI=F16 -DML=RowMajor -DMT=0 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-5 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=1 -DITY=uint -DII=U8 -DMI=I8 -DML=ColumnMajor -DMT=0 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-6 -// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=int -DII=U8 -DMI=U8 -DML=MulOptimal -DMT=1 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-7 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DINUM=8 -DII=F16 -DMI=F16 -DML=RowMajor -DMT=0 -DMST=64 | FileCheck %s --check-prefixes COMMON,DXIL-0 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DINUM=8 -DII=F8_E4M3 -DMI=F8_E4M3 -DML=MulOptimal -DMT=0 -DMST=0 | FileCheck %s --check-prefixes COMMON,DXIL-1 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DINUM=8 -DII=F8_E5M2 -DMI=F8_E5M2 -DML=MulOptimal -DMT=1 -DMST=0| FileCheck %s --check-prefixes COMMON,DXIL-2 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=1 -DITY=uint -DII=PackedS8x32 -DINUM=2 -DMI=I8 -DML=OuterProductOptimal -DMT=1 -DMST=0 | FileCheck %s --check-prefixes COMMON,DXIL-3 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=float -DINUM=8 -DII=I8 -DMI=I8 -DML=RowMajor -DMT=0 -DMST=64 | FileCheck %s --check-prefixes COMMON,DXIL-4 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=1 -DOTY=uint -DIU=0 -DITY=float -DINUM=8 -DII=I8 -DMI=F16 -DINUM=8 -DML=RowMajor -DMT=0 -DMST=64 | FileCheck %s --check-prefixes COMMON,DXIL-5 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=1 -DITY=uint -DINUM=8 -DII=U8 -DMI=I8 -DINUM=8 -DML=ColumnMajor -DMT=0 -DMST=64 | FileCheck %s --check-prefixes COMMON,DXIL-6 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=int -DINUM=8 -DII=U8 -DMI=U8 -DINUM=8 -DML=MulOptimal -DMT=1 -DMST=0 | FileCheck %s --check-prefixes COMMON,DXIL-7 + +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DINUM=8 -DII=F16 -DMI=F16 -DML=RowMajor -DMT=0 -DMST=64 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-0 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DINUM=8 -DII=F8_E4M3 -DMI=F8_E4M3 -DML=MulOptimal -DMT=0 -DMST=0 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-1 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=float16_t -DIU=0 -DITY=float16_t -DINUM=8 -DII=F8_E5M2 -DMI=F8_E5M2 -DML=MulOptimal -DMT=1 -DMST=0 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-2 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=1 -DITY=uint -DINUM=2 -DII=PackedS8x32 -DMI=I8 -DML=OuterProductOptimal -DMT=1 -DMST=0 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-3 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=float -DINUM=8 -DII=I8 -DMI=I8 -DML=RowMajor -DMT=0 -DMST=64 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-4 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=1 -DOTY=uint -DIU=0 -DITY=float -DINUM=8 -DII=I8 -DMI=F16 -DML=RowMajor -DMT=0 -DMST=64 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-5 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=1 -DITY=uint -DINUM=8 -DII=U8 -DMI=I8 -DML=ColumnMajor -DMT=0 -DMST=64 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-6 +// RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DOU=0 -DOTY=int -DIU=0 -DITY=int -DINUM=8 -DII=U8 -DMI=U8 -DML=MulOptimal -DMT=1 -DMST=0 -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-7 // COMMON: define void @main() // Test minimum support set of combinations for matVecMul -// HLOP-0: call void @"dx.hl.op..void (i32, <4 x half>*, i1, <8 x half>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32)"(i32 390, <4 x half>* %output_vector, i1 false, <8 x half> %{{[^ ]+}}, i1 false, i32 8, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 8, i32 8, i32 8, i32 0, i1 false, i32 64) -// DXIL-0: call <4 x half> @dx.op.matVecMul.v4f16.v8f16(i32 305, <8 x half> {{[^ ]+}}, i1 false, i32 8, %dx.types.Handle {{[^ ]+}}, i32 0, i32 8, i32 8, i32 8, i32 0, i1 false, i32 64, i1 false) ; MatVecMul(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,isOutputUnsigned) -// HLOP-1: call void @"dx.hl.op..void (i32, <4 x half>*, i1, <8 x half>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32)"(i32 390, <4 x half>* %output_vector, i1 false, <8 x half> %{{[^ ]+}}, i1 false, i32 21, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 21, i32 8, i32 8, i32 2, i1 false, i32 64) -// DXIL-1: call <4 x half> @dx.op.matVecMul.v4f16.v8f16(i32 305, <8 x half> {{[^ ]+}}, i1 false, i32 21, %dx.types.Handle {{[^ ]+}}, i32 0, i32 21, i32 8, i32 8, i32 2, i1 false, i32 64, i1 false) ; MatVecMul(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,isOutputUnsigned) -// HLOP-2: call void @"dx.hl.op..void (i32, <4 x half>*, i1, <8 x half>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32)"(i32 390, <4 x half>* %output_vector, i1 false, <8 x half> %{{[^ ]+}}, i1 false, i32 22, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 22, i32 8, i32 8, i32 2, i1 true, i32 64) -// DXIL-2: call <4 x half> @dx.op.matVecMul.v4f16.v8f16(i32 305, <8 x half> {{[^ ]+}}, i1 false, i32 22, %dx.types.Handle {{[^ ]+}}, i32 0, i32 22, i32 8, i32 8, i32 2, i1 true, i32 64, i1 false) ; MatVecMul(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,isOutputUnsigned) -// HLOP-3: call void @"dx.hl.op..void (i32, <4 x i32>*, i1, <8 x i32>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32)"(i32 390, <4 x i32>* %output_vector, i1 false, <8 x i32> %{{[^ ]+}}, i1 false, i32 17, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 3, i1 true, i32 64) -// DXIL-3: call <4 x i32> @dx.op.matVecMul.v4i32.v8i32(i32 305, <8 x i32> {{[^ ]+}}, i1 false, i32 17, %dx.types.Handle {{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 3, i1 true, i32 64, i1 false) ; MatVecMul(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,isOutputUnsigned) -// HLOP-4: call void @"dx.hl.op..void (i32, <4 x i32>*, i1, <8 x float>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32)"(i32 390, <4 x i32>* %output_vector, i1 false, <8 x float> %{{[^ ]+}}, i1 false, i32 20, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 0, i1 false, i32 64) -// DXIL-4: call <4 x i32> @dx.op.matVecMul.v4i32.v8f32(i32 305, <8 x float> {{[^ ]+}}, i1 false, i32 20, %dx.types.Handle {{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 0, i1 false, i32 64, i1 false) ; MatVecMul(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,isOutputUnsigned) +// HLOP-0: call void @"dx.hl.op..void (i32, <8 x half>*, i1, <8 x half>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32)"(i32 390, <8 x half>* %output_vector, i1 false, <8 x half> %{{[^ ]+}}, i1 false, i32 8, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 8, i32 8, i32 8, i32 0, i1 false, i32 64) + +// DXIL-0: call <8 x half> @dx.op.matVecMul.v8f16.v8f16(i32 305, <8 x half> {{[^ ]+}}, i1 false, i32 8, %dx.types.Handle {{[^ ]+}}, i32 0, i32 8, i32 8, i32 8, i32 0, i1 false, i32 64, i1 false) ; MatVecMul(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,isOutputUnsigned) + +// HLOP-1: call void @"dx.hl.op..void (i32, <8 x half>*, i1, <8 x half>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32)"(i32 390, <8 x half>* %output_vector, i1 false, <8 x half> %{{[^ ]+}}, i1 false, i32 21, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 21, i32 8, i32 8, i32 2, i1 false, i32 0) + +// DXIL-1: call <8 x half> @dx.op.matVecMul.v8f16.v8f16(i32 305, <8 x half> {{[^ ]+}}, i1 false, i32 21, %dx.types.Handle {{[^ ]+}}, i32 0, i32 21, i32 8, i32 8, i32 2, i1 false, i32 0, i1 false) ; MatVecMul(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,isOutputUnsigned) + +// HLOP-2: call void @"dx.hl.op..void (i32, <8 x half>*, i1, <8 x half>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32)"(i32 390, <8 x half>* %output_vector, i1 false, <8 x half> %{{[^ ]+}}, i1 false, i32 22, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 22, i32 8, i32 8, i32 2, i1 true, i32 0) + +// DXIL-2: call <8 x half> @dx.op.matVecMul.v8f16.v8f16(i32 305, <8 x half> {{[^ ]+}}, i1 false, i32 22, %dx.types.Handle {{[^ ]+}}, i32 0, i32 22, i32 8, i32 8, i32 2, i1 true, i32 0, i1 false) ; MatVecMul(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,isOutputUnsigned) + +// HLOP-3: call void @"dx.hl.op..void (i32, <8 x i32>*, i1, <2 x i32>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32)"(i32 390, <8 x i32>* %output_vector, i1 false, <2 x i32> %{{[^ ]+}}, i1 true, i32 17, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 3, i1 true, i32 0) + +// DXIL-3: call <8 x i32> @dx.op.matVecMul.v8i32.v2i32(i32 305, <2 x i32> {{[^ ]+}}, i1 true, i32 17, %dx.types.Handle {{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 3, i1 true, i32 0, i1 false) ; MatVecMul(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,isOutputUnsigned) + +// HLOP-4: call void @"dx.hl.op..void (i32, <8 x i32>*, i1, <8 x float>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32)"(i32 390, <8 x i32>* %output_vector, i1 false, <8 x float> %{{[^ ]+}}, i1 false, i32 20, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 0, i1 false, i32 64) + +// DXIL-4: call <8 x i32> @dx.op.matVecMul.v8i32.v8f32(i32 305, <8 x float> {{[^ ]+}}, i1 false, i32 20, %dx.types.Handle {{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 0, i1 false, i32 64, i1 false) ; MatVecMul(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,isOutputUnsigned) // Test unsigned variations -// HLOP-5: call void @"dx.hl.op..void (i32, <4 x i32>*, i1, <8 x float>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32)"(i32 390, <4 x i32>* %output_vector, i1 true, <8 x float> %{{[^ ]+}}, i1 false, i32 20, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 8, i32 8, i32 8, i32 0, i1 false, i32 64) -// DXIL-5: call <4 x i32> @dx.op.matVecMul.v4i32.v8f32(i32 305, <8 x float> {{[^ ]+}}, i1 false, i32 20, %dx.types.Handle {{[^ ]+}}, i32 0, i32 8, i32 8, i32 8, i32 0, i1 false, i32 64, i1 true) ; MatVecMul(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,isOutputUnsigned) -// HLOP-6: call void @"dx.hl.op..void (i32, <4 x i32>*, i1, <8 x i32>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32)"(i32 390, <4 x i32>* %output_vector, i1 false, <8 x i32> %{{[^ ]+}}, i1 true, i32 19, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 1, i1 false, i32 64) -// DXIL-6: call <4 x i32> @dx.op.matVecMul.v4i32.v8i32(i32 305, <8 x i32> {{[^ ]+}}, i1 true, i32 19, %dx.types.Handle {{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 1, i1 false, i32 64, i1 false) ; MatVecMul(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,isOutputUnsigned) -// HLOP-7: call void @"dx.hl.op..void (i32, <4 x i32>*, i1, <8 x i32>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32)"(i32 390, <4 x i32>* %output_vector, i1 false, <8 x i32> %{{[^ ]+}}, i1 false, i32 19, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 19, i32 8, i32 8, i32 2, i1 true, i32 64) -// DXIL-7: call <4 x i32> @dx.op.matVecMul.v4i32.v8i32(i32 305, <8 x i32> {{[^ ]+}}, i1 false, i32 19, %dx.types.Handle {{[^ ]+}}, i32 0, i32 19, i32 8, i32 8, i32 2, i1 true, i32 64, i1 false) ; MatVecMul(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,isOutputUnsigned) +// HLOP-5: call void @"dx.hl.op..void (i32, <8 x i32>*, i1, <8 x float>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32)"(i32 390, <8 x i32>* %output_vector, i1 true, <8 x float> %{{[^ ]+}}, i1 false, i32 20, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 8, i32 8, i32 8, i32 0, i1 false, i32 64) + +// DXIL-5: call <8 x i32> @dx.op.matVecMul.v8i32.v8f32(i32 305, <8 x float> {{[^ ]+}}, i1 false, i32 20, %dx.types.Handle {{[^ ]+}}, i32 0, i32 8, i32 8, i32 8, i32 0, i1 false, i32 64, i1 true) ; MatVecMul(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,isOutputUnsigned) + +// HLOP-6: call void @"dx.hl.op..void (i32, <8 x i32>*, i1, <8 x i32>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32)"(i32 390, <8 x i32>* %output_vector, i1 false, <8 x i32> %{{[^ ]+}}, i1 true, i32 19, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 1, i1 false, i32 64) + +// DXIL-6: call <8 x i32> @dx.op.matVecMul.v8i32.v8i32(i32 305, <8 x i32> {{[^ ]+}}, i1 true, i32 19, %dx.types.Handle {{[^ ]+}}, i32 0, i32 20, i32 8, i32 8, i32 1, i1 false, i32 64, i1 false) ; MatVecMul(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,isOutputUnsigned) + +// HLOP-7: call void @"dx.hl.op..void (i32, <8 x i32>*, i1, <8 x i32>, i1, i32, %dx.types.Handle, i32, i32, i32, i32, i32, i1, i32)"(i32 390, <8 x i32>* %output_vector, i1 false, <8 x i32> %{{[^ ]+}}, i1 false, i32 19, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 19, i32 8, i32 8, i32 2, i1 true, i32 0) + +// DXIL-7: call <8 x i32> @dx.op.matVecMul.v8i32.v8i32(i32 305, <8 x i32> {{[^ ]+}}, i1 false, i32 19, %dx.types.Handle {{[^ ]+}}, i32 0, i32 19, i32 8, i32 8, i32 2, i1 true, i32 0, i1 false) ; MatVecMul(inputVector,isInputUnsigned,inputInterpretation,matrixBuffer,matrixOffset,matrixIntepretation,matrixM,matrixK,matrixLayout,matrixTranspose,matrixStride,isOutputUnsigned) ByteAddressBuffer input_vector_buffer; @@ -83,10 +97,10 @@ enum MatLayout { [NumThreads(1,1,1)] void main() { - vector output_vector; + vector output_vector; static const uint is_output_unsigned = OU; - vector input_vector = input_vector_buffer.Load >(0); + vector input_vector = input_vector_buffer.Load >(0); const uint is_input_unsigned = IU; const uint input_interpretation = II; @@ -96,7 +110,7 @@ void main() const uint matrix_dimK = 8; const uint matrix_layout = ML; const bool matrix_is_transposed = (bool) MT; - const uint matrix_stride = 64; + const uint matrix_stride = MST; __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, is_input_unsigned, input_interpretation, matrix_buffer, matrix_offset, matrix_interpretation, matrix_dimM, matrix_dimK, matrix_layout, matrix_is_transposed, matrix_stride); diff --git a/tools/clang/test/CodeGenDXIL/hlsl/intrinsics/linalg_builtins/outer-product-accumulate-multioverload.hlsl b/tools/clang/test/CodeGenDXIL/hlsl/intrinsics/linalg_builtins/outer-product-accumulate-multioverload.hlsl index c40365078f..c53b7d8f21 100644 --- a/tools/clang/test/CodeGenDXIL/hlsl/intrinsics/linalg_builtins/outer-product-accumulate-multioverload.hlsl +++ b/tools/clang/test/CodeGenDXIL/hlsl/intrinsics/linalg_builtins/outer-product-accumulate-multioverload.hlsl @@ -1,7 +1,6 @@ // RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DITY=float16_t -DMI=F16 -DML=OuterProductOptimal | FileCheck %s --check-prefixes COMMON,DXIL-0 // RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DITY=float16_t -DMI=F8_E4M3 -DML=OuterProductOptimal | FileCheck %s --check-prefixes COMMON,DXIL-1 // RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DITY=uint -DMI=U8 -DML=OuterProductOptimal | FileCheck %s --check-prefixes COMMON,DXIL-2 - // RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DITY=float16_t -DMI=F16 -DML=OuterProductOptimal -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-0 // RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DITY=float16_t -DMI=F8_E4M3 -DML=OuterProductOptimal -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-1 // RUN: %dxc -T cs_6_9 %s -enable-16bit-types -DITY=uint -DMI=U8 -DML=OuterProductOptimal -fcgl | FileCheck %s --check-prefixes COMMON,HLOP-2 @@ -11,11 +10,17 @@ ByteAddressBuffer input_vector_buffer2; RWByteAddressBuffer matrix_buffer; // COMMON: define void @main() + // DXIL-0: call void @dx.op.outerProductAccumulate.v8f16.v8f16(i32 307, <8 x half> %{{[^ ]+}}, <8 x half> %{{[^ ]+}}, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 8, i32 3, i32 0) ; OuterProductAccumulate(inputVector1,inputVector2,matrixBuffer,matrixOffset,matrixIntepretation,matrixLayout,matrixStride) + // HLOP-0: call void @"dx.hl.op..void (i32, <8 x half>, <8 x half>, %dx.types.Handle, i32, i32, i32, i32)"(i32 392, <8 x half> %{{[^ ]+}}, <8 x half> %{{[^ ]+}}, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 8, i32 3, i32 0) + // DXIL-1: call void @dx.op.outerProductAccumulate.v8f16.v8f16(i32 307, <8 x half> %{{[^ ]+}}, <8 x half> %{{[^ ]+}}, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 21, i32 3, i32 0) ; OuterProductAccumulate(inputVector1,inputVector2,matrixBuffer,matrixOffset,matrixIntepretation,matrixLayout,matrixStride) + // HLOP-1: call void @"dx.hl.op..void (i32, <8 x half>, <8 x half>, %dx.types.Handle, i32, i32, i32, i32)"(i32 392, <8 x half> %{{[^ ]+}}, <8 x half> %{{[^ ]+}}, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 21, i32 3, i32 0) + // DXIL-2: call void @dx.op.outerProductAccumulate.v8i32.v8i32(i32 307, <8 x i32> %{{[^ ]+}}, <8 x i32> %{{[^ ]+}}, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 19, i32 3, i32 0) ; OuterProductAccumulate(inputVector1,inputVector2,matrixBuffer,matrixOffset,matrixIntepretation,matrixLayout,matrixStride) + // HLOP-2: call void @"dx.hl.op..void (i32, <8 x i32>, <8 x i32>, %dx.types.Handle, i32, i32, i32, i32)"(i32 392, <8 x i32> %{{[^ ]+}}, <8 x i32> %{{[^ ]+}}, %dx.types.Handle %{{[^ ]+}}, i32 0, i32 19, i32 3, i32 0) enum CompType { diff --git a/tools/clang/test/CodeGenDXIL/hlsl/linalg/mat-vec-mul.hlsl b/tools/clang/test/CodeGenDXIL/hlsl/linalg/mat-vec-mul.hlsl index 141801c71c..26bcc75da2 100644 --- a/tools/clang/test/CodeGenDXIL/hlsl/linalg/mat-vec-mul.hlsl +++ b/tools/clang/test/CodeGenDXIL/hlsl/linalg/mat-vec-mul.hlsl @@ -15,26 +15,78 @@ export float4 Test1(vector Input) { Matrix, MakeInterpretedVector(Input)); } -export vector Test2(vector Input) { +export vector Test2(vector Input) { using namespace dx::linalg; MatrixRef Matrix = { Buf, 0, 0}; // note the stride argument is dropped. - // CHECK: %{{.+}} = call <8 x float> @dx.op.matVecMul.v8f32.v6f32(i32 305, <6 x float> %{{.+}}, i1 false, i32 18, %dx.types.Handle %{{.+}}, i32 0, i32 19, i32 8, i32 24, i32 2, i1 false, i32 0, i1 false) + // CHECK: %{{.+}} = call <8 x float> @dx.op.matVecMul.v8f32.v6i32(i32 305, <6 x i32> %{{.+}}, i1 true, i32 18, %dx.types.Handle %{{.+}}, i32 0, i32 19, i32 8, i32 24, i32 2, i1 false, i32 0, i1 false) return Mul(Matrix, MakeInterpretedVector(Input)); } // test that "stride" isn't ignored in non-optimal layouts -export vector Test3(vector Input) { +export vector Test3(vector Input) { using namespace dx::linalg; MatrixRef Matrix = { Buf, 0, 6 * 4 * 8}; - // CHECK: %{{.+}} = call <8 x float> @dx.op.matVecMul.v8f32.v6f32(i32 305, <6 x float> %{{.+}}, i1 false, i32 18, %dx.types.Handle %{{.+}}, i32 0, i32 19, i32 8, i32 24, i32 0, i1 false, i32 192, i1 false) + // CHECK: %{{.+}} = call <8 x float> @dx.op.matVecMul.v8f32.v6i32(i32 305, <6 x i32> %{{.+}}, i1 true, i32 18, %dx.types.Handle %{{.+}}, i32 0, i32 19, i32 8, i32 24, i32 0, i1 false, i32 192, i1 false) return Mul(Matrix, MakeInterpretedVector(Input)); } + +// test that isUnsigned is set correctly for uint16_t +export vector Test4(vector Input) { + using namespace dx::linalg; + + MatrixRef Matrix = { + Buf, 0, 6 * 4 * 8}; + + // CHECK: %{{.+}} = call <8 x i16> @dx.op.matVecMul.v8i16.v6i32(i32 305, <6 x i32> %{{.+}}, i1 true, i32 18, %dx.types.Handle %{{.+}}, i32 0, i32 19, i32 8, i32 24, i32 0, i1 false, i32 192, i1 true) + return Mul(Matrix, + MakeInterpretedVector(Input)); + +} + +// test that isUnsigned is set correctly for uint32_t +export vector Test5(vector Input) { + using namespace dx::linalg; + + MatrixRef Matrix = { + Buf, 0, 6 * 4 * 8}; + + // CHECK: %{{.+}} = call <8 x i32> @dx.op.matVecMul.v8i32.v6i32(i32 305, <6 x i32> %{{.+}}, i1 true, i32 18, %dx.types.Handle %{{.+}}, i32 0, i32 19, i32 8, i32 24, i32 0, i1 false, i32 192, i1 true) + return Mul(Matrix, + MakeInterpretedVector(Input)); + +} + +// test that isUnsigned is set correctly for uint8_t4_packed +export vector Test5(vector Input) { + using namespace dx::linalg; + + MatrixRef Matrix = { + Buf, 0, 6 * 4 * 8}; + + // CHECK: %{{.+}} = call <8 x i32> @dx.op.matVecMul.v8i32.v6i32(i32 305, <6 x i32> %{{.+}}, i1 true, i32 18, %dx.types.Handle %{{.+}}, i32 0, i32 19, i32 8, i32 24, i32 0, i1 false, i32 192, i1 true) + return Mul(Matrix, + MakeInterpretedVector(Input)); + +} + +// test that isUnsigned is set correctly for int8_t4_packed +export vector Test5(vector Input) { + using namespace dx::linalg; + + MatrixRef Matrix = { + Buf, 0, 6 * 4 * 8}; + + // CHECK: %{{.+}} = call <8 x i32> @dx.op.matVecMul.v8i32.v6i32(i32 305, <6 x i32> %{{.+}}, i1 true, i32 17, %dx.types.Handle %{{.+}}, i32 0, i32 19, i32 8, i32 24, i32 0, i1 false, i32 192, i1 true) + return Mul(Matrix, + MakeInterpretedVector(Input)); + +} \ No newline at end of file diff --git a/tools/clang/test/SemaHLSL/hlsl/linalg/builtins/mul_add_invalid.hlsl b/tools/clang/test/SemaHLSL/hlsl/linalg/builtins/mul_add_invalid.hlsl new file mode 100644 index 0000000000..866fad8225 --- /dev/null +++ b/tools/clang/test/SemaHLSL/hlsl/linalg/builtins/mul_add_invalid.hlsl @@ -0,0 +1,1398 @@ +// RUN: %dxc -I %hlsl_headers -T lib_6_9 -enable-16bit-types %s -verify + +#include + +using namespace dx::linalg; + +ByteAddressBuffer input_vector_buffer; +ByteAddressBuffer matrix_buffer; +ByteAddressBuffer bias_buffer; +RWByteAddressBuffer output_vector_buffer; +ByteAddressBuffer constants_buffer; + +// Output vector, isUnsigned mismatch +void test_invalid_output_vector_type() { + + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + vector output_vector_0; + const uint is_output_unsigned_0 = 0; + + // expected-error@+1 {{IsOuputUnsigned must be true for vector of unsigned integer type}} + __builtin_MatVecMulAdd(output_vector_0, is_output_unsigned_0, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + vector output_vector_1; + const uint is_output_unsigned_1 = 1; + + // expected-error@+1 {{IsOuputUnsigned must be false for vector of signed integer type}} + __builtin_MatVecMulAdd(output_vector_1, is_output_unsigned_1, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + vector output_vector_2; + const uint is_output_unsigned_2 = 1; + + // expected-error@+1 {{IsOuputUnsigned must be false for vector of floating point type}} + __builtin_MatVecMulAdd(output_vector_2, is_output_unsigned_2, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// IsOutputUnsigned is not a constant parameter +void test_invalid_is_output_unsigned_non_const() { + + vector output_vector_0; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + const uint is_output_unsigned_0 = constants_buffer.Load(0); + + // expected-error@+1 {{expression is not an integer constant expression}} + __builtin_MatVecMulAdd(output_vector_0, is_output_unsigned_0, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Input vector is incorrect type - 64 bit types +void test_invalid_input_vector_type() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_0 = 0; + +// expected-error@+2 {{no matching function for call to '__builtin_MatVecMulAdd'}} +// expected-note@+1 {{candidate function not viable: no known conversion from 'vector' to 'vector' for 3rd argument}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned_0, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_1 = 1; + +// expected-error@+2 {{no matching function for call to '__builtin_MatVecMulAdd'}} +// expected-note@+1 {{candidate function not viable: no known conversion from 'vector' to 'vector' for 3rd argument}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned_1, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + vector input_vector_2 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_2 = 0; + +// expected-error@+2 {{no matching function for call to '__builtin_MatVecMulAdd'}} +// expected-note@+1 {{candidate function not viable: no known conversion from 'vector' to 'vector' for 3rd argument}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_2, + is_input_unsigned_2, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Input vector is incorrect type for packed InputInterpretation +void test_invalid_input_vector_type_packed_input_interpretation() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + const uint input_interpretation_0 = DataType::DATA_TYPE_SINT8_T4_PACKED; + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_0 = 1; + + // expected-error@+1 {{packed input vector type must be a 32-bit unsigned int type in linalg mul/muladd operations}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned_0, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_1 = DataType::DATA_TYPE_UINT8_T4_PACKED; + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_1 = 0; + + // expected-error@+1 {{packed input vector type must be a 32-bit unsigned int type in linalg mul/muladd operations}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned_1, input_interpretation_1, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_2 = DataType::DATA_TYPE_UINT8_T4_PACKED; + vector input_vector_2 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_2 = 1; + + // expected-error@+1 {{packed input vector type must be a 32-bit unsigned int type in linalg mul/muladd operations}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_2, + is_input_unsigned_2, input_interpretation_2, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_3 = DataType::DATA_TYPE_SINT8_T4_PACKED; + vector input_vector_3 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_3 = 0; + + // expected-error@+1 {{packed input vector type must be a 32-bit unsigned int type in linalg mul/muladd operations}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_3, + is_input_unsigned_3, input_interpretation_3, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_4 = DataType::DATA_TYPE_SINT8_T4_PACKED; + vector input_vector_4 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_4 = 0; + + // expected-error@+1 {{packed input vector type must be a 32-bit unsigned int type in linalg mul/muladd operations}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_4, + is_input_unsigned_4, input_interpretation_4, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// IsInputUnsigned must be true for packed input vector type +void test_invalid_is_input_unsigned_packed_input_vector_type() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + const uint input_interpretation_0 = DataType::DATA_TYPE_UINT8_T4_PACKED; + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_0 = 0; + + // expected-error@+2 {{IsInputUnsigned must be true for packed input interpretations in linalg mul/muladd operations}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned_0, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_1 = DataType::DATA_TYPE_SINT8_T4_PACKED; + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_1 = 0; + + // expected-error@+2 {{IsInputUnsigned must be true for packed input interpretations in linalg mul/muladd operations}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned_1, input_interpretation_1, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Check packed input vector dimension +void test_invalid_packed_input_vector_dimension() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_UINT8_T4_PACKED; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_UINT8; + const uint matrix_dimM = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_MUL_OPTIMAL; + const bool matrix_is_transposed = false; + const uint matrix_stride = 0; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_UINT32; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint matrix_dimK_0 = 4; + + // expected-error@+1 {{packed input vector length must be the smallest number that can hold matrix dim K values of the packed(smaller) type in linalg mul/muladd operations}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_0, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint matrix_dimK_1 = 7; + + // expected-error@+1 {{packed input vector length must be the smallest number that can hold matrix dim K values of the packed(smaller) type in linalg mul/muladd operations}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_1, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + vector input_vector_2 = + input_vector_buffer.Load >(0); + const uint matrix_dimK_2 = 7; + + // expected-error@+1 {{packed input vector length must be the smallest number that can hold matrix dim K values of the packed(smaller) type in linalg mul/muladd operations}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_2, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_2, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + +} + +// Check is Input vector type/isInputUnsigned matched +void test_invalid_input_vector_type_mismatch() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_0 = 0; + + // expected-error@+2 {{IsInputUnsigned must be true for vector of unsigned integer type}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned_0, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_1 = 1; + + // expected-error@+2 {{IsInputUnsigned must be false for vector of signed integer type}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned_1, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + vector input_vector_2 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_2 = 1; + + // expected-error@+2 {{IsInputUnsigned must be false for vector of floating point type}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_2, + is_input_unsigned_2, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Check is Matrix M dimension is a constant parameter +void test_invalid_matrix_M_dimension() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + const uint matrix_dimM = constants_buffer.Load(0); + + // expected-error@+3 {{expression is not an integer constant expression}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Check is Matrix K dimension is a constant parameter +void test_invalid_matrix_K_dimension() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + const uint matrix_dimK = constants_buffer.Load(0); + + // expected-error@+4 {{expression is not an integer constant expression}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Check is Matrix M dimension is non-zero +void test_invalid_matrix_M_dimension_non_zero() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + const uint matrix_dimM = 0; + // expected-error@+3 {{matrix dimension must be greater than 0}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Check is Matrix K dimension is non-zero +void test_invalid_matrix_K_dimension_non_zero() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + const uint matrix_dimK = 0; + // expected-error@+4 {{matrix dimension must be greater than 0}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Check if Matrix M dimension is less than Max +void test_invalid_matrix_M_dimension_less_than_Max() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 1; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = matrix_dimK * 4; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint input_interpretation_0 = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM_0 = 1025; + + // expected-error@+3 {{matrix dimension M must be less than 1024, in a linalg Mul/MulAdd operation}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM_0, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint input_interpretation_1 = DataType::DATA_TYPE_UINT8_T4_PACKED; + const uint matrix_dimM_1 = 4097; + + // expected-error@+3 {{matrix dimension M must be less than 1024, in a linalg Mul/MulAdd operation}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned, input_interpretation_1, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM_1, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Check if Matrix K dimension is less than Max in unpacked input vector case +void test_invalid_matrix_K_dimension_less_than_Max_unpacked_input_vector() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 1; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint input_interpretation_0 = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimK_0 = 1025; + + // expected-error@+4 {{matrix dimension K when using unpacked input vectors must be less than 1024, in a linalg Mul/MulAdd operation}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_0, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint input_interpretation_1 = DataType::DATA_TYPE_UINT8; + const uint matrix_dimK_1 = 4096; + // expected-error@+4 {{matrix dimension K when using unpacked input vectors must be less than 1024, in a linalg Mul/MulAdd operation}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned, input_interpretation_1, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_1, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + +} + +// Check if Matrix M dimension is less than Max in packed input vector case +void test_invalid_matrix_M_dimension_less_than_Max_packed_input_vector() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 1; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 1024; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 4096; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint input_interpretation_0 = DataType::DATA_TYPE_UINT8_T4_PACKED; + const uint matrix_dimK_0 = 4097; + + // expected-error@+4 {{matrix dimension K when using packed input vectors must be less than 4096, in a linalg Mul/MulAdd operation}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_0, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +void test_invalid_input_interpretation_non_const() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + const uint input_interpretation = constants_buffer.Load(0); + + // expected-error@+2 {{expression is not an integer constant expression}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Check if InputInterpretation is a valid value +void test_invalid_input_interpretation_value() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + const uint input_interpretation_0 = 0; + + // expected-error@+2 {{0 is an invalid register interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_1 = 1; + + // expected-error@+2 {{1 is an invalid register interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_1, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_2 = 6; + + // expected-error@+2 {{6 is an invalid register interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_2, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_3 = 7; + + // expected-error@+2 {{7 is an invalid register interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_3, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_4 = 10; + + // expected-error@+2 {{10 is an invalid register interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_4, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_5 = 11; + + // expected-error@+2 {{11 is an invalid register interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_5, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_6 = 12; + + // expected-error@+2 {{12 is an invalid register interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_6, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_7 = 13; + + // expected-error@+2 {{13 is an invalid register interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_7, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_8 = 14; + + // expected-error@+2 {{14 is an invalid register interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_8, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_9 = 15; + + // expected-error@+2 {{15 is an invalid register interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_9, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_10 = 16; + + // expected-error@+2 {{16 is an invalid register interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_10, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_11 = 23; + + // expected-error@+2 {{23 is an invalid register interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_11, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_12 = 100; + + // expected-error@+2 {{100 is an invalid register interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_12, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} +// Check if Input and Output vector dimensions are valid -non packed +void test_invalid_input_output_vector_dimensions_non_packed_square_matrix() { + + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 32; + const uint matrix_dimK = 32; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + vector output_vector_0; + vector input_vector_0 = + input_vector_buffer.Load >(0); + + // expected-error@+1 {{unpacked input vector length must be equal to Matrix K dimension in a linalg Mul/MulAdd operation}} + __builtin_MatVecMulAdd(output_vector_0, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + vector output_vector_1; + vector input_vector_1 = + input_vector_buffer.Load >(0); + + // expected-error@+1 {{output vector length must be equal to Matrix M dimension in a linalg Mul/MulAdd operation}} + __builtin_MatVecMulAdd(output_vector_1, is_output_unsigned, input_vector_1, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Check if Input and Output vector dimensions are valid -non packed +void test_invalid_input_output_vector_dimensions_non_packed_rectangle_matrix() { + + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 16; + const uint matrix_dimK = 32; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + // Use dimension of Matrix K to trigger error + vector output_vector_0; + vector input_vector_0 = + input_vector_buffer.Load >(0); + + // expected-error@+1 {{output vector length must be equal to Matrix M dimension in a linalg Mul/MulAdd operation}} + __builtin_MatVecMulAdd(output_vector_0, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + // Check off by 1 errors + vector output_vector_1; + vector input_vector_1 = + input_vector_buffer.Load >(0); + + // expected-error@+1 {{output vector length must be equal to Matrix M dimension in a linalg Mul/MulAdd operation}} + __builtin_MatVecMulAdd(output_vector_1, is_output_unsigned, input_vector_1, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + // Check off by 1 errors + vector output_vector_2; + vector input_vector_2 = + input_vector_buffer.Load >(0); + + // expected-error@+1 {{output vector length must be equal to Matrix M dimension in a linalg Mul/MulAdd operation}} + __builtin_MatVecMulAdd(output_vector_2, is_output_unsigned, input_vector_2, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + // Use dimension of Matrix M to trigger error + vector output_vector_3; + vector input_vector_3 = + input_vector_buffer.Load >(0); + + // expected-error@+1 {{unpacked input vector length must be equal to Matrix K dimension in a linalg Mul/MulAdd operation}} + __builtin_MatVecMulAdd(output_vector_3, is_output_unsigned, input_vector_3, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + // Check off by 1 errors + vector output_vector_4; + vector input_vector_4 = + input_vector_buffer.Load >(0); + + // expected-error@+1 {{unpacked input vector length must be equal to Matrix K dimension in a linalg Mul/MulAdd operation}} + __builtin_MatVecMulAdd(output_vector_4, is_output_unsigned, input_vector_4, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + // Check off by 1 errors + vector output_vector_5; + vector input_vector_5 = + input_vector_buffer.Load >(0); + + // expected-error@+1 {{unpacked input vector length must be equal to Matrix K dimension in a linalg Mul/MulAdd operation}} + __builtin_MatVecMulAdd(output_vector_5, is_output_unsigned, input_vector_5, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + // Swap dimensions to trigger error + vector output_vector_6; + vector input_vector_6 = + input_vector_buffer.Load >(0); + + // expected-error@+1 {{output vector length must be equal to Matrix M dimension in a linalg Mul/MulAdd operation}} + __builtin_MatVecMulAdd(output_vector_6, is_output_unsigned, input_vector_6, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Check if matrtrix interpretation is a constant value +void test_invalid_matrix_interpretation_constant_value() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + const uint matrix_interpretation_0 = constants_buffer.Load(0); + + // expected-error@+3 {{expression is not an integer constant expression}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_0, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Check for invalid matrix interpretation value +void test_invalid_matrix_interpretation_value() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + const uint matrix_interpretation_0 = 0; + + // expected-error@+3 {{0 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_0, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint matrix_interpretation_1 = 1; + + // expected-error@+3 {{1 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_1, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint matrix_interpretation_2 = 6; + + // expected-error@+3 {{6 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_2, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint matrix_interpretation_3 = 7; + + // expected-error@+3 {{7 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_3, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint matrix_interpretation_4 = 10; + + // expected-error@+3 {{10 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_4, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint matrix_interpretation_5 = 11; + + // expected-error@+3 {{11 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_5, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint matrix_interpretation_6 = 12; + + // expected-error@+3 {{12 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_6, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint matrix_interpretation_7 = 13; + + // expected-error@+3 {{13 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_7, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint matrix_interpretation_8 = 14; + + // expected-error@+3 {{14 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_8, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint matrix_interpretation_9 = 15; + + // expected-error@+3 {{15 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_9, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint matrix_interpretation_10 = 16; + + // expected-error@+3 {{16 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_10, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint matrix_interpretation_11 = 23; + // expected-error@+3 {{23 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_11, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint matrix_interpretation_12 = 100; + + // expected-error@+3 {{100 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_12, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Check if matrix Layout is a constant value +void test_invalid_matrix_layout_constant_value() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + const uint matrix_layout = constants_buffer.Load(0); + + // expected-error@+4 {{expression is not an integer constant expression}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Check invalid matrix layout value +void test_invalid_matrix_layout_value() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + const uint matrix_layout_0 = 4; + + // expected-error@+4 {{matrix layout 4 is not valid, must be in the range [0, 3]}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout_0, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Check if matrix is transposed is a constant value +void test_invalid_matrix_transposed_constant_value() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = constants_buffer.Load(0); + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + // expected-error@+4 {{expression is not an integer constant expression}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Check if invalid matrix transpose value is used +void test_invalid_matrix_transpose_value() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + const uint matrix_layout_0 = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed_0 = true; + + // expected-error@+4 {{RowMajor and ColumnMajor matrices are not transposable}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout_0, matrix_is_transposed_0, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint matrix_layout_1 = MatrixLayout::MATRIX_LAYOUT_COLUMN_MAJOR; + const bool matrix_is_transposed_1 = true; + + // expected-error@+4 {{RowMajor and ColumnMajor matrices are not transposable}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout_1, matrix_is_transposed_1, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + + +// Check invalid matrix stride value for optimal matrix layout +void test_invalid_matrix_stride_constant_value() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const bool matrix_is_transposed = false; + + const uint matrix_layout_0 = MatrixLayout::MATRIX_LAYOUT_MUL_OPTIMAL; + const uint matrix_stride_0 = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + // expected-error@+5 {{for optimal matrix layout, matrix stride must be 0}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout_0, matrix_is_transposed, + matrix_stride_0, bias_buffer, bias_offset, bias_interpretation); + + const uint matrix_layout_1 = MatrixLayout::MATRIX_LAYOUT_OUTER_PRODUCT_OPTIMAL; + const uint matrix_stride_1 = 64; + + // expected-error@+5 {{for optimal matrix layout, matrix stride must be 0}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout_1, matrix_is_transposed, + matrix_stride_1, bias_buffer, bias_offset, bias_interpretation); +} + +// Check bias interpretation is not a constant value +void test_invalid_bias_interpretation() { + vector output_vector; + const uint is_output_unsigned = 0; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const uint matrix_is_transposed = 0; + const uint matrix_stride = 0; + const uint bias_offset = 0; + + const uint bias_interpretation_0 = constants_buffer.Load(0); + + // expected-error@+6 {{expression is not an integer constant expression}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, + bias_interpretation_0); +} + +// Check bias interpretation is not a valid value +void test_invalid_bias_interpretation_value() { + vector output_vector; + const uint is_output_unsigned = 0; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const uint matrix_is_transposed = 0; + const uint matrix_stride = 0; + const uint bias_offset = 0; + + const uint bias_interpretation_0 = 0; + + // expected-error@+6 {{0 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, + bias_interpretation_0); + + const uint bias_interpretation_1 = 1; + + // expected-error@+6 {{1 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, + bias_interpretation_1); + + const uint bias_interpretation_2 = 6; + + // expected-error@+6 {{6 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, + bias_interpretation_2); + + const uint bias_interpretation_3 = 7; + + // expected-error@+6 {{7 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, + bias_interpretation_3); + + const uint bias_interpretation_4 = 10; + + // expected-error@+6 {{10 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, + bias_interpretation_4); + + const uint bias_interpretation_5 = 11; + + // expected-error@+6 {{11 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, + bias_interpretation_5); + + const uint bias_interpretation_6 = 12; + + // expected-error@+6 {{12 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, + bias_interpretation_6); + + const uint bias_interpretation_7 = 13; + + // expected-error@+6 {{13 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, + bias_interpretation_7); + + const uint bias_interpretation_8 = 14; + + // expected-error@+6 {{14 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, + bias_interpretation_8); + + const uint bias_interpretation_9 = 15; + + // expected-error@+6 {{15 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, + bias_interpretation_9); + + const uint bias_interpretation_10 = 16; + + // expected-error@+6 {{16 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, + bias_interpretation_10); + + const uint bias_interpretation_11 = DataType::DATA_TYPE_SINT8_T4_PACKED; + + // expected-error@+6 {{17 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, + bias_interpretation_11); + + const uint bias_interpretation_12 = DataType::DATA_TYPE_UINT8_T4_PACKED; + + // expected-error@+6 {{18 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, + bias_interpretation_12); + + const uint bias_interpretation_13 = 23; + + // expected-error@+6 {{23 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, + bias_interpretation_13); + + const uint bias_interpretation_14 = 100; + + // expected-error@+6 {{100 is an invalid memory interpretation value}} + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, + bias_interpretation_14); + } diff --git a/tools/clang/test/SemaHLSL/hlsl/linalg/builtins/mul_add_valid.hlsl b/tools/clang/test/SemaHLSL/hlsl/linalg/builtins/mul_add_valid.hlsl new file mode 100644 index 0000000000..4b0bd6dd87 --- /dev/null +++ b/tools/clang/test/SemaHLSL/hlsl/linalg/builtins/mul_add_valid.hlsl @@ -0,0 +1,244 @@ +// RUN: %dxc -I %hlsl_headers -T lib_6_9 %s + +#include + +using namespace dx::linalg; + +ByteAddressBuffer input_vector_buffer; +ByteAddressBuffer matrix_buffer; +ByteAddressBuffer bias_buffer; +RWByteAddressBuffer output_vector_buffer; +ByteAddressBuffer constants_buffer; + +// Check valid input vector packed types +void test_valid_input_vector_packed_types() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + const uint input_interpretation_0 = DataType::DATA_TYPE_UINT8_T4_PACKED; + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_0 = 1; + + // expected-no-diagnostics@+1 + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned_0, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_1 = DataType::DATA_TYPE_SINT8_T4_PACKED; + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_1 = 1; + + // expected-no-diagnostics@+1 + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned_1, input_interpretation_1, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + +} + +// IsInputUnsigned must be true for packed input vector type +void test_valid_is_input_unsigned_packed_input_vector_type() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + const uint input_interpretation_0 = DataType::DATA_TYPE_UINT8_T4_PACKED; + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_0 = 1; + + // expected-no-diagnostics@+2 + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned_0, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + const uint input_interpretation_1 = DataType::DATA_TYPE_SINT8_T4_PACKED; + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_1 = 1; + + // expected-no-diagnostics@+2 + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned_1, input_interpretation_1, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Check packed input vector dimension +void test_valid_packed_input_vector_dimension() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_UINT8_T4_PACKED; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_UINT8; + const uint matrix_dimM = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_MUL_OPTIMAL; + const bool matrix_is_transposed = false; + const uint matrix_stride = 0; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_UINT32; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint matrix_dimK_0 = 4; + + // expected-no-diagnostics@+1 + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_0, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint matrix_dimK_1 = 7; + + // expected-no-diagnostics@+1 + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_1, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Check if Matrix M dimension is less than Max +void test_valid_matrix_M_dimension_less_than_Max() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 1; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = matrix_dimK * 4; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint input_interpretation_0 = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM_0 = 4; + + // expected-no-diagnostics@+1 + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM_0, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint input_interpretation_1 = DataType::DATA_TYPE_UINT8_T4_PACKED; + const uint matrix_dimM_1 = 4; + + // expected-no-diagnostics@+1 + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned, input_interpretation_1, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM_1, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + +// Check if Matrix K dimension is less than Max in unpacked input vector case +void test_valid_matrix_K_dimension_less_than_Max_unpacked_input_vector() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 1; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint input_interpretation_0 = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimK_0 = 4; + + // expected-no-diagnostics@+1 + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_0, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint input_interpretation_1 = DataType::DATA_TYPE_UINT8; + const uint matrix_dimK_1 = 4; + // expected-no-diagnostics@+1 + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned, input_interpretation_1, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_1, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); + +} + +// Check if Matrix M dimension is less than Max in packed input vector case +void test_valid_matrix_M_dimension_less_than_Max_packed_input_vector() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 1; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint input_interpretation_0 = DataType::DATA_TYPE_UINT8_T4_PACKED; + const uint matrix_dimK_0 = 4096; + + // expected-no-diagnostics@+1 + __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_0, matrix_layout, matrix_is_transposed, + matrix_stride, bias_buffer, bias_offset, bias_interpretation); +} + + + diff --git a/tools/clang/test/SemaHLSL/hlsl/linalg/builtins/mul_invalid.hlsl b/tools/clang/test/SemaHLSL/hlsl/linalg/builtins/mul_invalid.hlsl new file mode 100644 index 0000000000..14f34d62c4 --- /dev/null +++ b/tools/clang/test/SemaHLSL/hlsl/linalg/builtins/mul_invalid.hlsl @@ -0,0 +1,1156 @@ +// RUN: %dxc -I %hlsl_headers -T lib_6_9 -enable-16bit-types %s -verify + +#include + +using namespace dx::linalg; + +ByteAddressBuffer input_vector_buffer; +ByteAddressBuffer matrix_buffer; +RWByteAddressBuffer output_vector_buffer; +ByteAddressBuffer constants_buffer; + +// Output vector, isUnsigned mismatch +void test_invalid_output_vector_type() { + + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + vector output_vector_0; + const uint is_output_unsigned_0 = 0; + + // expected-error@+1 {{IsOuputUnsigned must be true for vector of unsigned integer type}} + __builtin_MatVecMul(output_vector_0, is_output_unsigned_0, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + vector output_vector_1; + const uint is_output_unsigned_1 = 1; + + // expected-error@+1 {{IsOuputUnsigned must be false for vector of signed integer type}} + __builtin_MatVecMul(output_vector_1, is_output_unsigned_1, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + vector output_vector_2; + const uint is_output_unsigned_2 = 1; + + // expected-error@+1 {{IsOuputUnsigned must be false for vector of floating point type}} + __builtin_MatVecMul(output_vector_2, is_output_unsigned_2, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// IsOutputUnsigned is not a constant parameter +void test_invalid_is_output_unsigned_non_const() { + + vector output_vector_0; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + const uint is_output_unsigned_0 = constants_buffer.Load(0); + + // expected-error@+1 {{expression is not an integer constant expression}} + __builtin_MatVecMul(output_vector_0, is_output_unsigned_0, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Input vector is incorrect type - 64 bit types +void test_invalid_input_vector_type() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_0 = 0; + +// expected-error@+2 {{no matching function for call to '__builtin_MatVecMul'}} +// expected-note@+1 {{candidate function not viable: no known conversion from 'vector' to 'vector' for 3rd argument}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned_0, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_1 = 1; + +// expected-error@+2 {{no matching function for call to '__builtin_MatVecMul'}} +// expected-note@+1 {{candidate function not viable: no known conversion from 'vector' to 'vector' for 3rd argument}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned_1, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + vector input_vector_2 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_2 = 0; + +// expected-error@+2 {{no matching function for call to '__builtin_MatVecMul'}} +// expected-note@+1 {{candidate function not viable: no known conversion from 'vector' to 'vector' for 3rd argument}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_2, + is_input_unsigned_2, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Input vector is incorrect type for packed InputInterpretation +void test_invalid_input_vector_type_packed_input_interpretation() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + const uint input_interpretation_0 = DataType::DATA_TYPE_SINT8_T4_PACKED; + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_0 = 1; + + // expected-error@+1 {{packed input vector type must be a 32-bit unsigned int type in linalg mul/muladd operations}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned_0, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_1 = DataType::DATA_TYPE_UINT8_T4_PACKED; + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_1 = 0; + + // expected-error@+1 {{packed input vector type must be a 32-bit unsigned int type in linalg mul/muladd operations}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned_1, input_interpretation_1, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_2 = DataType::DATA_TYPE_UINT8_T4_PACKED; + vector input_vector_2 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_2 = 1; + + // expected-error@+1 {{packed input vector type must be a 32-bit unsigned int type in linalg mul/muladd operations}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_2, + is_input_unsigned_2, input_interpretation_2, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_3 = DataType::DATA_TYPE_SINT8_T4_PACKED; + vector input_vector_3 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_3 = 0; + + // expected-error@+1 {{packed input vector type must be a 32-bit unsigned int type in linalg mul/muladd operations}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_3, + is_input_unsigned_3, input_interpretation_3, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_4 = DataType::DATA_TYPE_SINT8_T4_PACKED; + vector input_vector_4 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_4 = 0; + + // expected-error@+1 {{packed input vector type must be a 32-bit unsigned int type in linalg mul/muladd operations}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_4, + is_input_unsigned_4, input_interpretation_4, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// IsInputUnsigned must be true for packed input vector type +void test_invalid_is_input_unsigned_packed_input_vector_type() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_FLOAT32; + + const uint input_interpretation_0 = DataType::DATA_TYPE_UINT8_T4_PACKED; + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_0 = 0; + + // expected-error@+2 {{IsInputUnsigned must be true for packed input interpretations in linalg mul/muladd operations}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned_0, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_1 = DataType::DATA_TYPE_SINT8_T4_PACKED; + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_1 = 0; + + // expected-error@+2 {{IsInputUnsigned must be true for packed input interpretations in linalg mul/muladd operations}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned_1, input_interpretation_1, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Check packed input vector dimension +void test_invalid_packed_input_vector_dimension() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_UINT8_T4_PACKED; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_UINT8; + const uint matrix_dimM = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_MUL_OPTIMAL; + const bool matrix_is_transposed = false; + const uint matrix_stride = 0; + const uint bias_offset = 0; + const uint bias_interpretation = DataType::DATA_TYPE_UINT32; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint matrix_dimK_0 = 4; + + // expected-error@+1 {{packed input vector length must be the smallest number that can hold matrix dim K values of the packed(smaller) type in linalg mul/muladd operations}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_0, matrix_layout, matrix_is_transposed, + matrix_stride); + + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint matrix_dimK_1 = 7; + + // expected-error@+1 {{packed input vector length must be the smallest number that can hold matrix dim K values of the packed(smaller) type in linalg mul/muladd operations}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_1, matrix_layout, matrix_is_transposed, + matrix_stride); + + vector input_vector_2 = + input_vector_buffer.Load >(0); + const uint matrix_dimK_2 = 7; + + // expected-error@+1 {{packed input vector length must be the smallest number that can hold matrix dim K values of the packed(smaller) type in linalg mul/muladd operations}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_2, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_2, matrix_layout, matrix_is_transposed, + matrix_stride); + +} + +// Input vector type/isInputUnsigned mismatch +void test_invalid_input_vector_type_mismatch() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_0 = 0; + + // expected-error@+2 {{IsInputUnsigned must be true for vector of unsigned integer type}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned_0, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_1 = 1; + + // expected-error@+2 {{IsInputUnsigned must be false for vector of signed integer type}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned_1, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + vector input_vector_2 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_2 = 1; + + // expected-error@+2 {{IsInputUnsigned must be false for vector of floating point type}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_2, + is_input_unsigned_2, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Check is Matrix M dimension is a constant parameter +void test_invalid_matrix_M_dimension() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + const uint matrix_dimM = constants_buffer.Load(0); + + // expected-error@+3 {{expression is not an integer constant expression}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Check is Matrix K dimension is a constant parameter +void test_invalid_matrix_K_dimension() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + const uint matrix_dimK = constants_buffer.Load(0); + + // expected-error@+4 {{expression is not an integer constant expression}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Check is Matrix M dimension is non-zero +void test_invalid_matrix_M_dimension_non_zero() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + const uint matrix_dimM = 0; + // expected-error@+3 {{matrix dimension must be greater than 0}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Check is Matrix K dimension is non-zero +void test_invalid_matrix_K_dimension_non_zero() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + const uint matrix_dimK = 0; + // expected-error@+4 {{matrix dimension must be greater than 0}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Check if Matrix M dimension is less than Max +void test_invalid_matrix_M_dimension_less_than_Max() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 1; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = matrix_dimK * 4; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint input_interpretation_0 = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM_0 = 1025; + + // expected-error@+3 {{matrix dimension M must be less than 1024, in a linalg Mul/MulAdd operation}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM_0, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint input_interpretation_1 = DataType::DATA_TYPE_UINT8_T4_PACKED; + const uint matrix_dimM_1 = 4097; + + // expected-error@+3 {{matrix dimension M must be less than 1024, in a linalg Mul/MulAdd operation}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned, input_interpretation_1, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM_1, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Check if Matrix K dimension is less than Max in unpacked input vector case +void test_invalid_matrix_K_dimension_less_than_Max_unpacked_input_vector() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 1; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint input_interpretation_0 = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimK_0 = 1025; + + // expected-error@+4 {{matrix dimension K when using unpacked input vectors must be less than 1024, in a linalg Mul/MulAdd operation}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_0, matrix_layout, matrix_is_transposed, + matrix_stride); + + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint input_interpretation_1 = DataType::DATA_TYPE_UINT8; + const uint matrix_dimK_1 = 4096; + // expected-error@+4 {{matrix dimension K when using unpacked input vectors must be less than 1024, in a linalg Mul/MulAdd operation}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned, input_interpretation_1, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_1, matrix_layout, matrix_is_transposed, + matrix_stride); + +} + +// Check if Matrix M dimension is less than Max in packed input vector case +void test_invalid_matrix_M_dimension_less_than_Max_packed_input_vector() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 1; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 1024; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 4096; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint input_interpretation_0 = DataType::DATA_TYPE_UINT8_T4_PACKED; + const uint matrix_dimK_0 = 4097; + + // expected-error@+4 {{matrix dimension K when using packed input vectors must be less than 4096, in a linalg Mul/MulAdd operation}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_0, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +//Check if InputInterpretation is a constant parameter +void test_invalid_input_interpretation_non_const() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + const uint input_interpretation = constants_buffer.Load(0); + + // expected-error@+2 {{expression is not an integer constant expression}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Check if InputInterpretation is a valid value +void test_invalid_input_interpretation_value() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + const uint input_interpretation_0 = 0; + + // expected-error@+2 {{0 is an invalid register interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_1 = 1; + + // expected-error@+2 {{1 is an invalid register interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_1, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_2 = 6; + + // expected-error@+2 {{6 is an invalid register interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_2, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_3 = 7; + + // expected-error@+2 {{7 is an invalid register interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_3, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_4 = 10; + + // expected-error@+2 {{10 is an invalid register interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_4, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_5 = 11; + + // expected-error@+2 {{11 is an invalid register interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_5, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_6 = 12; + + // expected-error@+2 {{12 is an invalid register interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_6, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_7 = 13; + + // expected-error@+2 {{13 is an invalid register interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_7, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_8 = 14; + + // expected-error@+2 {{14 is an invalid register interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_8, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_9 = 15; + + // expected-error@+2 {{15 is an invalid register interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_9, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_10 = 16; + + // expected-error@+2 {{16 is an invalid register interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_10, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_11 = 23; + + // expected-error@+2 {{23 is an invalid register interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_11, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_12 = 100; + + // expected-error@+2 {{100 is an invalid register interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation_12, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} +// Check if Input and Output vector dimensions are valid -non packed +void test_invalid_input_output_vector_dimensions_non_packed_square_matrix() { + + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 32; + const uint matrix_dimK = 32; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + vector output_vector_0; + vector input_vector_0 = + input_vector_buffer.Load >(0); + + // expected-error@+1 {{unpacked input vector length must be equal to Matrix K dimension in a linalg Mul/MulAdd operation}} + __builtin_MatVecMul(output_vector_0, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + vector output_vector_1; + vector input_vector_1 = + input_vector_buffer.Load >(0); + + // expected-error@+1 {{output vector length must be equal to Matrix M dimension in a linalg Mul/MulAdd operation}} + __builtin_MatVecMul(output_vector_1, is_output_unsigned, input_vector_1, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Check if Input and Output vector dimensions are valid -non packed +void test_invalid_input_output_vector_dimensions_non_packed_rectangle_matrix() { + + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 16; + const uint matrix_dimK = 32; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + // Use dimension of Matrix K to trigger error + vector output_vector_0; + vector input_vector_0 = + input_vector_buffer.Load >(0); + + // expected-error@+1 {{output vector length must be equal to Matrix M dimension in a linalg Mul/MulAdd operation}} + __builtin_MatVecMul(output_vector_0, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + // Check off by 1 errors + vector output_vector_1; + vector input_vector_1 = + input_vector_buffer.Load >(0); + + // expected-error@+1 {{output vector length must be equal to Matrix M dimension in a linalg Mul/MulAdd operation}} + __builtin_MatVecMul(output_vector_1, is_output_unsigned, input_vector_1, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + // Check off by 1 errors + vector output_vector_2; + vector input_vector_2 = + input_vector_buffer.Load >(0); + + // expected-error@+1 {{output vector length must be equal to Matrix M dimension in a linalg Mul/MulAdd operation}} + __builtin_MatVecMul(output_vector_2, is_output_unsigned, input_vector_2, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + // Use dimension of Matrix M to trigger error + vector output_vector_3; + vector input_vector_3 = + input_vector_buffer.Load >(0); + + // expected-error@+1 {{unpacked input vector length must be equal to Matrix K dimension in a linalg Mul/MulAdd operation}} + __builtin_MatVecMul(output_vector_3, is_output_unsigned, input_vector_3, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + // Check off by 1 errors + vector output_vector_4; + vector input_vector_4 = + input_vector_buffer.Load >(0); + + // expected-error@+1 {{unpacked input vector length must be equal to Matrix K dimension in a linalg Mul/MulAdd operation}} + __builtin_MatVecMul(output_vector_4, is_output_unsigned, input_vector_4, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + // Check off by 1 errors + vector output_vector_5; + vector input_vector_5 = + input_vector_buffer.Load >(0); + + // expected-error@+1 {{unpacked input vector length must be equal to Matrix K dimension in a linalg Mul/MulAdd operation}} + __builtin_MatVecMul(output_vector_5, is_output_unsigned, input_vector_5, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + // Swap dimensions to trigger error + vector output_vector_6; + vector input_vector_6 = + input_vector_buffer.Load >(0); + + // expected-error@+1 {{output vector length must be equal to Matrix M dimension in a linalg Mul/MulAdd operation}} + __builtin_MatVecMul(output_vector_6, is_output_unsigned, input_vector_6, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Check if matrtrix interpretation is a constant value +void test_invalid_matrix_interpretation_constant_value() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + const uint matrix_interpretation_0 = constants_buffer.Load(0); + + // expected-error@+3 {{expression is not an integer constant expression}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_0, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Check for invalid matrix interpretation value +void test_invalid_matrix_interpretation_value() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + const uint matrix_interpretation_0 = 0; + + // expected-error@+3 {{0 is an invalid memory interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_0, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint matrix_interpretation_1 = 1; + + // expected-error@+3 {{1 is an invalid memory interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_1, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint matrix_interpretation_2 = 6; + + // expected-error@+3 {{6 is an invalid memory interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_2, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint matrix_interpretation_3 = 7; + + // expected-error@+3 {{7 is an invalid memory interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_3, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint matrix_interpretation_4 = 10; + + // expected-error@+3 {{10 is an invalid memory interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_4, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint matrix_interpretation_5 = 11; + + // expected-error@+3 {{11 is an invalid memory interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_5, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint matrix_interpretation_6 = 12; + + // expected-error@+3 {{12 is an invalid memory interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_6, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint matrix_interpretation_7 = 13; + + // expected-error@+3 {{13 is an invalid memory interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_7, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint matrix_interpretation_8 = 14; + + // expected-error@+3 {{14 is an invalid memory interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_8, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint matrix_interpretation_9 = 15; + + // expected-error@+3 {{15 is an invalid memory interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_9, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint matrix_interpretation_10 = 16; + + // expected-error@+3 {{16 is an invalid memory interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_10, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint matrix_interpretation_11 = 23; + // expected-error@+3 {{23 is an invalid memory interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_11, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint matrix_interpretation_12 = 100; + + // expected-error@+3 {{100 is an invalid memory interpretation value}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation_12, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Check if matrix Layout is a constant value +void test_invalid_matrix_layout_constant_value() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + const uint matrix_layout = constants_buffer.Load(0); + + // expected-error@+4 {{expression is not an integer constant expression}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Check invalid matrix layout value +void test_invalid_matrix_layout_value() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + const uint matrix_layout_0 = 4; + + // expected-error@+4 {{matrix layout 4 is not valid, must be in the range [0, 3]}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout_0, matrix_is_transposed, + matrix_stride); +} + +// Check if matrix is transposed is a constant value +void test_invalid_matrix_transposed_constant_value() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = constants_buffer.Load(0); + const uint matrix_stride = 64; + + // expected-error@+4 {{expression is not an integer constant expression}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Check if invalid matrix transpose value is used +void test_invalid_matrix_transpose_value() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_stride = 64; + + const uint matrix_layout_0 = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed_0 = true; + + // expected-error@+4 {{RowMajor and ColumnMajor matrices are not transposable}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout_0, matrix_is_transposed_0, + matrix_stride); + + const uint matrix_layout_1 = MatrixLayout::MATRIX_LAYOUT_COLUMN_MAJOR; + const bool matrix_is_transposed_1 = true; + + // expected-error@+4 {{RowMajor and ColumnMajor matrices are not transposable}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout_1, matrix_is_transposed_1, + matrix_stride); +} + + +// Check invalid matrix stride value for optimal matrix layout +void test_invalid_matrix_stride_constant_value() { + + vector output_vector; + const uint is_output_unsigned = 1; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const bool matrix_is_transposed = false; + + const uint matrix_layout_0 = MatrixLayout::MATRIX_LAYOUT_MUL_OPTIMAL; + const uint matrix_stride_0 = 64; + + // expected-error@+5 {{for optimal matrix layout, matrix stride must be 0}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout_0, matrix_is_transposed, + matrix_stride_0); + + const uint matrix_layout_1 = MatrixLayout::MATRIX_LAYOUT_OUTER_PRODUCT_OPTIMAL; + const uint matrix_stride_1 = 64; + + // expected-error@+5 {{for optimal matrix layout, matrix stride must be 0}} + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout_1, matrix_is_transposed, + matrix_stride_1); +} diff --git a/tools/clang/test/SemaHLSL/hlsl/linalg/builtins/mul_valid.hlsl b/tools/clang/test/SemaHLSL/hlsl/linalg/builtins/mul_valid.hlsl new file mode 100644 index 0000000000..5972b22b95 --- /dev/null +++ b/tools/clang/test/SemaHLSL/hlsl/linalg/builtins/mul_valid.hlsl @@ -0,0 +1,344 @@ +// RUN: %dxc -I %hlsl_headers -T lib_6_9 -enable-16bit-types %s -verify + +#include + +using namespace dx::linalg; + +ByteAddressBuffer input_vector_buffer; +ByteAddressBuffer matrix_buffer; +RWByteAddressBuffer output_vector_buffer; +ByteAddressBuffer const_buffer; + +// Output vector, isUnsigned mismatch +void test_valid_output_vector_type() { + + vector input_vector = input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + vector output_vector_0; + const uint is_output_unsigned_0 = 1; + + // expected-no-diagnostics@+1 + __builtin_MatVecMul(output_vector_0, is_output_unsigned_0, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, matrix_offset, + matrix_interpretation, matrix_dimM, matrix_dimK, matrix_layout, + matrix_is_transposed, matrix_stride); + + vector output_vector_1; + const uint is_output_unsigned_1 = 0; + + // expected-no-diagnostics@+1 + __builtin_MatVecMul(output_vector_1, is_output_unsigned_1, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, matrix_offset, + matrix_interpretation, matrix_dimM, matrix_dimK, matrix_layout, + matrix_is_transposed, matrix_stride); + + vector output_vector_2; + const uint is_output_unsigned_2 = 0; + + // expected-no-diagnostics@+1 + __builtin_MatVecMul(output_vector_2, is_output_unsigned_2, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, matrix_offset, + matrix_interpretation, matrix_dimM, matrix_dimK, matrix_layout, + matrix_is_transposed, matrix_stride); +} + +void test_valid_is_output_unsigned_non_const() { + + vector output_vector_0; + vector input_vector = + input_vector_buffer.Load >(0); + const uint is_input_unsigned = 0; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + const uint is_output_unsigned_0 = 1; + + // expected-no-diagnostics@+1 + __builtin_MatVecMul(output_vector_0, is_output_unsigned_0, input_vector, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Input vector is incorrect type +void test_valid_input_vector_type() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_0 = 0; + + // expected-no-diagnostics@+1 + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned_0, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_1 = 1; + + // expected-no-diagnostics@+1 + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned_1, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + vector input_vector_2 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_2 = 0; + + // expected-no-diagnostics@+1 + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_2, + is_input_unsigned_2, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Check valid input vector packed types +void test_valid_input_vector_packed_types() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + const uint input_interpretation_0 = DataType::DATA_TYPE_UINT8_T4_PACKED; + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_0 = 1; + + // expected-no-diagnostics@+1 + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned_0, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_1 = DataType::DATA_TYPE_SINT8_T4_PACKED; + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_1 = 1; + + // expected-no-diagnostics@+1 + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned_1, input_interpretation_1, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + +} + +// IsInputUnsigned must be true for packed input vector type +void test_valid_is_input_unsigned_packed_input_vector_type() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + const uint input_interpretation_0 = DataType::DATA_TYPE_UINT8_T4_PACKED; + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_0 = 1; + + // expected-no-diagnostics@+2 + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned_0, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + const uint input_interpretation_1 = DataType::DATA_TYPE_SINT8_T4_PACKED; + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint is_input_unsigned_1 = 1; + + // expected-no-diagnostics@+2 + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned_1, input_interpretation_1, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Check packed input vector dimension +void test_valid_packed_input_vector_dimension() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 1; + const uint input_interpretation = DataType::DATA_TYPE_UINT8_T4_PACKED; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_UINT8; + const uint matrix_dimM = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_MUL_OPTIMAL; + const bool matrix_is_transposed = false; + const uint matrix_stride = 0; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint matrix_dimK_0 = 4; + + // expected-no-diagnostics@+1 + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_0, matrix_layout, matrix_is_transposed, + matrix_stride); + + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint matrix_dimK_1 = 7; + + // expected-no-diagnostics@+1 + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned, input_interpretation, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_1, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Check if Matrix M dimension is less than Max +void test_valid_matrix_M_dimension_less_than_Max() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 1; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimK = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = matrix_dimK * 4; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint input_interpretation_0 = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM_0 = 4; + + // expected-no-diagnostics@+1 + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM_0, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); + + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint input_interpretation_1 = DataType::DATA_TYPE_UINT8_T4_PACKED; + const uint matrix_dimM_1 = 4; + + // expected-no-diagnostics@+1 + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned, input_interpretation_1, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM_1, + matrix_dimK, matrix_layout, matrix_is_transposed, + matrix_stride); +} + +// Check if Matrix K dimension is less than Max in unpacked input vector case +void test_valid_matrix_K_dimension_less_than_Max_unpacked_input_vector() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 1; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint input_interpretation_0 = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimK_0 = 4; + + // expected-no-diagnostics@+1 + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_0, matrix_layout, matrix_is_transposed, + matrix_stride); + + vector input_vector_1 = + input_vector_buffer.Load >(0); + const uint input_interpretation_1 = DataType::DATA_TYPE_UINT8; + const uint matrix_dimK_1 = 4; + + // expected-no-diagnostics@+1 + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_1, + is_input_unsigned, input_interpretation_1, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_1, matrix_layout, matrix_is_transposed, + matrix_stride); + +} + +// Check if Matrix M dimension is less than Max in packed input vector case +void test_valid_matrix_M_dimension_less_than_Max_packed_input_vector() { + + vector output_vector; + const uint is_output_unsigned = 1; + const uint is_input_unsigned = 1; + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_dimM = 4; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + const bool matrix_is_transposed = false; + const uint matrix_stride = 64; + + vector input_vector_0 = + input_vector_buffer.Load >(0); + const uint input_interpretation_0 = DataType::DATA_TYPE_UINT8_T4_PACKED; + const uint matrix_dimK_0 = 4096; + + // expected-no-diagnostics@+1 + __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector_0, + is_input_unsigned, input_interpretation_0, matrix_buffer, + matrix_offset, matrix_interpretation, matrix_dimM, + matrix_dimK_0, matrix_layout, matrix_is_transposed, + matrix_stride); +} diff --git a/tools/clang/test/SemaHLSL/hlsl/linalg/builtins/outer_product_accumulate_invalid.hlsl b/tools/clang/test/SemaHLSL/hlsl/linalg/builtins/outer_product_accumulate_invalid.hlsl new file mode 100644 index 0000000000..4e15c92a5d --- /dev/null +++ b/tools/clang/test/SemaHLSL/hlsl/linalg/builtins/outer_product_accumulate_invalid.hlsl @@ -0,0 +1,256 @@ +// RUN: %dxc -I %hlsl_headers -T lib_6_9 -enable-16bit-types %s -verify + +#include + +using namespace dx::linalg; + +ByteAddressBuffer input_vector_buffer; +RWByteAddressBuffer accumulate_buffer; +ByteAddressBuffer constants_buffer; + +// Check if input vectors aren't the same component type +void test_invalid_input_vector_component_type() { + + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_OUTER_PRODUCT_OPTIMAL; + const uint matrix_stride = 0; + + vector input_vector_0_0 = input_vector_buffer.Load >(0); + vector input_vector_1_0 = input_vector_buffer.Load >(0); + + // expected-error@+1 {{input vectors of outerproductaccumulate must have the same element type}} + __builtin_OuterProductAccumulate(input_vector_0_0, input_vector_1_0, + accumulate_buffer, matrix_offset, + matrix_interpretation, matrix_layout, + matrix_stride); + + vector input_vector_0_1 = input_vector_buffer.Load >(0); + vector input_vector_1_1 = input_vector_buffer.Load >(0); + + // expected-error@+1 {{input vectors of outerproductaccumulate must have the same element type}} + __builtin_OuterProductAccumulate(input_vector_0_1, input_vector_1_1, + accumulate_buffer, matrix_offset, + matrix_interpretation, matrix_layout, + matrix_stride); +} + +// Check for non constant matrix interpretation +void test_non_constant_matrix_interpretation() { + + vector input_vector_0 = input_vector_buffer.Load >(0); + vector input_vector_1 = input_vector_buffer.Load >(0); + const uint matrix_offset = 0; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_OUTER_PRODUCT_OPTIMAL; + const uint matrix_stride = 0; + + const uint matrix_interpretation = constants_buffer.Load(0); + + // expected-error@+3 {{expression is not an integer constant expression}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation, matrix_layout, + matrix_stride); +} + +// Check for matrix interpretation is not a valid value +void test_invalid_matrix_interpretation() { + + vector input_vector_0 = input_vector_buffer.Load >(0); + vector input_vector_1 = input_vector_buffer.Load >(0); + const uint matrix_offset = 0; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_OUTER_PRODUCT_OPTIMAL; + const uint matrix_stride = 0; + + const uint matrix_interpretation = 0; + + // expected-error@+3 {{0 is an invalid memory interpretation value}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation, matrix_layout, + matrix_stride); + + const uint matrix_interpretation_2 = 1; + + // expected-error@+3 {{1 is an invalid memory interpretation value}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation_2, matrix_layout, + matrix_stride); + + const uint matrix_interpretation_3 = 6; + + // expected-error@+3 {{6 is an invalid memory interpretation value}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation_3, matrix_layout, + matrix_stride); + + const uint matrix_interpretation_4 = 7; + + // expected-error@+3 {{7 is an invalid memory interpretation value}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation_4, matrix_layout, + matrix_stride); + + const uint matrix_interpretation_5 = 10; + + // expected-error@+3 {{10 is an invalid memory interpretation value}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation_5, matrix_layout, + matrix_stride); + + const uint matrix_interpretation_6 = 11; + + // expected-error@+3 {{11 is an invalid memory interpretation value}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation_6, matrix_layout, + matrix_stride); + + const uint matrix_interpretation_7 = 12; + + // expected-error@+3 {{12 is an invalid memory interpretation value}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation_7, matrix_layout, + matrix_stride); + + const uint matrix_interpretation_8 = 13; + + // expected-error@+3 {{13 is an invalid memory interpretation value}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation_8, matrix_layout, + matrix_stride); + + const uint matrix_interpretation_9 = 14; + + // expected-error@+3 {{14 is an invalid memory interpretation value}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation_9, matrix_layout, + matrix_stride); + + const uint matrix_interpretation_10 = 15; + + // expected-error@+3 {{15 is an invalid memory interpretation value}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation_10, matrix_layout, + matrix_stride); + + const uint matrix_interpretation_11 = 16; + + // expected-error@+3 {{16 is an invalid memory interpretation value}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation_11, matrix_layout, + matrix_stride); + + const uint matrix_interpretation_12 = DataType::DATA_TYPE_SINT8_T4_PACKED; + + // expected-error@+3 {{17 is an invalid memory interpretation value}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation_12, matrix_layout, + matrix_stride); + + const uint matrix_interpretation_13 = DataType::DATA_TYPE_UINT8_T4_PACKED; + + // expected-error@+3 {{18 is an invalid memory interpretation value}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation_13, matrix_layout, + matrix_stride); + + const uint matrix_interpretation_14 = 23; + + // expected-error@+3 {{23 is an invalid memory interpretation value}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation_14, matrix_layout, + matrix_stride); + + const uint matrix_interpretation_15 = 100; + + // expected-error@+3 {{100 is an invalid memory interpretation value}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation_15, matrix_layout, + matrix_stride); + +} + +// Check for matrix layout is not a constant parameter +void test_non_constant_matrix_layout() { + + vector input_vector_0 = input_vector_buffer.Load >(0); + vector input_vector_1 = input_vector_buffer.Load >(0); + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_stride = 0; + + const uint matrix_layout = constants_buffer.Load(0); + + // expected-error@+3 {{expression is not an integer constant expression}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation, matrix_layout, + matrix_stride); +} + +// Check for matrix layout is not a valid value +void test_invalid_matrix_layout() { + + vector input_vector_0 = input_vector_buffer.Load >(0); + vector input_vector_1 = input_vector_buffer.Load >(0); + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_stride = 0; + + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_ROW_MAJOR; + + // expected-error@+3 {{matrix layout for outerproductaccumulate must be 3}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation, matrix_layout, + matrix_stride); + + const uint matrix_layout_2 = MatrixLayout::MATRIX_LAYOUT_COLUMN_MAJOR; + + // expected-error@+3 {{matrix layout for outerproductaccumulate must be 3}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation, matrix_layout_2, + matrix_stride); + + const uint matrix_layout_3 = MatrixLayout::MATRIX_LAYOUT_MUL_OPTIMAL; + + // expected-error@+3 {{matrix layout for outerproductaccumulate must be 3}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation, matrix_layout_3, + matrix_stride); + +} + +// Check for matrix stride is zero, if constant +void test_zero_matrix_stride() { + + vector input_vector_0 = input_vector_buffer.Load >(0); + vector input_vector_1 = input_vector_buffer.Load >(0); + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_OUTER_PRODUCT_OPTIMAL; + + const uint matrix_stride = 16; + + // expected-error@+4 {{for optimal matrix layout, matrix stride must be 0}} + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation, matrix_layout, + matrix_stride); +} diff --git a/tools/clang/test/SemaHLSL/hlsl/linalg/builtins/outer_product_accumulate_valid.hlsl b/tools/clang/test/SemaHLSL/hlsl/linalg/builtins/outer_product_accumulate_valid.hlsl new file mode 100644 index 0000000000..85298e2dbb --- /dev/null +++ b/tools/clang/test/SemaHLSL/hlsl/linalg/builtins/outer_product_accumulate_valid.hlsl @@ -0,0 +1,66 @@ +// RUN: %dxc -I %hlsl_headers -T lib_6_9 -enable-16bit-types %s -verify + +#include + +using namespace dx::linalg; + +ByteAddressBuffer input_vector_buffer; +RWByteAddressBuffer accumulate_buffer; +ByteAddressBuffer constants_buffer; + +// Check for input vectors aren't the same component type +void test_invalid_input_vector_component_type() { + + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_OUTER_PRODUCT_OPTIMAL; + const uint matrix_stride = 0; + + vector input_vector_0_0 = input_vector_buffer.Load >(0); + vector input_vector_1_0 = input_vector_buffer.Load >(0); + + // expected-no-diagnostics@+1 + __builtin_OuterProductAccumulate(input_vector_0_0, input_vector_1_0, + accumulate_buffer, matrix_offset, + matrix_interpretation, matrix_layout, + matrix_stride); + + vector input_vector_0_1 = input_vector_buffer.Load >(0); + vector input_vector_1_1 = input_vector_buffer.Load >(0); + + // expected-no-diagnostics@+1 + __builtin_OuterProductAccumulate(input_vector_0_1, input_vector_1_1, + accumulate_buffer, matrix_offset, + matrix_interpretation, matrix_layout, + matrix_stride); + + vector input_vector_0_2 = input_vector_buffer.Load >(0); + vector input_vector_1_2 = input_vector_buffer.Load >(0); + + // expected-no-diagnostics@+1 + __builtin_OuterProductAccumulate(input_vector_0_2, input_vector_1_2, + accumulate_buffer, matrix_offset, + matrix_interpretation, matrix_layout, + matrix_stride); +} + +// Check for non constant matrix stride +void test_non_constant_matrix_stride() { + + vector input_vector_0 = input_vector_buffer.Load >(0); + vector input_vector_1 = input_vector_buffer.Load >(0); + const uint matrix_offset = 0; + const uint matrix_interpretation = DataType::DATA_TYPE_FLOAT32; + const uint matrix_layout = MatrixLayout::MATRIX_LAYOUT_OUTER_PRODUCT_OPTIMAL; + + const uint matrix_stride = constants_buffer.Load(0); + + // expected-no-diagnostics@+4 + __builtin_OuterProductAccumulate(input_vector_0, input_vector_1, + accumulate_buffer, matrix_offset, + matrix_interpretation, matrix_layout, + matrix_stride); +} + +// Check for matrix stride is not a valid value + diff --git a/tools/clang/test/SemaHLSL/hlsl/linalg/make-interp-vec-errors.hlsl b/tools/clang/test/SemaHLSL/hlsl/linalg/make-interp-vec-errors.hlsl index 9f2793d417..be67d92546 100644 --- a/tools/clang/test/SemaHLSL/hlsl/linalg/make-interp-vec-errors.hlsl +++ b/tools/clang/test/SemaHLSL/hlsl/linalg/make-interp-vec-errors.hlsl @@ -10,7 +10,7 @@ export float4 Test1(vector Input) { Buf, 0, 0}; // expected-error@+3{{no matching function for call to 'MakeInterpretedVector'}} - // expected-note@dx/linalg.h:97{{candidate template ignored: invalid explicitly-specified argument for template parameter 'DT'}} + // expected-note@dx/linalg.h:113{{candidate template ignored: invalid explicitly-specified argument for template parameter 'DT'}} return Mul( Matrix, MakeInterpretedVector<2>(Input)); } @@ -26,7 +26,7 @@ export float4 Test2(vector Input) { Buf, 0, 0}; // expected-error@+3{{no matching function for call to 'MakeInterpretedVector'}} - // expected-note@dx/linalg.h:97{{candidate template ignored: invalid explicitly-specified argument for template parameter 'DT'}} + // expected-note@dx/linalg.h:113{{candidate template ignored: invalid explicitly-specified argument for template parameter 'DT'}} return Mul( Matrix, MakeInterpretedVector(Input)); } diff --git a/tools/clang/test/SemaHLSL/hlsl/linalg/mat-vec-mul-errors.hlsl b/tools/clang/test/SemaHLSL/hlsl/linalg/mat-vec-mul-errors.hlsl index 2d5a11e83e..b911de648e 100644 --- a/tools/clang/test/SemaHLSL/hlsl/linalg/mat-vec-mul-errors.hlsl +++ b/tools/clang/test/SemaHLSL/hlsl/linalg/mat-vec-mul-errors.hlsl @@ -11,6 +11,6 @@ vector MixUpVectorAndMatrixArguments(vector Input) { Buf, 0, 0}; // expected-error@+2{{no matching function for call to 'Mul'}} - // expected-note@dx/linalg.h:111{{candidate template ignored: could not match 'MatrixRefImpl' against 'InterpretedVector'}} + // expected-note@dx/linalg.h:127{{candidate template ignored: could not match 'MatrixRefImpl' against 'InterpretedVector'}} return Mul(MakeInterpretedVector(Input), Matrix); } diff --git a/tools/clang/test/SemaHLSL/hlsl/linalg/mat-vec-muladd-errors.hlsl b/tools/clang/test/SemaHLSL/hlsl/linalg/mat-vec-muladd-errors.hlsl index f444f81c3a..24ad3ef46c 100644 --- a/tools/clang/test/SemaHLSL/hlsl/linalg/mat-vec-muladd-errors.hlsl +++ b/tools/clang/test/SemaHLSL/hlsl/linalg/mat-vec-muladd-errors.hlsl @@ -11,6 +11,6 @@ vector MixUpVectorAndMatrixArguments(vector Input) { Buf, 0, 0}; // expected-error@+2{{no matching function for call to 'MulAdd'}} - // expected-note@dx/linalg.h:137{{candidate template ignored: could not match 'MatrixRefImpl' against 'InterpretedVector'}} + // expected-note@dx/linalg.h:153{{candidate template ignored: could not match 'MatrixRefImpl' against 'InterpretedVector'}} return MulAdd(MakeInterpretedVector(Input), Matrix, MakeInterpretedVector(Input)); } diff --git a/tools/clang/test/SemaHLSL/hlsl/linalg/outerproductaccumulate-errors.hlsl b/tools/clang/test/SemaHLSL/hlsl/linalg/outerproductaccumulate-errors.hlsl index 6f503b367b..5759631bcb 100644 --- a/tools/clang/test/SemaHLSL/hlsl/linalg/outerproductaccumulate-errors.hlsl +++ b/tools/clang/test/SemaHLSL/hlsl/linalg/outerproductaccumulate-errors.hlsl @@ -12,7 +12,7 @@ export void Test4(vector Input1, vector Input2) { matrix = {RWBuf, 0, 0}; // expected-error@+3{{no matching function for call to 'OuterProductAccumulate'}} - // expected-note@dx/linalg.h:161{{candidate template ignored: could not match 0 against 1}} + // expected-note@dx/linalg.h:177{{candidate template ignored: could not match 0 against 1}} OuterProductAccumulate(Input1, Input2, matrix); } @@ -25,7 +25,7 @@ export void Test5(vector Input1, vector Input2) { matrix = {RWBuf, 0, 0}; // expected-error@+3{{no matching function for call to 'OuterProductAccumulate'}} - // expected-note@dx/linalg.h:161{{candidate template ignored: could not match 0 against 1}} + // expected-note@dx/linalg.h:177{{candidate template ignored: could not match 0 against 1}} OuterProductAccumulate(Input1, Input2, matrix); } @@ -38,7 +38,7 @@ export void Test4(vector Input1, vector Input2) { matrix = {RWBuf, 0, 0}; // expected-error@+3{{no matching function for call to 'OuterProductAccumulate'}} - // expected-note@dx/linalg.h:161{{candidate template ignored: deduced conflicting types for parameter 'ElTy' ('int' vs. 'unsigned int')}} + // expected-note@dx/linalg.h:177{{candidate template ignored: deduced conflicting types for parameter 'ElTy' ('int' vs. 'unsigned int')}} OuterProductAccumulate(Input1, Input2, matrix); } diff --git a/tools/clang/test/SemaHLSL/hlsl/linalg/unavailable-pre-sm69.hlsl b/tools/clang/test/SemaHLSL/hlsl/linalg/unavailable-pre-sm69.hlsl index d5e251ae8b..57683b9a59 100644 --- a/tools/clang/test/SemaHLSL/hlsl/linalg/unavailable-pre-sm69.hlsl +++ b/tools/clang/test/SemaHLSL/hlsl/linalg/unavailable-pre-sm69.hlsl @@ -23,7 +23,7 @@ void cs_main() const bool matrix_is_transposed = false; const uint matrix_stride = 64; - //expected-error@+1{{intrinsic __builtin_MatVecMul potentially used by 'cs_main' requires shader model 6.9 or greater}} + //expected-error@+1{{intrinsic hlsl::__builtin_MatVecMul potentially used by ''cs_main'' requires shader model 6.9 or greater}} __builtin_MatVecMul(output_vector, is_output_unsigned, input_vector, is_input_unsigned, input_interpretation, matrix_buffer, matrix_offset, matrix_interpretation, matrix_dimM, matrix_dimK, matrix_layout, @@ -32,7 +32,7 @@ void cs_main() const uint bias_offset = 0; const uint bias_interpretation = 9; /*F32*/ - //expected-error@+1{{intrinsic __builtin_MatVecMulAdd potentially used by 'cs_main' requires shader model 6.9 or greater}} + //expected-error@+1{{intrinsic hlsl::__builtin_MatVecMulAdd potentially used by ''cs_main'' requires shader model 6.9 or greater}} __builtin_MatVecMulAdd(output_vector, is_output_unsigned, input_vector, is_input_unsigned, input_interpretation, matrix_buffer, matrix_offset, matrix_interpretation, matrix_dimM, matrix_dimK, matrix_layout, @@ -44,16 +44,16 @@ void cs_main() const uint opa_matrix_offset = 0; const uint opa_matrix_interpretation = 5; /*U32*/ const uint opa_matrix_layout = 3; /*OuterProductOptimal*/ - const uint opa_matrix_stride = 64; + const uint opa_matrix_stride = 0; - //expected-error@+1{{intrinsic __builtin_OuterProductAccumulate potentially used by 'cs_main' requires shader model 6.9 or greater}} + //expected-error@+1{{intrinsic hlsl::__builtin_OuterProductAccumulate potentially used by ''cs_main'' requires shader model 6.9 or greater}} __builtin_OuterProductAccumulate(input_vector1, input_vector2, rw_matrix_buffer, opa_matrix_offset, opa_matrix_interpretation, opa_matrix_layout, opa_matrix_stride); const uint va_matrix_offset = 0; - //expected-error@+1{{intrinsic __builtin_VectorAccumulate potentially used by 'cs_main' requires shader model 6.9 or greater}} - __builtin_VectorAccumulate(input_vector1, rw_matrix_buffer, - va_matrix_offset); + //expected-error@+1{{intrinsic hlsl::__builtin_VectorAccumulate potentially used by ''cs_main'' requires shader model 6.9 or greater}} + __builtin_VectorAccumulate(input_vector1, rw_matrix_buffer, + va_matrix_offset); } \ No newline at end of file diff --git a/utils/hct/gen_intrin_main.txt b/utils/hct/gen_intrin_main.txt index e5e4119330..60bef02f18 100644 --- a/utils/hct/gen_intrin_main.txt +++ b/utils/hct/gen_intrin_main.txt @@ -383,13 +383,13 @@ void [[]] Barrier(in NodeRecordOrUAV o, in uint SemanticFlags); uint [[]] GetRemainingRecursionLevels(); -void [[]] __builtin_MatVecMul(out numeric OutputVector, in bool OutputIsUnsigned, in numeric InputVector, in bool InputIsUnsigned, in uint InputInterpretation, in ByteAddressBuffer MatrixBuffer, in uint MatrixOffset, in uint MatrixInterpretation, in uint M, in uint K, in uint MatrixLayout, in bool MatrixIsTransposed, in uint MatrixStride); +void [[min_sm=6.9]] __builtin_MatVecMul(out LinAlg OutputVector, in bool OutputIsUnsigned, in LinAlg InputVector, in bool InputIsUnsigned, in uint InputInterpretation, in ByteAddressBuffer MatrixBuffer, in uint MatrixOffset, in uint MatrixInterpretation, in uint M, in uint K, in uint MatrixLayout, in bool MatrixIsTransposed, in uint MatrixStride); -void [[]] __builtin_MatVecMulAdd(out numeric OutputVector, in bool OutputIsUnsigned, in numeric InputVector, in bool InputIsUnsigned, in uint InputInterpretation, in ByteAddressBuffer MatrixBuffer, in uint MatrixOffset, in uint MatrixInterpretation, in uint M, in uint K, in uint MatrixLayout, in bool MatrixIsTransposed, in uint MatrixStride, in ByteAddressBuffer BiasVector, in uint BiasOffset, in uint BiasInterpretation); +void [[min_sm=6.9]] __builtin_MatVecMulAdd(out LinAlg OutputVector, in bool OutputIsUnsigned, in LinAlg InputVector, in bool InputIsUnsigned, in uint InputInterpretation, in ByteAddressBuffer MatrixBuffer, in uint MatrixOffset, in uint MatrixInterpretation, in uint M, in uint K, in uint MatrixLayout, in bool MatrixIsTransposed, in uint MatrixStride, in ByteAddressBuffer BiasVector, in uint BiasOffset, in uint BiasInterpretation); -void [[]] __builtin_OuterProductAccumulate(in numeric InputVector1, in numeric InputVector2, in RWByteAddressBuffer MatrixBuffer, in uint MatrixOffset, in uint MatrixInterpretation, in uint MatrixLayout, in uint MatrixStride); +void [[min_sm=6.9]] __builtin_OuterProductAccumulate(in LinAlg InputVector1, in LinAlg InputVector2, in RWByteAddressBuffer MatrixBuffer, in uint MatrixOffset, in uint MatrixInterpretation, in uint MatrixLayout, in uint MatrixStride); -void [[]] __builtin_VectorAccumulate(in numeric InputVector, in RWByteAddressBuffer MatrixBuffer, in uint MatrixOffset); +void [[min_sm=6.9]] __builtin_VectorAccumulate(in LinAlg InputVector, in RWByteAddressBuffer MatrixBuffer, in uint MatrixOffset); } namespace diff --git a/utils/hct/hctdb.py b/utils/hct/hctdb.py index 5567a6a88d..3af3cde949 100644 --- a/utils/hct/hctdb.py +++ b/utils/hct/hctdb.py @@ -8419,13 +8419,13 @@ def build_valrules(self): self.add_valrule_msg( "Instr.MatVecOpIsUnsignedFlagsAreConst", "In Linalg Mul/MulAdd functions, IsUnsigned flag is a constant.", - "'%1' is not a constant value", + "%0 is not a constant value", ) self.add_valrule_msg( "Instr.LinalgInterpretationParamAreConst", "In Linalg operations, Interpretation value is a constant.", - "'%1' is not a constant value", + "%0 is not a constant value", ) self.add_valrule_msg( @@ -9357,6 +9357,7 @@ def __init__(self, intrinsic_defs, opcode_data): "DxHitObject": "LICOMPTYPE_HIT_OBJECT", "VkBufferPointer": "LICOMPTYPE_VK_BUFFER_POINTER", "RayQuery": "LICOMPTYPE_RAY_QUERY", + "LinAlg": "LICOMPTYPE_LINALG", } self.trans_rowcol = {"r": "IA_R", "c": "IA_C", "r2": "IA_R2", "c2": "IA_C2"}