67ef4ae2c3
Before: op verifiers failed if the input and output ranks were the same (i.e. no expansion or collapse). This behavior requires users of these shape ops to verify manually that they are not creating identity versions of these ops every time they build them -- problematic. This PR removes this strict verification, and introduces folders for the the identity cases. The PR also removes the special case handling of rank-0 tensors for expand_shape and collapse_shape, there doesn't seem to be any reason to treat them differently.
703 lines
24 KiB
MLIR
703 lines
24 KiB
MLIR
// RUN: mlir-opt <%s -split-input-file -verify-diagnostics
|
|
|
|
// Asking the dimension of a 0-D shape doesn't make sense.
|
|
func.func @dim_0_ranked(%arg : tensor<f32>, %arg1 : index) {
|
|
tensor.dim %arg, %arg1 : tensor<f32> // expected-error {{'tensor.dim' op operand #0 must be non-0-ranked or unranked tensor, but got 'tensor<f32>'}}
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @tensor.cast_mismatching_constants(%arg0: tensor<1xf32>) {
|
|
// expected-error@+1 {{operand type 'tensor<1xf32>' and result type 'tensor<2xf32>' are cast incompatible}}
|
|
%0 = tensor.cast %arg0 : tensor<1xf32> to tensor<2xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @concat_empty() {
|
|
// expected-error@+1 {{requires at least one input}}
|
|
%0 = tensor.concat dim(0) : () -> tensor<1x2x3xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @concat_rank_mismatch(%arg0: tensor<1xf32>, %arg1: tensor<1xf32>) {
|
|
// expected-error@+1 {{rank of concatenated inputs must match result rank}}
|
|
%0 = tensor.concat dim(0) %arg0, %arg1 : (tensor<1xf32>, tensor<1xf32>) -> tensor<2x1xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @concat_dim_out_of_range(%arg0: tensor<3xf32>) {
|
|
// expected-error@+1 {{concatenation dim must be less than the tensor rank}}
|
|
%0 = tensor.concat dim(1) %arg0 : (tensor<3xf32>) -> tensor<3xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @concat_element_type_mismatch(%arg0: tensor<3xf32>, %arg1: tensor<3xi32>) {
|
|
// expected-error@+1 {{inputs and result element type must match}}
|
|
%0 = tensor.concat dim(0) %arg0, %arg1 : (tensor<3xf32>, tensor<3xi32>) -> tensor<3xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @concat_incompatible_input_types(%arg0: tensor<3x4xf32>, %arg1: tensor<4x5xf32>) {
|
|
// expected-error@+1 {{static concatenation size mismatch along non-concatenated dimension 1}}
|
|
%0 = tensor.concat dim(0) %arg0, %arg1 : (tensor<3x4xf32>, tensor<4x5xf32>) -> tensor<7x5xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @concat_static_shape_mismatch(%arg0: tensor<3xf32>) {
|
|
// expected-error@+1 {{result type 'tensor<7xf32>'does not match inferred shape 'tensor<6xf32>' static sizes}}
|
|
%0 = tensor.concat dim(0) %arg0, %arg0 : (tensor<3xf32>, tensor<3xf32>) -> tensor<7xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @extract_too_many_indices(%arg0: tensor<?xf32>) {
|
|
// expected-error@+1 {{incorrect number of indices for extract_element}}
|
|
%0 = tensor.extract %arg0[] : tensor<?xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @insert_too_many_indices(%arg0: f32, %arg1: tensor<?xf32>) {
|
|
// expected-error@+1 {{incorrect number of indices}}
|
|
%0 = tensor.insert %arg0 into %arg1[] : tensor<?xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @tensor.from_elements_wrong_result_type() {
|
|
// expected-error@+2 {{'tensor.from_elements' invalid kind of type specified}}
|
|
%c0 = arith.constant 0 : i32
|
|
%0 = tensor.from_elements %c0 : tensor<*xi32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @tensor.from_elements_wrong_elements_count() {
|
|
// expected-error@+2 {{1 operands present, but expected 2}}
|
|
%c0 = arith.constant 0 : index
|
|
%0 = tensor.from_elements %c0 : tensor<2xindex>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @tensor.generate(%m : index)
|
|
-> tensor<?x3x?xf32> {
|
|
// expected-error @+1 {{must have as many index operands as dynamic extents in the result type}}
|
|
%tnsr = tensor.generate %m {
|
|
^bb0(%i : index, %j : index, %k : index):
|
|
%elem = arith.constant 8.0 : f32
|
|
tensor.yield %elem : f32
|
|
} : tensor<?x3x?xf32>
|
|
return %tnsr : tensor<?x3x?xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @tensor.generate(%m : index, %n : index)
|
|
-> tensor<?x3x?xf32> {
|
|
// expected-error @+1 {{must have one body argument per input dimension}}
|
|
%tnsr = tensor.generate %m, %n {
|
|
^bb0(%i : index, %j : index):
|
|
%elem = arith.constant 8.0 : f32
|
|
tensor.yield %elem : f32
|
|
} : tensor<?x3x?xf32>
|
|
return %tnsr : tensor<?x3x?xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @tensor.generate(%m : index, %n : index)
|
|
-> tensor<?x3x?xf32> {
|
|
// expected-error @+1 {{all body arguments must be index}}
|
|
%tnsr = tensor.generate %m, %n {
|
|
^bb0(%i : index, %j : index, %k : i64):
|
|
%elem = arith.constant 8.0 : f32
|
|
tensor.yield %elem : f32
|
|
} : tensor<?x3x?xf32>
|
|
return %tnsr : tensor<?x3x?xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @tensor.generate(%m : index, %n : index)
|
|
-> tensor<?x3x?xf32> {
|
|
// expected-error @+4 {{'func.return' op expects parent op 'func.func'}}
|
|
%tnsr = tensor.generate %m, %n {
|
|
^bb0(%i : index, %j : index, %k : index):
|
|
%elem = arith.constant 8.0 : f32
|
|
func.return %elem : f32
|
|
} : tensor<?x3x?xf32>
|
|
return %tnsr : tensor<?x3x?xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @tensor.generate(%m : index, %n : index)
|
|
-> tensor<?x3x?xf32> {
|
|
// expected-error @+1 {{body must be terminated with a `yield` operation of the tensor element type}}
|
|
%tnsr = tensor.generate %m, %n {
|
|
^bb0(%i : index, %j : index, %k : index):
|
|
%elem = arith.constant 8 : i32
|
|
tensor.yield %elem : i32
|
|
} : tensor<?x3x?xf32>
|
|
return %tnsr : tensor<?x3x?xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @tensor.reshape_element_type_mismatch(
|
|
%buf: tensor<*xf32>, %shape: tensor<1xi32>) {
|
|
// expected-error @+1 {{element types of source and destination tensor types should be the same}}
|
|
tensor.reshape %buf(%shape) : (tensor<*xf32>, tensor<1xi32>) -> tensor<?xi32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @tensor.reshape_dst_ranked_shape_unranked(
|
|
%buf: tensor<*xf32>, %shape: tensor<?xi32>) {
|
|
// expected-error @+1 {{cannot use shape operand with dynamic length to reshape to statically-ranked tensor type}}
|
|
tensor.reshape %buf(%shape) : (tensor<*xf32>, tensor<?xi32>) -> tensor<?xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @tensor.reshape_dst_shape_rank_mismatch(
|
|
%buf: tensor<*xf32>, %shape: tensor<1xi32>) {
|
|
// expected-error @+1 {{length of shape operand differs from the result's tensor rank}}
|
|
tensor.reshape %buf(%shape)
|
|
: (tensor<*xf32>, tensor<1xi32>) -> tensor<?x?xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @tensor.reshape_num_elements_mismatch(
|
|
%buf: tensor<1xf32>, %shape: tensor<1xi32>) {
|
|
// expected-error @+1 {{source and destination tensor should have the same number of elements}}
|
|
tensor.reshape %buf(%shape)
|
|
: (tensor<1xf32>, tensor<1xi32>) -> tensor<10xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @extract_slice_wrong_result_rank(%t: tensor<?xf32>, %idx : index) {
|
|
// expected-error @+1 {{expected rank to be smaller or equal to the other rank.}}
|
|
%0 = tensor.extract_slice %t[0][4][1] : tensor<?xf32> to tensor<?x?xf32>
|
|
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @extract_slice_wrong_result_rank(%t: tensor<?xf32>, %idx : index) {
|
|
// expected-error @+1 {{expected element type to be 'f32'}}
|
|
%0 = tensor.extract_slice %t[0][4][1] : tensor<?xf32> to tensor<4xi8>
|
|
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @extract_slice_wrong_static_type(%t: tensor<8x16x4xf32>, %idx : index) {
|
|
// expected-error @+1 {{expected type to be 'tensor<?x4x4xf32>' or a rank-reduced version. (size mismatch)}}
|
|
%0 = tensor.extract_slice %t[0, 0, 0][%idx, 4, 4][1, 1, 1]
|
|
: tensor<8x16x4xf32> to tensor<4x4x4xf32>
|
|
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @extract_slice_wrong_dynamic_type(%t: tensor<8x16x4xf32>, %idx : index) {
|
|
// expected-error @+1 {{expected type to be 'tensor<4x4x4xf32>' or a rank-reduced version. (size mismatch)}}
|
|
%0 = tensor.extract_slice %t[0, 2, 0][4, 4, 4][1, 1, 1]
|
|
: tensor<8x16x4xf32> to tensor<?x4x4xf32>
|
|
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @insert_slice_wrong_result_rank(%t1: tensor<?xf32>, %t2: tensor<?x?xf32>, %idx : index) {
|
|
// expected-error @+1 {{expected rank to be smaller or equal to the other rank.}}
|
|
%0 = tensor.insert_slice %t2 into %t1[0][4][1] : tensor<?x?xf32> into tensor<?xf32>
|
|
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @insert_slice_wrong_result_rank(%t1: tensor<4xi8>, %t2: tensor<?xf32>, %idx : index) {
|
|
// expected-error @+1 {{expected element type to be 'f32'}}
|
|
%0 = tensor.insert_slice %t1 into %t2[0][4][1] : tensor<4xi8> into tensor<?xf32>
|
|
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @insert_slice_wrong_static_type(%t1: tensor<4x4x4xf32>, %t2: tensor<8x16x4xf32>, %idx : index) {
|
|
// expected-error @+1 {{expected type to be 'tensor<?x4x4xf32>' or a rank-reduced version. (size mismatch)}}
|
|
%0 = tensor.insert_slice %t1 into %t2[0, 0, 0][%idx, 4, 4][1, 1, 1]
|
|
: tensor<4x4x4xf32> into tensor<8x16x4xf32>
|
|
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @insert_slice_wrong_dynamic_type(%t1: tensor<?x4x4xf32>, %t2: tensor<8x16x4xf32>, %idx : index) {
|
|
// expected-error @+1 {{expected type to be 'tensor<4x4x4xf32>' or a rank-reduced version. (size mismatch)}}
|
|
%0 = tensor.insert_slice %t1 into %t2[0, 2, 0][4, 4, 4][1, 1, 1]
|
|
: tensor<?x4x4xf32> into tensor<8x16x4xf32>
|
|
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @illegal_expanding_reshape_dynamic_tensor
|
|
(%arg0: tensor<?x?x?xf32>) -> tensor<?x?x?x4x?xf32> {
|
|
// expected-error @+1 {{invalid to have a single dimension (2) expanded into multiple dynamic dims (2,4)}}
|
|
%0 = tensor.expand_shape %arg0 [[0], [1], [2, 3, 4]]
|
|
: tensor<?x?x?xf32> into tensor<?x?x?x4x?xf32>
|
|
return %0 : tensor<?x?x?x4x?xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
|
|
func.func @illegal_expanding_reshape_static_tensor
|
|
(%arg0: tensor<2x3x20xf32>) -> tensor<2x3x2x4x5xf32> {
|
|
// expected-error @+1 {{expected dimension 2 of collapsed type to be static value of 40}}
|
|
%0 = tensor.expand_shape %arg0 [[0], [1], [2, 3, 4]]
|
|
: tensor<2x3x20xf32> into tensor<2x3x2x4x5xf32>
|
|
return %0 : tensor<2x3x2x4x5xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @illegal_collapsing_reshape_static_tensor
|
|
(%arg0: tensor<2x3x2x4x5xf32>) -> tensor<2x3x20xf32> {
|
|
// expected-error @+1 {{expected dimension 2 of collapsed type to be static value of 40}}
|
|
%0 = tensor.collapse_shape %arg0 [[0], [1], [2, 3, 4]]
|
|
: tensor<2x3x2x4x5xf32> into tensor<2x3x20xf32>
|
|
return %0 : tensor<2x3x20xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @illegal_expanding_reshape_mixed_tensor(%arg0 : tensor<?x?xf32>)
|
|
-> tensor<?x4x5xf32> {
|
|
// expected-error @+1 {{expected dimension 1 of collapsed type to be static value of 5}}
|
|
%0 = tensor.expand_shape %arg0 [[0, 1], [2]]
|
|
: tensor<?x?xf32> into tensor<?x4x5xf32>
|
|
return %0 : tensor<?x4x5xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @illegal_expanding_reshape_mixed_tensor_2(%arg0 : tensor<?x?xf32>)
|
|
-> tensor<?x4x5xf32> {
|
|
// expected-error @+1 {{expected dimension 1 of collapsed type to be static value of 20}}
|
|
%0 = tensor.expand_shape %arg0 [[0], [1, 2]]
|
|
: tensor<?x?xf32> into tensor<?x4x5xf32>
|
|
return %0 : tensor<?x4x5xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @illegal_collapsing_reshape_mixed_tensor(%arg0 : tensor<?x4x5xf32>) -> tensor<?x?xf32> {
|
|
// expected-error @+1 {{expected dimension 1 of collapsed type to be static value of 5}}
|
|
%0 = tensor.collapse_shape %arg0 [[0, 1], [2]]
|
|
: tensor<?x4x5xf32> into tensor<?x?xf32>
|
|
return %0 : tensor<?x?xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @illegal_collapsing_reshape_mixed_tensor_2(%arg0 : tensor<?x4x5xf32>)
|
|
-> tensor<?x?xf32> {
|
|
// expected-error @+1 {{expected dimension 1 of collapsed type to be static value of 20}}
|
|
%0 = tensor.collapse_shape %arg0 [[0], [1, 2]]
|
|
: tensor<?x4x5xf32> into tensor<?x?xf32>
|
|
return %0 : tensor<?x?xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @rank(%0: f32) {
|
|
// expected-error@+1 {{'tensor.rank' op operand #0 must be tensor of any type values}}
|
|
"tensor.rank"(%0): (f32)->index
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @illegal_num_offsets(%arg0 : tensor<?x?x?xf32>, %arg1 : index, %arg2 : index) {
|
|
// expected-error@+1 {{expected 3 offset values}}
|
|
%0 = tensor.extract_slice %arg0[0, 0] [%arg1, %arg2] [1, 1] : tensor<?x?x?xf32> to tensor<?x?x?xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @illegal_num_offsets(%arg0 : tensor<?x?xf32>, %arg1 : tensor<?x?x?xf32>,
|
|
%arg2 : index, %arg3 : index) {
|
|
// expected-error@+1 {{expected 3 offset values}}
|
|
%0 = tensor.insert_slice %arg0 into %arg1[0, 0] [%arg2, %arg3] [1, 1] : tensor<?x?xf32> into tensor<?x?x?xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
|
|
func.func @pad_result_type(%arg0: tensor<?x2x3x4xi32>, %arg1: index, %arg2: i32) -> tensor<?x?x?x8xf32> {
|
|
// expected-error @+1 {{specified type 'tensor<?x?x?x8xf32>' does not match the inferred type 'tensor<?x?x?x9xi32>}}
|
|
%0 = tensor.pad %arg0 low[1, %arg1, 2, 2] high[1, 2, %arg1, 3] {
|
|
^bb0(%arg3: index, %arg4: index):
|
|
tensor.yield %arg2 : i32
|
|
} : tensor<?x2x3x4xi32> to tensor<?x?x?x8xf32>
|
|
return %0 : tensor<?x?x?x8xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @pad_number_of_block_args(%arg0: tensor<?x4xi32>, %arg1: i32) -> tensor<?x9xi32> {
|
|
// expected-error @+1 {{expected the block to have 2 arguments}}
|
|
%0 = tensor.pad %arg0 low[1, 2] high[2, 3] {
|
|
^bb0(%arg2: index, %arg3: index, %arg4: index):
|
|
tensor.yield %arg1 : i32
|
|
} : tensor<?x4xi32> to tensor<?x9xi32>
|
|
return %0 : tensor<?x9xi32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @pad_block_args(%arg0: tensor<?x4xi32>, %arg1: i32) -> tensor<?x9xi32> {
|
|
// expected-error @+1 {{op expected block argument 1 to be an index}}
|
|
%0 = tensor.pad %arg0 low[1, 2] high[2, 3] {
|
|
^bb0(%arg2: i32, %arg3: i32):
|
|
tensor.yield %arg1 : i32
|
|
} : tensor<?x4xi32> to tensor<?x9xi32>
|
|
return %0 : tensor<?x9xi32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @pad_yield_type(%arg0: tensor<?x4xi32>, %arg1: i8) -> tensor<?x9xi32> {
|
|
// expected-error @+1 {{op expected yield type to match shape element type}}
|
|
%0 = tensor.pad %arg0 low[1, 2] high[2, 3] {
|
|
^bb0(%arg2: index, %arg3: index):
|
|
tensor.yield %arg1 : i8
|
|
} : tensor<?x4xi32> to tensor<?x9xi32>
|
|
return %0 : tensor<?x9xi32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @invalid_splat(%v : f32) {
|
|
// expected-error@+1 {{invalid kind of type specified}}
|
|
tensor.splat %v : memref<8xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @invalid_splat(%v : vector<8xf32>) {
|
|
// expected-error@+1 {{must be integer/index/float type}}
|
|
%w = tensor.splat %v : tensor<8xvector<8xf32>>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @invalid_splat(%v: f32, %m: index) {
|
|
// expected-error@+1 {{incorrect number of dynamic sizes, has 1, expected 2}}
|
|
%w = tensor.splat %v[%m] : tensor<?x8x?xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @gather_empty_dims(
|
|
%source : tensor<4x5x6xf32>, %indices: tensor<1x2x3xindex>) {
|
|
// expected-error@+1 {{gather_dims must be non-empty}}
|
|
%out = tensor.gather %source[%indices] gather_dims([]):
|
|
(tensor<4x5x6xf32>, tensor<1x2x3xindex>) -> tensor<1x2xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @gather_coordinate_rank_overflow(
|
|
%source : tensor<4x5x6xf32>, %indices: tensor<1x2x3xindex>) {
|
|
// expected-error@+1 {{gather_dims overflow source rank}}
|
|
%out = tensor.gather %source[%indices] gather_dims([0, 1, 2, 3]):
|
|
(tensor<4x5x6xf32>, tensor<1x2x3xindex>) -> tensor<1x2xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @gather_coordinate_negative(
|
|
%source : tensor<4x5x6xf32>, %indices: tensor<1x2x3xindex>) {
|
|
// expected-error@+1 {{gather_dims value must be non-negative}}
|
|
%out = tensor.gather %source[%indices] gather_dims([-1]):
|
|
(tensor<4x5x6xf32>, tensor<1x2x3xindex>) -> tensor<1x2x1x1x1xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @gather_coordinate_overflow(
|
|
%source : tensor<4x5x6xf32>, %indices: tensor<1x2x3xindex>) {
|
|
// expected-error@+1 {{gather_dims value must be smaller than source rank}}
|
|
%out = tensor.gather %source[%indices] gather_dims([42]):
|
|
(tensor<4x5x6xf32>, tensor<1x2x3xindex>) -> tensor<1x2x1x1x1xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @gather_coordinate_overflow(
|
|
%source : tensor<4x5x6xf32>, %indices: tensor<1x2x3xindex>) {
|
|
// expected-error@+1 {{gather_dims values must be strictly increasing}}
|
|
%out = tensor.gather %source[%indices] gather_dims([1, 0]):
|
|
(tensor<4x5x6xf32>, tensor<1x2x3xindex>) -> tensor<1x2x1x1x1xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @gather_wrong_result_type(
|
|
%source : tensor<4x5x6xf32>, %indices: tensor<1x2x3xindex>) {
|
|
// expected-error@+1 {{result type mismatch: expected 'tensor<1x2x1x5x1xf32>' or its rank-reduced variant 'tensor<1x2x5xf32>' (got: 'tensor<1x2x1xf32>')}}
|
|
%out = tensor.gather %source[%indices] gather_dims([0, 2]):
|
|
(tensor<4x5x6xf32>, tensor<1x2x3xindex>) -> tensor<1x2x1xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @scatter_empty_dims(
|
|
%source : tensor<f32>,
|
|
%dest : tensor<4x5x6xf32>, %indices: tensor<1x2x3xindex>) {
|
|
// expected-error@+1 {{scatter_dims must be non-empty}}
|
|
%out = tensor.scatter %source into %dest[%indices] scatter_dims([]) unique:
|
|
(tensor<f32>, tensor<4x5x6xf32>, tensor<1x2x3xindex>) -> tensor<1x2xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @scatter_coordinate_rank_overflow(
|
|
%source : tensor<f32>,
|
|
%dest : tensor<4x5x6xf32>, %indices: tensor<1x2x3xindex>) {
|
|
// expected-error@+1 {{scatter_dims overflow dest rank}}
|
|
%out = tensor.scatter %source into %dest[%indices] scatter_dims([0, 1, 2, 3]) unique:
|
|
(tensor<f32>, tensor<4x5x6xf32>, tensor<1x2x3xindex>) -> tensor<1x2xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @scatter_coordinate_negative(
|
|
%source : tensor<f32>,
|
|
%dest : tensor<4x5x6xf32>, %indices: tensor<1x2x3xindex>) {
|
|
// expected-error@+1 {{scatter_dims value must be non-negative}}
|
|
%out = tensor.scatter %source into %dest[%indices] scatter_dims([-1]) unique:
|
|
(tensor<f32>, tensor<4x5x6xf32>, tensor<1x2x3xindex>) -> tensor<1x2x1x1x1xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @scatter_coordinate_overflow(
|
|
%source : tensor<f32>,
|
|
%dest : tensor<4x5x6xf32>, %indices: tensor<1x2x3xindex>) {
|
|
// expected-error@+1 {{scatter_dims value must be smaller than dest rank}}
|
|
%out = tensor.scatter %source into %dest[%indices] scatter_dims([42]) unique:
|
|
(tensor<f32>, tensor<4x5x6xf32>, tensor<1x2x3xindex>) -> tensor<1x2x1x1x1xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @scatter_coordinate_overflow(
|
|
%source : tensor<f32>,
|
|
%dest : tensor<4x5x6xf32>, %indices: tensor<1x2x3xindex>) {
|
|
// expected-error@+1 {{scatter_dims values must be strictly increasing}}
|
|
%out = tensor.scatter %source into %dest[%indices] scatter_dims([1, 0]) unique:
|
|
(tensor<f32>, tensor<4x5x6xf32>, tensor<1x2x3xindex>) -> tensor<1x2x1x1x1xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @scatter_missing_unique(
|
|
%source : tensor<f32>,
|
|
%dest : tensor<4x5x6xf32>, %indices: tensor<1x2x3xindex>) {
|
|
// expected-error@+1 {{requires 'unique' attribute to be set}}
|
|
%out = tensor.scatter %source into %dest[%indices] scatter_dims([0, 2]):
|
|
(tensor<f32>, tensor<4x5x6xf32>, tensor<1x2x3xindex>) -> tensor<1x2x1xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @scatter_wrong_result_type(
|
|
%source : tensor<f32>,
|
|
%dest : tensor<4x5x6xf32>, %indices: tensor<1x2x3xindex>) {
|
|
// expected-error@+1 {{source type mismatch: expected 'tensor<1x2x1x5x1xf32>' or its rank-reduced variant 'tensor<1x2x5xf32>' (got: 'tensor<f32>')}}
|
|
%out = tensor.scatter %source into %dest[%indices] scatter_dims([0, 2]) unique:
|
|
(tensor<f32>, tensor<4x5x6xf32>, tensor<1x2x3xindex>) -> tensor<1x2x1xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @empty_wrong_number_of_operands(%sz : index) {
|
|
// expected-error@+1 {{incorrect number of dynamic sizes, has 1, expected 2}}
|
|
%out = tensor.empty(%sz) : tensor<2x?x?x5xf32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @pack_invalid_no_padding_no_full_tiles(%input: tensor<256x128xf32>, %output: tensor<8x8x16x33xf32>) -> tensor<8x8x16x33xf32> {
|
|
// expected-error@+1 {{invalid tile factor or output size provided. Only full tiles are supported when padding_value is not set}}
|
|
%0 = tensor.pack %input inner_dims_pos = [1, 0] inner_tiles = [16, 33] into %output : tensor<256x128xf32> -> tensor<8x8x16x33xf32>
|
|
return %0 : tensor<8x8x16x33xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @pack_invalid_no_padding_no_full_tiles_dyn_tiles(%input: tensor<256x128xf32>, %output: tensor<10x8x?x?xf32>, %tile_size_0: index, %tile_size_1: index) -> tensor<10x8x?x?xf32> {
|
|
// expected-error@+1 {{invalid tile factor or output size provided. Only full tiles are supported when padding_value is not set}}
|
|
%0 = tensor.pack %input inner_dims_pos = [1, 0] inner_tiles = [%tile_size_0, %tile_size_1] into %output : tensor<256x128xf32> -> tensor<10x8x?x?xf32>
|
|
return %0 : tensor<10x8x?x?xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @pack_invalid_no_padding_no_full_tiles_dyn_tiles_outperm(%input: tensor<256x128xf32>, %output: tensor<8x10x?x?xf32>, %tile_size_0: index, %tile_size_1: index) -> tensor<8x10x?x?xf32> {
|
|
// expected-error@+1 {{invalid tile factor or output size provided. Only full tiles are supported when padding_value is not set}}
|
|
%0 = tensor.pack %input outer_dims_perm = [1, 0] inner_dims_pos = [1, 0] inner_tiles = [%tile_size_0, %tile_size_1] into %output : tensor<256x128xf32> -> tensor<8x10x?x?xf32>
|
|
return %0 : tensor<8x10x?x?xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @pad_and_pack_invalid_type(%input: tensor<13x15xf32>, %output: tensor<2x8x8x2xf32>, %pad: i32) -> tensor<2x8x8x2xf32> {
|
|
// expected-error@+1 {{expected padding_value has 'f32' but got: 'i32'}}
|
|
%0 = tensor.pack %input padding_value(%pad: i32) inner_dims_pos = [0, 1] inner_tiles = [8, 2] into %output : tensor<13x15xf32> -> tensor<2x8x8x2xf32>
|
|
return %0 : tensor<2x8x8x2xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @pack_invalid_inner_dims_pos_vector(%input: tensor<256x128xf32>, %output: tensor<8x8x32x16xf32>) -> tensor<8x8x32x16xf32> {
|
|
// expected-error@+1 {{invalid inner_dims_pos vector}}
|
|
%0 = tensor.pack %input inner_dims_pos = [2, 0] inner_tiles = [2, 2] into %output : tensor<256x128xf32> -> tensor<8x8x32x16xf32>
|
|
return %0 : tensor<8x8x32x16xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @pack_invalid_duplicate_element_in_inner_dims(%input: tensor<256x128xf32>, %output: tensor<8x8x32x16xf32>) -> tensor<8x8x32x16xf32> {
|
|
// expected-error@+1 {{invalid inner_dims_pos vector}}
|
|
%0 = tensor.pack %input inner_dims_pos = [1, 1] inner_tiles = [2, 2] into %output : tensor<256x128xf32> -> tensor<8x8x32x16xf32>
|
|
return %0 : tensor<8x8x32x16xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @pack_invalid_duplicate_element_in_outer_perm(%input: tensor<256x128xf32>, %output: tensor<8x8x32x16xf32>) -> tensor<8x8x32x16xf32> {
|
|
// expected-error@+1 {{invalid outer_dims_perm vector}}
|
|
%0 = tensor.pack %input outer_dims_perm = [1, 1] inner_dims_pos = [0, 1] inner_tiles = [2, 2] into %output : tensor<256x128xf32> -> tensor<8x8x32x16xf32>
|
|
return %0 : tensor<8x8x32x16xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @unpack_invalid_out_of_bound_outer_perm(%input: tensor<256x128xf32>, %output: tensor<8x8x32x16xf32>) -> tensor<8x8x32x16xf32> {
|
|
// expected-error@+1 {{invalid outer_dims_perm vector}}
|
|
%0 = tensor.unpack %output outer_dims_perm = [2, 1] inner_dims_pos = [0, 1] inner_tiles = [2, 2] into %input : tensor<8x8x32x16xf32> -> tensor<256x128xf32>
|
|
return %0 : tensor<256x128xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @pack_invalid_outer_dims_perm(%source: tensor<128x256xf32>, %dest: tensor<16x4x32x16xf32>) -> tensor<16x4x32x16xf32> {
|
|
// expected-error@+1 {{outer_dims_perm must be a permutation or empty}}
|
|
%0 = tensor.pack %source outer_dims_perm = [0] inner_dims_pos = [0, 1] inner_tiles = [32, 16] into %dest : tensor<128x256xf32> -> tensor<16x4x32x16xf32>
|
|
return %0 : tensor<16x4x32x16xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @unpack_invalid_outer_dims_perm(%source: tensor<128x256xf32>, %dest: tensor<16x4x32x16xf32>) -> tensor<128x256xf32> {
|
|
// expected-error@+1 {{outer_dims_perm must be a permutation or empty}}
|
|
%0 = tensor.unpack %dest outer_dims_perm = [1] inner_dims_pos = [0, 1] inner_tiles = [32, 16] into %source : tensor<16x4x32x16xf32> -> tensor<128x256xf32>
|
|
return %0 : tensor<128x256xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @pack_invalid(%input: tensor<256x128xf32>, %output: tensor<8x8x32x16xf32>) -> tensor<8x8x32x16xf32> {
|
|
// expected-error@+1 {{the shape of output is not large enough to hold the packed data. Expected at least 'tensor<8x8x16x32xf32>', got 'tensor<8x8x32x16xf32>'}}
|
|
%0 = tensor.pack %input inner_dims_pos = [1, 0] inner_tiles = [16, 32] into %output : tensor<256x128xf32> -> tensor<8x8x32x16xf32>
|
|
return %0 : tensor<8x8x32x16xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @unpack_invalid(%output: tensor<256x128xf32>, %input: tensor<8x8x32x16xf32>) -> tensor<256x128xf32> {
|
|
// expected-error@+1 {{the shape of output is not large enough to hold the packed data. Expected at least 'tensor<8x32x4x32xf32>', got 'tensor<8x8x32x16xf32>'}}
|
|
%0 = tensor.unpack %input inner_dims_pos = [1, 0] inner_tiles = [4, 32] into %output : tensor<8x8x32x16xf32> -> tensor<256x128xf32>
|
|
return %0 : tensor<256x128xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @pack_invalid(%input: tensor<256x128xf32>, %output: tensor<8x8x32x16xf32>) -> tensor<8x8x32x16xf32> {
|
|
// expected-error@+1 {{invalid zero tile factor}}
|
|
%0 = tensor.pack %input inner_dims_pos = [1, 0] inner_tiles = [0, 2] into %output : tensor<256x128xf32> -> tensor<8x8x32x16xf32>
|
|
return %0 : tensor<8x8x32x16xf32>
|
|
}
|
|
|
|
// -----
|
|
func.func @pack_mismatch_inner_tile_size_and_output_shape(
|
|
%input : tensor<?x?xf32>, %output : tensor<?x?x8x8xf32>) -> tensor<?x?x8x8xf32> {
|
|
// expected-error@+1 {{mismatch in inner tile sizes specified and shaped of tiled dimension in the packed type}}
|
|
%0 = tensor.pack %input inner_dims_pos = [0, 1] inner_tiles = [8, 4] into %output : tensor<?x?xf32> -> tensor<?x?x8x8xf32>
|
|
return %0 : tensor<?x?x8x8xf32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func @unpack_mismatch_inner_tile_size_and_output_shape(
|
|
%input : tensor<?x?x8x8xf32>, %output : tensor<?x?xf32>) -> tensor<?x?xf32> {
|
|
// expected-error@+1 {{mismatch in inner tile sizes specified and shaped of tiled dimension in the packed type}}
|
|
%0 = tensor.unpack %input inner_dims_pos = [0, 1] inner_tiles = [8, 4] into %output : tensor<?x?x8x8xf32> -> tensor<?x?xf32>
|
|
return %0 : tensor<?x?xf32>
|
|
}
|