| // RUN: mlir-opt -split-input-file %s -verify-diagnostics |
| |
| func.func @test_index_cast_shape_error(%arg0 : tensor<index>) -> tensor<2xi64> { |
| // expected-error @+1 {{'arith.index_cast' op requires the same shape for all operands and results}} |
| %0 = arith.index_cast %arg0 : tensor<index> to tensor<2xi64> |
| return %0 : tensor<2xi64> |
| } |
| |
| // ----- |
| |
| func.func @test_index_cast_tensor_error(%arg0 : tensor<index>) -> i64 { |
| // expected-error @+1 {{'arith.index_cast' op requires the same shape for all operands and results}} |
| %0 = arith.index_cast %arg0 : tensor<index> to i64 |
| return %0 : i64 |
| } |
| |
| // ----- |
| |
| func.func @non_signless_constant() { |
| // expected-error @+1 {{'arith.constant' op integer return type must be signless}} |
| %0 = arith.constant 0 : ui32 |
| return |
| } |
| |
| // ----- |
| |
| func.func @complex_constant_wrong_attribute_type() { |
| // expected-error @+1 {{'arith.constant' op failed to verify that all of {value, result} have same type}} |
| %0 = "arith.constant" () {value = 1.0 : f32} : () -> complex<f32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @non_signless_constant() { |
| // expected-error @+1 {{'arith.constant' op integer return type must be signless}} |
| %0 = arith.constant 0 : si32 |
| return |
| } |
| |
| // ----- |
| |
| func.func @bitcast_different_bit_widths(%arg : f16) -> f32 { |
| // expected-error@+1 {{are cast incompatible}} |
| %res = arith.bitcast %arg : f16 to f32 |
| return %res : f32 |
| } |
| |
| // ----- |
| |
| func.func @constant() { |
| ^bb: |
| %x = "arith.constant"(){value = "xyz"} : () -> i32 // expected-error {{'arith.constant' op failed to verify that all of {value, result} have same type}} |
| return |
| } |
| |
| // ----- |
| |
| func.func @constant_out_of_range() { |
| ^bb: |
| %x = "arith.constant"(){value = 100} : () -> i1 // expected-error {{'arith.constant' op failed to verify that all of {value, result} have same type}} |
| return |
| } |
| |
| // ----- |
| |
| func.func @constant_wrong_type() { |
| ^bb: |
| %x = "arith.constant"(){value = 10.} : () -> f32 // expected-error {{'arith.constant' op failed to verify that all of {value, result} have same type}} |
| return |
| } |
| |
| // ----- |
| |
| func.func @intlimit2() { |
| ^bb: |
| %0 = "arith.constant"() {value = 0} : () -> i16777215 |
| %1 = "arith.constant"() {value = 1} : () -> i16777216 // expected-error {{integer bitwidth is limited to 16777215 bits}} |
| return |
| } |
| |
| // ----- |
| |
| func.func @func_with_ops(f32) { |
| ^bb0(%a : f32): |
| %sf = arith.addf %a, %a, %a : f32 // expected-error {{expected ':'}} |
| } |
| |
| // ----- |
| |
| func.func @func_with_ops(f32) { |
| ^bb0(%a : f32): |
| %sf = arith.addf(%a, %a) : f32 // expected-error {{expected SSA operand}} |
| } |
| |
| // ----- |
| |
| func.func @func_with_ops(f32) { |
| ^bb0(%a : f32): |
| %sf = arith.addf{%a, %a} : f32 // expected-error {{expected SSA operand}} |
| } |
| |
| // ----- |
| |
| func.func @func_with_ops(f32) { |
| ^bb0(%a : f32): |
| // expected-error@+1 {{'arith.addi' op operand #0 must be signless-integer-like}} |
| %sf = arith.addi %a, %a : f32 |
| } |
| |
| // ----- |
| |
| func.func @func_with_ops(%a: f32) { |
| // expected-error@+1 {{'arith.addui_extended' op operand #0 must be signless-integer-like}} |
| %r:2 = arith.addui_extended %a, %a : f32, i32 |
| return |
| } |
| |
| // ----- |
| |
| func.func @func_with_ops(%a: i32) { |
| // expected-error@+1 {{'arith.addui_extended' op result #1 must be bool-like}} |
| %r:2 = arith.addui_extended %a, %a : i32, i32 |
| return |
| } |
| |
| // ----- |
| |
| func.func @func_with_ops(%a: vector<8xi32>) { |
| // expected-error@+1 {{'arith.addui_extended' op if an operand is non-scalar, then all results must be non-scalar}} |
| %r:2 = arith.addui_extended %a, %a : vector<8xi32>, i1 |
| return |
| } |
| |
| // ----- |
| |
| func.func @func_with_ops(%a: vector<8xi32>) { |
| // expected-error@+1 {{'arith.addui_extended' op all non-scalar operands/results must have the same shape and base type}} |
| %r:2 = arith.addui_extended %a, %a : vector<8xi32>, tensor<8xi1> |
| return |
| } |
| |
| // ----- |
| |
| func.func @func_with_ops(i32) { |
| ^bb0(%a : i32): |
| %sf = arith.addf %a, %a : i32 // expected-error {{'arith.addf' op operand #0 must be floating-point-like}} |
| } |
| |
| // ----- |
| |
| func.func @func_with_ops(i32) { |
| ^bb0(%a : i32): |
| // expected-error@+1 {{failed to satisfy constraint: allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}} |
| %r = "arith.cmpi"(%a, %a) {predicate = 42} : (i32, i32) -> i1 |
| } |
| |
| // ----- |
| |
| // Comparison are defined for arguments of the same type. |
| func.func @func_with_ops(i32, i64) { |
| ^bb0(%a : i32, %b : i64): // expected-note {{prior use here}} |
| %r = arith.cmpi eq, %a, %b : i32 // expected-error {{use of value '%b' expects different type than prior uses}} |
| } |
| |
| // ----- |
| |
| // Comparisons must have the "predicate" attribute. |
| func.func @func_with_ops(i32, i32) { |
| ^bb0(%a : i32, %b : i32): |
| %r = arith.cmpi %a, %b : i32 // expected-error {{expected string or keyword containing one of the following enum values}} |
| } |
| |
| // ----- |
| |
| // Integer comparisons are not recognized for float types. |
| func.func @func_with_ops(f32, f32) { |
| ^bb0(%a : f32, %b : f32): |
| %r = arith.cmpi eq, %a, %b : f32 // expected-error {{'lhs' must be signless-integer-like, but got 'f32'}} |
| } |
| |
| // ----- |
| |
| // Result type must be boolean like. |
| func.func @func_with_ops(i32, i32) { |
| ^bb0(%a : i32, %b : i32): |
| %r = "arith.cmpi"(%a, %b) {predicate = 0} : (i32, i32) -> i32 // expected-error {{op result #0 must be bool-like}} |
| } |
| |
| // ----- |
| |
| func.func @func_with_ops(i32, i32) { |
| ^bb0(%a : i32, %b : i32): |
| // expected-error@+1 {{requires attribute 'predicate'}} |
| %r = "arith.cmpi"(%a, %b) {foo = 1} : (i32, i32) -> i1 |
| } |
| |
| // ----- |
| |
| func.func @func_with_ops() { |
| ^bb0: |
| %c = arith.constant dense<0> : vector<42 x i32> |
| // expected-error@+1 {{op failed to verify that result type has i1 element type and same shape as operands}} |
| %r = "arith.cmpi"(%c, %c) {predicate = 0} : (vector<42 x i32>, vector<42 x i32>) -> vector<41 x i1> |
| } |
| |
| // ----- |
| |
| func.func @func_with_ops() { |
| ^bb0: |
| %c = arith.constant dense<0> : tensor<42 x i32, "foo"> |
| // expected-error@+1 {{op failed to verify that result type has i1 element type and same shape as operands}} |
| %r = "arith.cmpi"(%c, %c) {predicate = 0} : (tensor<42 x i32, "foo">, tensor<42 x i32, "foo">) -> tensor<42 x i1, "bar"> |
| } |
| |
| // ----- |
| |
| func.func @invalid_cmp_shape(%idx : () -> ()) { |
| // expected-error@+1 {{'lhs' must be signless-integer-like, but got '() -> ()'}} |
| %cmp = arith.cmpi eq, %idx, %idx : () -> () |
| |
| // ----- |
| |
| func.func @invalid_cmp_attr(%idx : i32) { |
| // expected-error@+1 {{expected string or keyword containing one of the following enum values}} |
| %cmp = arith.cmpi i1, %idx, %idx : i32 |
| |
| // ----- |
| |
| func.func @cmpf_generic_invalid_predicate_value(%a : f32) { |
| // expected-error@+1 {{attribute 'predicate' failed to satisfy constraint: allowed 64-bit signless integer cases}} |
| %r = "arith.cmpf"(%a, %a) {predicate = 42} : (f32, f32) -> i1 |
| } |
| |
| // ----- |
| |
| func.func @cmpf_canonical_invalid_predicate_value(%a : f32) { |
| // expected-error@+1 {{expected string or keyword containing one of the following enum values}} |
| %r = arith.cmpf foo, %a, %a : f32 |
| } |
| |
| // ----- |
| |
| func.func @cmpf_canonical_invalid_predicate_value_signed(%a : f32) { |
| // expected-error@+1 {{expected string or keyword containing one of the following enum values}} |
| %r = arith.cmpf sge, %a, %a : f32 |
| } |
| |
| // ----- |
| |
| func.func @cmpf_canonical_invalid_predicate_value_no_order(%a : f32) { |
| // expected-error@+1 {{expected string or keyword containing one of the following enum values}} |
| %r = arith.cmpf eq, %a, %a : f32 |
| } |
| |
| // ----- |
| |
| func.func @cmpf_canonical_no_predicate_attr(%a : f32, %b : f32) { |
| %r = arith.cmpf %a, %b : f32 // expected-error {{}} |
| } |
| |
| // ----- |
| |
| func.func @cmpf_generic_no_predicate_attr(%a : f32, %b : f32) { |
| // expected-error@+1 {{requires attribute 'predicate'}} |
| %r = "arith.cmpf"(%a, %b) {foo = 1} : (f32, f32) -> i1 |
| } |
| |
| // ----- |
| |
| func.func @cmpf_wrong_type(%a : i32, %b : i32) { |
| %r = arith.cmpf oeq, %a, %b : i32 // expected-error {{must be floating-point-like}} |
| } |
| |
| // ----- |
| |
| func.func @cmpf_generic_wrong_result_type(%a : f32, %b : f32) { |
| // expected-error@+1 {{result #0 must be bool-like}} |
| %r = "arith.cmpf"(%a, %b) {predicate = 0} : (f32, f32) -> f32 |
| } |
| |
| // ----- |
| |
| func.func @cmpf_canonical_wrong_result_type(%a : f32, %b : f32) -> f32 { |
| %r = arith.cmpf oeq, %a, %b : f32 // expected-note {{prior use here}} |
| // expected-error@+1 {{use of value '%r' expects different type than prior uses}} |
| return %r : f32 |
| } |
| |
| // ----- |
| |
| func.func @cmpf_result_shape_mismatch(%a : vector<42xf32>) { |
| // expected-error@+1 {{op failed to verify that result type has i1 element type and same shape as operands}} |
| %r = "arith.cmpf"(%a, %a) {predicate = 0} : (vector<42 x f32>, vector<42 x f32>) -> vector<41 x i1> |
| } |
| |
| // ----- |
| |
| func.func @cmpf_operand_shape_mismatch(%a : vector<42xf32>, %b : vector<41xf32>) { |
| // expected-error@+1 {{op requires all operands to have the same type}} |
| %r = "arith.cmpf"(%a, %b) {predicate = 0} : (vector<42 x f32>, vector<41 x f32>) -> vector<42 x i1> |
| } |
| |
| // ----- |
| |
| func.func @cmpf_generic_operand_type_mismatch(%a : f32, %b : f64) { |
| // expected-error@+1 {{op requires all operands to have the same type}} |
| %r = "arith.cmpf"(%a, %b) {predicate = 0} : (f32, f64) -> i1 |
| } |
| |
| // ----- |
| |
| func.func @cmpf_canonical_type_mismatch(%a : f32, %b : f64) { // expected-note {{prior use here}} |
| // expected-error@+1 {{use of value '%b' expects different type than prior uses}} |
| %r = arith.cmpf oeq, %a, %b : f32 |
| } |
| |
| // ----- |
| |
| func.func @index_cast_index_to_index(%arg0: index) { |
| // expected-error@+1 {{are cast incompatible}} |
| %0 = arith.index_cast %arg0: index to index |
| return |
| } |
| |
| // ----- |
| |
| func.func @index_cast_float(%arg0: index, %arg1: f32) { |
| // expected-error@+1 {{op result #0 must be signless-integer-like or memref of signless-integer, but got 'f32'}} |
| %0 = arith.index_cast %arg0 : index to f32 |
| return |
| } |
| |
| // ----- |
| |
| func.func @index_cast_float_to_index(%arg0: f32) { |
| // expected-error@+1 {{op operand #0 must be signless-integer-like or memref of signless-integer, but got 'f32'}} |
| %0 = arith.index_cast %arg0 : f32 to index |
| return |
| } |
| |
| // ----- |
| |
| func.func @sitofp_i32_to_i64(%arg0 : i32) { |
| // expected-error@+1 {{op result #0 must be floating-point-like, but got 'i64'}} |
| %0 = arith.sitofp %arg0 : i32 to i64 |
| return |
| } |
| |
| // ----- |
| |
| func.func @sitofp_f32_to_i32(%arg0 : f32) { |
| // expected-error@+1 {{op operand #0 must be signless-fixed-width-integer-like, but got 'f32'}} |
| %0 = arith.sitofp %arg0 : f32 to i32 |
| return |
| } |
| |
| // ----- |
| |
| func.func @fpext_f32_to_f16(%arg0 : f32) { |
| // expected-error@+1 {{are cast incompatible}} |
| %0 = arith.extf %arg0 : f32 to f16 |
| return |
| } |
| |
| // ----- |
| |
| func.func @fpext_f16_to_f16(%arg0 : f16) { |
| // expected-error@+1 {{are cast incompatible}} |
| %0 = arith.extf %arg0 : f16 to f16 |
| return |
| } |
| |
| // ----- |
| |
| func.func @fpext_i32_to_f32(%arg0 : i32) { |
| // expected-error@+1 {{op operand #0 must be floating-point-like, but got 'i32'}} |
| %0 = arith.extf %arg0 : i32 to f32 |
| return |
| } |
| |
| // ----- |
| |
| func.func @fpext_f32_to_i32(%arg0 : f32) { |
| // expected-error@+1 {{op result #0 must be floating-point-like, but got 'i32'}} |
| %0 = arith.extf %arg0 : f32 to i32 |
| return |
| } |
| |
| // ----- |
| |
| func.func @fpext_vec(%arg0 : vector<2xf16>) { |
| // expected-error@+1 {{op requires the same shape for all operands and results}} |
| %0 = arith.extf %arg0 : vector<2xf16> to vector<3xf32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @fpext_vec_f32_to_f16(%arg0 : vector<2xf32>) { |
| // expected-error@+1 {{are cast incompatible}} |
| %0 = arith.extf %arg0 : vector<2xf32> to vector<2xf16> |
| return |
| } |
| |
| // ----- |
| |
| func.func @fpext_vec_f16_to_f16(%arg0 : vector<2xf16>) { |
| // expected-error@+1 {{are cast incompatible}} |
| %0 = arith.extf %arg0 : vector<2xf16> to vector<2xf16> |
| return |
| } |
| |
| // ----- |
| |
| func.func @fpext_vec_i32_to_f32(%arg0 : vector<2xi32>) { |
| // expected-error@+1 {{op operand #0 must be floating-point-like, but got 'vector<2xi32>'}} |
| %0 = arith.extf %arg0 : vector<2xi32> to vector<2xf32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @fpext_vec_f32_to_i32(%arg0 : vector<2xf32>) { |
| // expected-error@+1 {{op result #0 must be floating-point-like, but got 'vector<2xi32>'}} |
| %0 = arith.extf %arg0 : vector<2xf32> to vector<2xi32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @fpext_vec_f32_to_i32(%arg0 : tensor<2xf32, "foo">) { |
| // expected-error@+1 {{op operand type 'tensor<2xf32, "foo">' and result type 'tensor<2xf64, "bar">' are cast incompatible}} |
| %0 = arith.extf %arg0 : tensor<2xf32, "foo"> to tensor<2xf64, "bar"> |
| return |
| } |
| |
| // ----- |
| |
| func.func @fptrunc_f16_to_f32(%arg0 : f16) { |
| // expected-error@+1 {{are cast incompatible}} |
| %0 = arith.truncf %arg0 : f16 to f32 |
| return |
| } |
| |
| // ----- |
| |
| func.func @fptrunc_f32_to_f32(%arg0 : f32) { |
| // expected-error@+1 {{are cast incompatible}} |
| %0 = arith.truncf %arg0 : f32 to f32 |
| return |
| } |
| |
| // ----- |
| |
| func.func @fptrunc_i32_to_f32(%arg0 : i32) { |
| // expected-error@+1 {{op operand #0 must be floating-point-like, but got 'i32'}} |
| %0 = arith.truncf %arg0 : i32 to f32 |
| return |
| } |
| |
| // ----- |
| |
| func.func @fptrunc_f32_to_i32(%arg0 : f32) { |
| // expected-error@+1 {{op result #0 must be floating-point-like, but got 'i32'}} |
| %0 = arith.truncf %arg0 : f32 to i32 |
| return |
| } |
| |
| // ----- |
| |
| func.func @fptrunc_vec(%arg0 : vector<2xf16>) { |
| // expected-error@+1 {{op requires the same shape for all operands and results}} |
| %0 = arith.truncf %arg0 : vector<2xf16> to vector<3xf32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @fptrunc_vec_f16_to_f32(%arg0 : vector<2xf16>) { |
| // expected-error@+1 {{are cast incompatible}} |
| %0 = arith.truncf %arg0 : vector<2xf16> to vector<2xf32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @fptrunc_vec_f32_to_f32(%arg0 : vector<2xf32>) { |
| // expected-error@+1 {{are cast incompatible}} |
| %0 = arith.truncf %arg0 : vector<2xf32> to vector<2xf32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @fptrunc_vec_i32_to_f32(%arg0 : vector<2xi32>) { |
| // expected-error@+1 {{op operand #0 must be floating-point-like, but got 'vector<2xi32>'}} |
| %0 = arith.truncf %arg0 : vector<2xi32> to vector<2xf32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @fptrunc_vec_f32_to_i32(%arg0 : vector<2xf32>) { |
| // expected-error@+1 {{op result #0 must be floating-point-like, but got 'vector<2xi32>'}} |
| %0 = arith.truncf %arg0 : vector<2xf32> to vector<2xi32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @sexti_index_as_operand(%arg0 : index) { |
| // expected-error@+1 {{op operand #0 must be signless-fixed-width-integer-like, but got 'index'}} |
| %0 = arith.extsi %arg0 : index to i128 |
| return |
| } |
| |
| // ----- |
| |
| func.func @zexti_index_as_operand(%arg0 : index) { |
| // expected-error@+1 {{op operand #0 must be signless-fixed-width-integer-like, but got 'index'}} |
| %0 = arith.extui %arg0 : index to i128 |
| return |
| } |
| |
| // ----- |
| |
| func.func @trunci_index_as_operand(%arg0 : index) { |
| // expected-error@+1 {{op operand #0 must be signless-fixed-width-integer-like, but got 'index'}} |
| %2 = arith.trunci %arg0 : index to i128 |
| return |
| } |
| |
| // ----- |
| |
| func.func @sexti_index_as_result(%arg0 : i1) { |
| // expected-error@+1 {{op result #0 must be signless-fixed-width-integer-like, but got 'index'}} |
| %0 = arith.extsi %arg0 : i1 to index |
| return |
| } |
| |
| // ----- |
| |
| func.func @zexti_index_as_operand(%arg0 : i1) { |
| // expected-error@+1 {{op result #0 must be signless-fixed-width-integer-like, but got 'index'}} |
| %0 = arith.extui %arg0 : i1 to index |
| return |
| } |
| |
| // ----- |
| |
| func.func @trunci_index_as_result(%arg0 : i128) { |
| // expected-error@+1 {{op result #0 must be signless-fixed-width-integer-like, but got 'index'}} |
| %2 = arith.trunci %arg0 : i128 to index |
| return |
| } |
| |
| // ----- |
| |
| func.func @sexti_cast_to_narrower(%arg0 : i16) { |
| // expected-error@+1 {{are cast incompatible}} |
| %0 = arith.extsi %arg0 : i16 to i15 |
| return |
| } |
| |
| // ----- |
| |
| func.func @zexti_cast_to_narrower(%arg0 : i16) { |
| // expected-error@+1 {{are cast incompatible}} |
| %0 = arith.extui %arg0 : i16 to i15 |
| return |
| } |
| |
| // ----- |
| |
| func.func @trunci_cast_to_wider(%arg0 : i16) { |
| // expected-error@+1 {{are cast incompatible}} |
| %0 = arith.trunci %arg0 : i16 to i17 |
| return |
| } |
| |
| // ----- |
| |
| func.func @sexti_cast_to_same_width(%arg0 : i16) { |
| // expected-error@+1 {{are cast incompatible}} |
| %0 = arith.extsi %arg0 : i16 to i16 |
| return |
| } |
| |
| // ----- |
| |
| func.func @zexti_cast_to_same_width(%arg0 : i16) { |
| // expected-error@+1 {{are cast incompatible}} |
| %0 = arith.extui %arg0 : i16 to i16 |
| return |
| } |
| |
| // ----- |
| |
| func.func @trunci_cast_to_same_width(%arg0 : i16) { |
| // expected-error@+1 {{are cast incompatible}} |
| %0 = arith.trunci %arg0 : i16 to i16 |
| return |
| } |
| |
| // ----- |
| |
| func.func @trunci_scalable_to_fl(%arg0 : vector<[4]xi32>) { |
| // expected-error@+1 {{'arith.trunci' op requires the same shape for all operands and results}} |
| %0 = arith.trunci %arg0 : vector<[4]xi32> to vector<4xi8> |
| return |
| } |
| |
| // ----- |
| |
| func.func @truncf_scalable_to_fl(%arg0 : vector<[4]xf64>) { |
| // expected-error@+1 {{'arith.truncf' op requires the same shape for all operands and results}} |
| %0 = arith.truncf %arg0 : vector<[4]xf64> to vector<4xf32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @extui_scalable_to_fl(%arg0 : vector<[4]xi32>) { |
| // expected-error@+1 {{'arith.extui' op requires the same shape for all operands and results}} |
| %0 = arith.extui %arg0 : vector<[4]xi32> to vector<4xi64> |
| return |
| } |
| |
| // ----- |
| |
| func.func @extsi_scalable_to_fl(%arg0 : vector<[4]xi32>) { |
| // expected-error@+1 {{'arith.extsi' op requires the same shape for all operands and results}} |
| %0 = arith.extsi %arg0 : vector<[4]xi32> to vector<4xi64> |
| return |
| } |
| |
| // ----- |
| |
| func.func @extf_scalable_to_fl(%arg0 : vector<[4]xf32>) { |
| // expected-error@+1 {{'arith.extf' op requires the same shape for all operands and results}} |
| %0 = arith.extf %arg0 : vector<[4]xf32> to vector<4xf64> |
| return |
| } |
| |
| // ----- |
| |
| func.func @fptoui_scalable_to_fl(%arg0 : vector<[4]xf64>) { |
| // expected-error@+1 {{'arith.fptoui' op requires the same shape for all operands and results}} |
| %0 = arith.fptoui %arg0 : vector<[4]xf64> to vector<4xi32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @fptosi_scalable_to_fl(%arg0 : vector<[4]xf32>) { |
| // expected-error@+1 {{'arith.fptosi' op requires the same shape for all operands and results}} |
| %0 = arith.fptosi %arg0 : vector<[4]xf32> to vector<4xi32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @uitofp_scalable_to_fl(%arg0 : vector<[4]xi32>) { |
| // expected-error@+1 {{'arith.uitofp' op requires the same shape for all operands and results}} |
| %0 = arith.uitofp %arg0 : vector<[4]xi32> to vector<4xf32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @sitofp_scalable_to_fl(%arg0 : vector<[4]xi32>) { |
| // expected-error@+1 {{'arith.sitofp' op requires the same shape for all operands and results}} |
| %0 = arith.sitofp %arg0 : vector<[4]xi32> to vector<4xf32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @bitcast_scalable_to_fl(%arg0 : vector<[4]xf32>) { |
| // expected-error@+1 {{'arith.bitcast' op requires the same shape for all operands and results}} |
| %0 = arith.bitcast %arg0 : vector<[4]xf32> to vector<4xi32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @trunci_fl_to_scalable(%arg0 : vector<4xi32>) { |
| // expected-error@+1 {{'arith.trunci' op requires the same shape for all operands and results}} |
| %0 = arith.trunci %arg0 : vector<4xi32> to vector<[4]xi8> |
| return |
| } |
| |
| // ----- |
| |
| func.func @truncf_fl_to_scalable(%arg0 : vector<4xf64>) { |
| // expected-error@+1 {{'arith.truncf' op requires the same shape for all operands and results}} |
| %0 = arith.truncf %arg0 : vector<4xf64> to vector<[4]xf32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @extui_fl_to_scalable(%arg0 : vector<4xi32>) { |
| // expected-error@+1 {{'arith.extui' op requires the same shape for all operands and results}} |
| %0 = arith.extui %arg0 : vector<4xi32> to vector<[4]xi64> |
| return |
| } |
| |
| // ----- |
| |
| func.func @extsi_fl_to_scalable(%arg0 : vector<4xi32>) { |
| // expected-error@+1 {{'arith.extsi' op requires the same shape for all operands and results}} |
| %0 = arith.extsi %arg0 : vector<4xi32> to vector<[4]xi64> |
| return |
| } |
| |
| // ----- |
| |
| func.func @extf_fl_to_scalable(%arg0 : vector<4xf32>) { |
| // expected-error@+1 {{'arith.extf' op requires the same shape for all operands and results}} |
| %0 = arith.extf %arg0 : vector<4xf32> to vector<[4]xf64> |
| return |
| } |
| |
| // ----- |
| |
| func.func @fptoui_fl_to_scalable(%arg0 : vector<4xf64>) { |
| // expected-error@+1 {{'arith.fptoui' op requires the same shape for all operands and results}} |
| %0 = arith.fptoui %arg0 : vector<4xf64> to vector<[4]xi32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @fptosi_fl_to_scalable(%arg0 : vector<4xf32>) { |
| // expected-error@+1 {{'arith.fptosi' op requires the same shape for all operands and results}} |
| %0 = arith.fptosi %arg0 : vector<4xf32> to vector<[4]xi32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @uitofp_fl_to_scalable(%arg0 : vector<4xi32>) { |
| // expected-error@+1 {{'arith.uitofp' op requires the same shape for all operands and results}} |
| %0 = arith.uitofp %arg0 : vector<4xi32> to vector<[4]xf32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @sitofp_fl_to_scalable(%arg0 : vector<4xi32>) { |
| // expected-error@+1 {{'arith.sitofp' op requires the same shape for all operands and results}} |
| %0 = arith.sitofp %arg0 : vector<4xi32> to vector<[4]xf32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @bitcast_fl_to_scalable(%arg0 : vector<4xf32>) { |
| // expected-error@+1 {{'arith.bitcast' op requires the same shape for all operands and results}} |
| %0 = arith.bitcast %arg0 : vector<4xf32> to vector<[4]xi32> |
| return |
| } |
| |
| // ----- |
| |
| func.func @func() { |
| %c0 = arith.constant // expected-error {{expected attribute value}} |
| |
| %x = arith.constant 1 : i32 |
| } |
| |
| // ----- |
| |
| func.func @disallow_zero_rank_tensor_with_ranked_tensor(%arg0 : tensor<i1>, %arg1 : tensor<2xi64>, %arg2 : tensor<2xi64>) -> tensor<2xi64> { |
| // expected-error @+1 {{'arith.select' op failed to verify that condition is scalar or has matching shape}} |
| %0 = arith.select %arg0, %arg1, %arg2 : tensor<i1>, tensor<2xi64> |
| return %0 : tensor<2xi64> |
| } |
| |
| // ----- |
| |
| func.func @disallow_zero_rank_tensor_with_unranked_tensor(%arg0 : tensor<i1>, %arg1 : tensor<2x?xi64>, %arg2 : tensor<2x?xi64>) -> tensor<2x?xi64> { |
| // expected-error @+1 {{'arith.select' op failed to verify that condition is scalar or has matching shape}} |
| %0 = arith.select %arg0, %arg1, %arg2 : tensor<i1>, tensor<2x?xi64> |
| return %0 : tensor<2x?xi64> |
| } |
| |
| // ----- |
| |
| func.func @select_tensor_encoding( |
| %arg0 : tensor<8xi1, "bar">, %arg1 : tensor<8xi32, "foo">, %arg2 : tensor<8xi32, "foo">) -> tensor<8xi32, "foo"> { |
| // expected-error @+1 {{'arith.select' op expected condition type to have the same shape as the result type}} |
| %0 = arith.select %arg0, %arg1, %arg2 : tensor<8xi1, "bar">, tensor<8xi32, "foo"> |
| return %0 : tensor<8xi32, "foo"> |
| } |
