derek.holloway
7502bf64a4
CodeQL / Analyze (actions) (push) Canceled after 0s
CodeQL / Analyze (python) (push) Canceled after 0s
pre-commit / pre-commit (push) Canceled after 0s
Multi-Arch CI / setup (push) Canceled after 0s
Publish build_manylinux_x86_64 images / publish_build_manylinux_x86_64 (push) Canceled after 0s
Setup (Multi-Arch) / setup (push) Canceled after 0s
Multi-Arch CI / Linux::${{ fromJSON(needs.setup.outputs.linux_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubi10 image / publish_no_rocm_image_ubi10 (push) Canceled after 0s
Multi-Arch CI / Windows::${{ fromJSON(needs.setup.outputs.windows_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Multi-Arch CI / Manifest Diff (push) Canceled after 0s
TheRock Manifest Diff Report / Generate Manifest Diff Report (push) Canceled after 0s
Multi-Arch CI / CI Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_ocl_rt images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_rocgdb images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Unit Tests / Unit Tests :: ubuntu-24.04 (push) Canceled after 0s
Unit Tests / Unit Tests :: windows-2022 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_media (push) Canceled after 0s
Unit Tests / Unit Tests Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_openmpi (push) Canceled after 0s
313 lines
13 KiB
MLIR
313 lines
13 KiB
MLIR
// RUN: mlir-opt %s -split-input-file -verify-diagnostics
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// arm_sme.get_tile
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_get_tile__bad_vector_type_rank_1() -> vector<[16]xi8> {
|
|
// expected-error@+1 {{op result #0 must be a vector type that fits into a SME tile, but got 'vector<[16]xi8>'}}
|
|
%0 = arm_sme.get_tile : vector<[16]xi8>
|
|
return %0 : vector<[16]xi8>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_get_tile__bad_vector_type_i4() -> vector<[16]x[16]xi4> {
|
|
// expected-error@+1 {{op result #0 must be a vector type that fits into a SME tile, but got 'vector<[16]x[16]xi4>'}}
|
|
%0 = arm_sme.get_tile : vector<[16]x[16]xi4>
|
|
return %0 : vector<[16]x[16]xi4>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_get_tile__bad_vector_type_non_scalable_dim_0() -> vector<16x[16]xi8> {
|
|
// expected-error@+1 {{op result #0 must be a vector type that fits into a SME tile, but got 'vector<16x[16]xi8>'}}
|
|
%0 = arm_sme.get_tile : vector<16x[16]xi8>
|
|
return %0 : vector<16x[16]xi8>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_get_tile__bad_vector_type_non_scalable_dim_1() -> vector<[16]x16xi8> {
|
|
// expected-error@+1 {{op result #0 must be a vector type that fits into a SME tile, but got 'vector<[16]x16xi8>'}}
|
|
%0 = arm_sme.get_tile : vector<[16]x16xi8>
|
|
return %0 : vector<[16]x16xi8>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_get_tile__bad_shape(%tile_id : i8) -> vector<[4]x[16]xi8> {
|
|
// expected-error@+1 {{op result #0 must be a vector type that fits into a SME tile, but got 'vector<[4]x[16]xi8>'}}
|
|
%0 = arm_sme.get_tile : vector<[4]x[16]xi8>
|
|
return %0 : vector<[4]x[16]xi8>
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// arm_sme.insert_tile_slice
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_insert_tile_slice_i8__bad_vector_length(%vector : vector<[8]xi8>, %tile : vector<[16]x[16]xi8>, %tile_slice_index : index) -> vector<[16]x[16]xi8> {
|
|
%c0 = arith.constant 0 : index
|
|
// expected-error@+1 {{op failed to verify that type of 'vector' matches type of 'tile' slice}}
|
|
%0 = arm_sme.insert_tile_slice %vector, %tile[%tile_slice_index] : vector<[8]xi8> into vector<[16]x[16]xi8>
|
|
return %0 : vector<[16]x[16]xi8>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_insert_tile_slice_f32__bad_vector_length(%vector : vector<[8]xf32>, %tile : vector<[4]x[4]xf32>, %tile_slice_index : index) -> vector<[4]x[4]xf32> {
|
|
%c0 = arith.constant 0 : index
|
|
// expected-error@+1 {{op failed to verify that type of 'vector' matches type of 'tile' slice}}
|
|
%0 = arm_sme.insert_tile_slice %vector, %tile[%tile_slice_index] : vector<[8]xf32> into vector<[4]x[4]xf32>
|
|
return %0 : vector<[4]x[4]xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_insert_tile_slice__bad_element_type(%vector : vector<[4]xf64>, %tile : vector<[4]x[4]xf32>, %tile_slice_index : index) -> vector<[4]x[4]xf32> {
|
|
%c0 = arith.constant 0 : index
|
|
// expected-error@+1 {{op failed to verify that type of 'vector' matches type of 'tile' slice}}
|
|
%0 = arm_sme.insert_tile_slice %vector, %tile[%tile_slice_index] : vector<[4]xf64> into vector<[4]x[4]xf32>
|
|
return %0 : vector<[4]x[4]xf32>
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// arm_sme.extract_tile_slice
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_extract_tile_slice__bad_result_length(%tile : vector<[4]x[4]xf32>, %tile_slice_index : index) -> vector<[2]xf32> {
|
|
// expected-error@+1 {{op failed to verify that type of 'result' matches type of 'tile' slice}}
|
|
%0 = arm_sme.extract_tile_slice %tile[%tile_slice_index] : vector<[2]xf32> from vector<[4]x[4]xf32>
|
|
return %0 : vector<[2]xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_extract_tile_slice__bad_result_element_type(%tile : vector<[4]x[4]xf32>, %tile_slice_index : index) -> vector<[4]xf64> {
|
|
// expected-error@+1 {{op failed to verify that type of 'result' matches type of 'tile' slice}}
|
|
%0 = arm_sme.extract_tile_slice %tile[%tile_slice_index] : vector<[4]xf64> from vector<[4]x[4]xf32>
|
|
return %0 : vector<[4]xf64>
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// arm_sme.tile_load
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_tile_load__bad_padding_type(%src : memref<?x?xf64>, %pad : f32, %mask : vector<[2]x[2]xi1>) {
|
|
%c0 = arith.constant 0 : index
|
|
// expected-note@-2 {{prior use here}}
|
|
// expected-error@+1 {{use of value '%pad' expects different type than prior uses: 'f64' vs 'f32'}}
|
|
%tile = arm_sme.tile_load %src[%c0, %c0], %pad, %mask : memref<?x?xf64>, vector<[2]x[2]xf64>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_tile_load__bad_mask_type(%src : memref<?x?xf64>, %pad : f64, %mask : vector<[4]x[4]xi1>) {
|
|
%c0 = arith.constant 0 : index
|
|
// expected-note@-2 {{prior use here}}
|
|
// expected-error@+1 {{use of value '%mask' expects different type than prior uses: 'vector<[2]x[2]xi1>' vs 'vector<[4]x[4]xi1>}}
|
|
%tile = arm_sme.tile_load %src[%c0, %c0], %pad, %mask : memref<?x?xf64>, vector<[2]x[2]xf64>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_tile_load__pad_but_no_mask(%src : memref<?x?xf64>, %pad : f64) {
|
|
%c0 = arith.constant 0 : index
|
|
// expected-error@+1 {{op failed to verify that both `padding` and `mask` should be provided or neither}}
|
|
%tile = arm_sme.tile_load %src[%c0, %c0], %pad, : memref<?x?xf64>, vector<[2]x[2]xf64>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_tile_load__bad_memref_rank(%src : memref<?xf64>, %pad : f64) {
|
|
%c0 = arith.constant 0 : index
|
|
// expected-error@+1 {{op operand #0 must be 2D memref of any non-token type values, but got 'memref<?xf64>'}}
|
|
%tile = arm_sme.tile_load %src[%c0], %pad, : memref<?xf64>, vector<[2]x[2]xf64>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_tile_load__bad_element_type(%src : memref<?x?xi32>) {
|
|
%c0 = arith.constant 0 : index
|
|
// expected-error@+1 {{failed to verify that all of {result, base} have same element type}}
|
|
%tile = arm_sme.tile_load %src[%c0, %c0] : memref<?x?xi32>, vector<[16]x[16]xi8>
|
|
return
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// arm_sme.load_tile_slice
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_load_tile_slice__bad_mask_type(%src : memref<?x?xi8>, %mask : vector<[2]xi1>, %tile : vector<[16]x[16]xi8>, %tile_slice_index : index) {
|
|
%c0 = arith.constant 0 : index
|
|
// expected-error@+1 {{op failed to verify that `mask` has i1 element type and the shape is a slice of `result`}}
|
|
%tile_update = arm_sme.load_tile_slice %src[%c0], %mask, %tile, %tile_slice_index : memref<?x?xi8>, vector<[2]xi1>, vector<[16]x[16]xi8>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_load_tile_slice__bad_element_type(%src : memref<?x?xi32>, %mask : vector<[16]xi1>, %tile : vector<[16]x[16]xi8>, %tile_slice_index : index) {
|
|
%c0 = arith.constant 0 : index
|
|
// expected-error@+1 {{op failed to verify that all of {tile, base} have same element type}}
|
|
%tile_update = arm_sme.load_tile_slice %src[%c0], %mask, %tile, %tile_slice_index : memref<?x?xi32>, vector<[16]xi1>, vector<[16]x[16]xi8>
|
|
return
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// arm_sme.tile_store
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_tile_store__bad_mask_type(%tile : vector<[16]x[16]xi8>, %mask : vector<[1]x[1]xi1>, %dest : memref<?x?xi8>) {
|
|
%c0 = arith.constant 0 : index
|
|
// expected-note@-2 {{prior use here}}
|
|
// expected-error@+1 {{use of value '%mask' expects different type than prior uses: 'vector<[16]x[16]xi1>' vs 'vector<[1]x[1]xi1>}}
|
|
arm_sme.tile_store %tile, %dest[%c0, %c0], %mask : memref<?x?xi8>, vector<[16]x[16]xi8>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_tile_store__bad_memref_rank(%tile : vector<[16]x[16]xi8>, %dest : memref<?xi8>) {
|
|
%c0 = arith.constant 0 : index
|
|
// expected-error@+1 {{op operand #1 must be 2D memref of any non-token type values, but got 'memref<?xi8>'}}
|
|
arm_sme.tile_store %tile, %dest[%c0] : memref<?xi8>, vector<[16]x[16]xi8>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_tile_store__bad_element_type(%tile : vector<[16]x[16]xi8>, %dest : memref<?x?xi32>) {
|
|
%c0 = arith.constant 0 : index
|
|
// expected-error@+1 {{op failed to verify that all of {valueToStore, base} have same element type}}
|
|
arm_sme.tile_store %tile, %dest[%c0, %c0] : memref<?x?xi32>, vector<[16]x[16]xi8>
|
|
return
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// arm_sme.store_tile_slice
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_store_tile_slice__bad_mask_type(%tile : vector<[16]x[16]xi8>, %tile_slice_index : index, %mask : vector<[8]xi1>, %dest : memref<?x?xi8>) -> () {
|
|
%c0 = arith.constant 0 : index
|
|
// expected-error@+1 {{op failed to verify that `mask` has i1 element type and the shape is a slice of `tile`}}
|
|
arm_sme.store_tile_slice %tile, %tile_slice_index, %mask, %dest[%c0] : memref<?x?xi8>, vector<[8]xi1>, vector<[16]x[16]xi8>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_store_tile_slice__bad_element_type(%tile : vector<[16]x[16]xi8>, %tile_slice_index : index, %mask : vector<[16]xi1>, %dest : memref<?x?xi32>) -> () {
|
|
%c0 = arith.constant 0 : index
|
|
// expected-error@+1 {{op failed to verify that all of {tile, base} have same element type}}
|
|
arm_sme.store_tile_slice %tile, %tile_slice_index, %mask, %dest[%c0, %c0] : memref<?x?xi32>, vector<[16]xi1>, vector<[16]x[16]xi8>
|
|
return
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// arm_sme.outerproduct
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_outerproduct__bad_result_type(%vecA: vector<[2]xi16>, %vecB: vector<[2]xi16>) -> vector<[2]x[2]xi16>
|
|
{
|
|
// expected-error@+1 {{op result #0 must be a vector type that fits into a SME tile, but got 'vector<[2]x[2]xi16>'}}
|
|
%0 = arm_sme.outerproduct %vecA, %vecB : vector<[2]xi16>, vector<[2]xi16>
|
|
return %0 : vector<[2]x[2]xi16>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_outerproduct__bad_vector_type(%vecA: vector<[4]xf32>, %vecB: vector<[8]xf32>) -> vector<[4]x[4]xf32>
|
|
{
|
|
// expected-error@+1 {{op failed to verify that all of {lhs, rhs} have same type}}
|
|
%0 = arm_sme.outerproduct %vecA, %vecB : vector<[4]xf32>, vector<[8]xf32>
|
|
return %0 : vector<[4]x[4]xf32>
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// arm_sme.fmopa_2way
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_fmopa_2way__bad_rhs_vector_type(%vecA: vector<[8]xf16>, %vecB: vector<[4]xf32>) -> vector<[4]x[4]xf32>
|
|
{
|
|
// expected-error@+1 {{op failed to verify that all of {lhs, rhs} have same type}}
|
|
%0 = arm_sme.fmopa_2way %vecA, %vecB : vector<[8]xf16>, vector<[4]xf32> into vector<[4]x[4]xf32>
|
|
return %0 : vector<[4]x[4]xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_fmopa_2way__bad_lhs_mask_type(%vecA: vector<[8]xf16>, %vecB: vector<[8]xf16>, %maskA : vector<[4]xi1>, %maskB : vector<[8]xi1>) -> vector<[4]x[4]xf32>
|
|
{
|
|
// expected-note@-2 {{prior use here}}
|
|
// expected-error@+1 {{use of value '%maskA' expects different type than prior uses: 'vector<[8]xi1>' vs 'vector<[4]xi1>}}
|
|
%0 = arm_sme.fmopa_2way %vecA, %vecB masks(%maskA, %maskB) : vector<[8]xf16>, vector<[8]xf16> into vector<[4]x[4]xf32>
|
|
return %0 : vector<[4]x[4]xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_fmopa_2way__bad_rhs_mask_type(%vecA: vector<[8]xf16>, %vecB: vector<[8]xf16>, %maskA : vector<[8]xi1>, %maskB : vector<[4]xi1>) -> vector<[4]x[4]xf32>
|
|
{
|
|
// expected-note@-2 {{prior use here}}
|
|
// expected-error@+1 {{use of value '%maskB' expects different type than prior uses: 'vector<[8]xi1>' vs 'vector<[4]xi1>}}
|
|
%0 = arm_sme.fmopa_2way %vecA, %vecB masks(%maskA, %maskB) : vector<[8]xf16>, vector<[8]xf16> into vector<[4]x[4]xf32>
|
|
return %0 : vector<[4]x[4]xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_fmopa_2way__no_rhs_mask(%vecA: vector<[8]xf16>, %vecB: vector<[8]xf16>, %maskA : vector<[8]xi1>) -> vector<[4]x[4]xf32>
|
|
{
|
|
// expected-error@+1 {{op failed to verify that both `lhsMask` and `rhsMask` should be provided or neither}}
|
|
%0 = arm_sme.fmopa_2way %vecA, %vecB masks(%maskA,) : vector<[8]xf16>, vector<[8]xf16> into vector<[4]x[4]xf32>
|
|
return %0 : vector<[4]x[4]xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_fmopa_2way__bad_acc_type(%vecA: vector<[8]xf16>, %vecB: vector<[8]xf16>) -> vector<[4]x[4]xf32>
|
|
{
|
|
%acc = arm_sme.zero : vector<[2]x[2]xi64>
|
|
// expected-note@-1 {{prior use here}}
|
|
// expected-error@+1 {{use of value '%acc' expects different type than prior uses: 'vector<[4]x[4]xf32>' vs 'vector<[2]x[2]xi64>'}}
|
|
%0 = arm_sme.fmopa_2way %vecA, %vecB masks(%maskA, %maskB) acc(%acc) : vector<[8]xf16>, vector<[8]xf16> into vector<[4]x[4]xf32>
|
|
return %0 : vector<[4]x[4]xf32>
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// arm_sme.smopa_4way
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// -----
|
|
|
|
func.func @arm_sme_smopa_4way__bad_tile_type(%vecA: vector<[8]xi16>, %vecB: vector<[8]xi16>) -> vector<[4]x[4]xi32>
|
|
{
|
|
// expected-error@+1 {{op failed to verify that tile element size equals input element size * 4}}
|
|
%0 = arm_sme.smopa_4way %vecA, %vecB : vector<[8]xi16>, vector<[8]xi16> into vector<[4]x[4]xi32>
|
|
return %0 : vector<[4]x[4]xi32>
|
|
}
|