337 lines · plain
1// RUN: mlir-opt --split-input-file --verify-diagnostics %s | FileCheck %s2// RUN: mlir-opt --split-input-file --verify-diagnostics --canonicalize %s \3// RUN: | FileCheck %s --check-prefix=CANON4 5//===----------------------------------------------------------------------===//6// spirv.BitCount7//===----------------------------------------------------------------------===//8 9func.func @bitcount(%arg: i32) -> i32 {10 // CHECK: spirv.BitCount {{%.*}} : i3211 %0 = spirv.BitCount %arg : i3212 spirv.ReturnValue %0 : i3213}14 15// -----16 17//===----------------------------------------------------------------------===//18// spirv.BitFieldInsert19//===----------------------------------------------------------------------===//20 21func.func @bit_field_insert_vec(%base: vector<3xi32>, %insert: vector<3xi32>, %offset: i32, %count: i16) -> vector<3xi32> {22 // CHECK: {{%.*}} = spirv.BitFieldInsert {{%.*}}, {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi32>, i32, i1623 %0 = spirv.BitFieldInsert %base, %insert, %offset, %count : vector<3xi32>, i32, i1624 spirv.ReturnValue %0 : vector<3xi32>25}26 27// -----28 29func.func @bit_field_insert_invalid_insert_type(%base: vector<3xi32>, %insert: vector<2xi32>, %offset: i32, %count: i16) -> vector<3xi32> {30 // TODO: expand post change in verification order. This is currently only31 // verifying that the type verification is failing but not the specific error32 // message. In final state the error should refer to mismatch in base and33 // insert.34 // expected-error @+1 {{type}}35 %0 = "spirv.BitFieldInsert" (%base, %insert, %offset, %count) : (vector<3xi32>, vector<2xi32>, i32, i16) -> vector<3xi32>36 spirv.ReturnValue %0 : vector<3xi32>37}38 39// -----40 41//===----------------------------------------------------------------------===//42// spirv.BitFieldSExtract43//===----------------------------------------------------------------------===//44 45func.func @bit_field_s_extract_vec(%base: vector<3xi32>, %offset: i8, %count: i8) -> vector<3xi32> {46 // CHECK: {{%.*}} = spirv.BitFieldSExtract {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi32>, i8, i847 %0 = spirv.BitFieldSExtract %base, %offset, %count : vector<3xi32>, i8, i848 spirv.ReturnValue %0 : vector<3xi32>49}50 51//===----------------------------------------------------------------------===//52// spirv.BitFieldUExtract53//===----------------------------------------------------------------------===//54 55func.func @bit_field_u_extract_vec(%base: vector<3xi32>, %offset: i8, %count: i8) -> vector<3xi32> {56 // CHECK: {{%.*}} = spirv.BitFieldUExtract {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi32>, i8, i857 %0 = spirv.BitFieldUExtract %base, %offset, %count : vector<3xi32>, i8, i858 spirv.ReturnValue %0 : vector<3xi32>59}60 61// -----62 63func.func @bit_field_u_extract_invalid_result_type(%base: vector<3xi32>, %offset: i32, %count: i16) -> vector<4xi32> {64 // expected-error @+1 {{failed to verify that all of {base, result} have same type}}65 %0 = "spirv.BitFieldUExtract" (%base, %offset, %count) : (vector<3xi32>, i32, i16) -> vector<4xi32>66 spirv.ReturnValue %0 : vector<4xi32>67}68 69// -----70 71//===----------------------------------------------------------------------===//72// spirv.BitReverse73//===----------------------------------------------------------------------===//74 75func.func @bitreverse(%arg: i32) -> i32 {76 // CHECK: spirv.BitReverse {{%.*}} : i3277 %0 = spirv.BitReverse %arg : i3278 spirv.ReturnValue %0 : i3279}80 81// -----82 83//===----------------------------------------------------------------------===//84// spirv.BitwiseOr85//===----------------------------------------------------------------------===//86 87// CHECK-LABEL: func @bitwise_or_scalar88func.func @bitwise_or_scalar(%arg: i32) -> i32 {89 // CHECK: spirv.BitwiseOr90 %0 = spirv.BitwiseOr %arg, %arg : i3291 return %0 : i3292}93 94// CHECK-LABEL: func @bitwise_or_vector95func.func @bitwise_or_vector(%arg: vector<4xi32>) -> vector<4xi32> {96 // CHECK: spirv.BitwiseOr97 %0 = spirv.BitwiseOr %arg, %arg : vector<4xi32>98 return %0 : vector<4xi32>99}100 101// CANON-LABEL: func @bitwise_or_zero102// CANON-SAME: (%[[ARG:.+]]: i32)103func.func @bitwise_or_zero(%arg: i32) -> i32 {104 // CANON: return %[[ARG]]105 %zero = spirv.Constant 0 : i32106 %0 = spirv.BitwiseOr %arg, %zero : i32107 return %0 : i32108}109 110// CANON-LABEL: func @bitwise_or_zero_vector111// CANON-SAME: (%[[ARG:.+]]: vector<4xi32>)112func.func @bitwise_or_zero_vector(%arg: vector<4xi32>) -> vector<4xi32> {113 // CANON: return %[[ARG]]114 %zero = spirv.Constant dense<0> : vector<4xi32>115 %0 = spirv.BitwiseOr %arg, %zero : vector<4xi32>116 return %0 : vector<4xi32>117}118 119// CANON-LABEL: func @bitwise_or_all_ones120func.func @bitwise_or_all_ones(%arg: i8) -> i8 {121 // CANON: %[[CST:.+]] = spirv.Constant -1122 // CANON: return %[[CST]]123 %ones = spirv.Constant 255 : i8124 %0 = spirv.BitwiseOr %arg, %ones : i8125 return %0 : i8126}127 128// CANON-LABEL: func @bitwise_or_all_ones_vector129func.func @bitwise_or_all_ones_vector(%arg: vector<3xi8>) -> vector<3xi8> {130 // CANON: %[[CST:.+]] = spirv.Constant dense<-1>131 // CANON: return %[[CST]]132 %ones = spirv.Constant dense<255> : vector<3xi8>133 %0 = spirv.BitwiseOr %arg, %ones : vector<3xi8>134 return %0 : vector<3xi8>135}136 137// -----138 139func.func @bitwise_or_float(%arg0: f16, %arg1: f16) -> f16 {140 // expected-error @+1 {{operand #0 must be 8/16/32/64-bit integer or fixed-length vector of 8/16/32/64-bit integer values of length 2/3/4}}141 %0 = spirv.BitwiseOr %arg0, %arg1 : f16142 return %0 : f16143}144 145// -----146 147//===----------------------------------------------------------------------===//148// spirv.BitwiseXor149//===----------------------------------------------------------------------===//150 151func.func @bitwise_xor_scalar(%arg: i32) -> i32 {152 %c1 = spirv.Constant 1 : i32 // using constant to avoid folding153 // CHECK: spirv.BitwiseXor154 %0 = spirv.BitwiseXor %c1, %arg : i32155 return %0 : i32156}157 158func.func @bitwise_xor_vector(%arg: vector<4xi32>) -> vector<4xi32> {159 %c1 = spirv.Constant dense<1> : vector<4xi32> // using constant to avoid folding160 // CHECK: spirv.BitwiseXor161 %0 = spirv.BitwiseXor %c1, %arg : vector<4xi32>162 return %0 : vector<4xi32>163}164 165// -----166 167func.func @bitwise_xor_float(%arg0: f16, %arg1: f16) -> f16 {168 // expected-error @+1 {{operand #0 must be 8/16/32/64-bit integer or fixed-length vector of 8/16/32/64-bit integer values of length 2/3/4}}169 %0 = spirv.BitwiseXor %arg0, %arg1 : f16170 return %0 : f16171}172 173// -----174 175//===----------------------------------------------------------------------===//176// spirv.BitwiseAnd177//===----------------------------------------------------------------------===//178 179// CHECK-LABEL: func @bitwise_and_scalar180func.func @bitwise_and_scalar(%arg: i32) -> i32 {181 // CHECK: spirv.BitwiseAnd182 %0 = spirv.BitwiseAnd %arg, %arg : i32183 return %0 : i32184}185 186// CHECK-LABEL: func @bitwise_and_vector187func.func @bitwise_and_vector(%arg: vector<4xi32>) -> vector<4xi32> {188 // CHECK: spirv.BitwiseAnd189 %0 = spirv.BitwiseAnd %arg, %arg : vector<4xi32>190 return %0 : vector<4xi32>191}192 193// CANON-LABEL: func @bitwise_and_zero194func.func @bitwise_and_zero(%arg: i32) -> i32 {195 // CANON: %[[CST:.+]] = spirv.Constant 0196 // CANON: return %[[CST]]197 %zero = spirv.Constant 0 : i32198 %0 = spirv.BitwiseAnd %arg, %zero : i32199 return %0 : i32200}201 202// CANON-LABEL: func @bitwise_and_zero_vector203func.func @bitwise_and_zero_vector(%arg: vector<4xi32>) -> vector<4xi32> {204 // CANON: %[[CST:.+]] = spirv.Constant dense<0>205 // CANON: return %[[CST]]206 %zero = spirv.Constant dense<0> : vector<4xi32>207 %0 = spirv.BitwiseAnd %arg, %zero : vector<4xi32>208 return %0 : vector<4xi32>209}210 211// CANON-LABEL: func @bitwise_and_all_ones212// CANON-SAME: (%[[ARG:.+]]: i8)213func.func @bitwise_and_all_ones(%arg: i8) -> i8 {214 // CANON: return %[[ARG]]215 %ones = spirv.Constant 255 : i8216 %0 = spirv.BitwiseAnd %arg, %ones : i8217 return %0 : i8218}219 220// CANON-LABEL: func @bitwise_and_all_ones_vector221// CANON-SAME: (%[[ARG:.+]]: vector<3xi8>)222func.func @bitwise_and_all_ones_vector(%arg: vector<3xi8>) -> vector<3xi8> {223 // CANON: return %[[ARG]]224 %ones = spirv.Constant dense<255> : vector<3xi8>225 %0 = spirv.BitwiseAnd %arg, %ones : vector<3xi8>226 return %0 : vector<3xi8>227}228 229// CANON-LABEL: func @bitwise_and_zext_1230// CANON-SAME: (%[[ARG:.+]]: i8)231func.func @bitwise_and_zext_1(%arg: i8) -> i32 {232 // CANON: %[[ZEXT:.+]] = spirv.UConvert %[[ARG]]233 // CANON: return %[[ZEXT]]234 %zext = spirv.UConvert %arg : i8 to i32235 %ones = spirv.Constant 255 : i32236 %0 = spirv.BitwiseAnd %zext, %ones : i32237 return %0 : i32238}239 240// CANON-LABEL: func @bitwise_and_zext_2241// CANON-SAME: (%[[ARG:.+]]: i8)242func.func @bitwise_and_zext_2(%arg: i8) -> i32 {243 // CANON: %[[ZEXT:.+]] = spirv.UConvert %[[ARG]]244 // CANON: return %[[ZEXT]]245 %zext = spirv.UConvert %arg : i8 to i32246 %ones = spirv.Constant 0x12345ff : i32247 %0 = spirv.BitwiseAnd %zext, %ones : i32248 return %0 : i32249}250 251// CANON-LABEL: func @bitwise_and_zext_3252// CANON-SAME: (%[[ARG:.+]]: i8)253func.func @bitwise_and_zext_3(%arg: i8) -> i32 {254 // CANON: %[[ZEXT:.+]] = spirv.UConvert %[[ARG]]255 // CANON: %[[AND:.+]] = spirv.BitwiseAnd %[[ZEXT]]256 // CANON: return %[[AND]]257 %zext = spirv.UConvert %arg : i8 to i32258 %ones = spirv.Constant 254 : i32259 %0 = spirv.BitwiseAnd %zext, %ones : i32260 return %0 : i32261}262 263// CANON-LABEL: func @bitwise_and_zext_vector264// CANON-SAME: (%[[ARG:.+]]: vector<2xi8>)265func.func @bitwise_and_zext_vector(%arg: vector<2xi8>) -> vector<2xi32> {266 // CANON: %[[ZEXT:.+]] = spirv.UConvert %[[ARG]]267 // CANON: return %[[ZEXT]]268 %zext = spirv.UConvert %arg : vector<2xi8> to vector<2xi32>269 %ones = spirv.Constant dense<255> : vector<2xi32>270 %0 = spirv.BitwiseAnd %zext, %ones : vector<2xi32>271 return %0 : vector<2xi32>272}273 274// -----275 276func.func @bitwise_and_float(%arg0: f16, %arg1: f16) -> f16 {277 // expected-error @+1 {{operand #0 must be 8/16/32/64-bit integer or fixed-length vector of 8/16/32/64-bit integer values of length 2/3/4}}278 %0 = spirv.BitwiseAnd %arg0, %arg1 : f16279 return %0 : f16280}281 282// -----283 284//===----------------------------------------------------------------------===//285// spirv.Not286//===----------------------------------------------------------------------===//287 288func.func @not(%arg: i32) -> i32 {289 // CHECK: spirv.Not {{%.*}} : i32290 %0 = spirv.Not %arg : i32291 spirv.ReturnValue %0 : i32292}293 294// -----295 296//===----------------------------------------------------------------------===//297// spirv.ShiftLeftLogical298//===----------------------------------------------------------------------===//299 300func.func @shift_left_logical(%arg0: i32, %arg1 : i16) -> i32 {301 // CHECK: {{%.*}} = spirv.ShiftLeftLogical {{%.*}}, {{%.*}} : i32, i16302 %0 = spirv.ShiftLeftLogical %arg0, %arg1: i32, i16303 spirv.ReturnValue %0 : i32304}305 306// -----307 308func.func @shift_left_logical_invalid_result_type(%arg0: i32, %arg1 : i16) -> i16 {309 // expected-error @+1 {{op failed to verify that all of {operand1, result} have same type}}310 %0 = "spirv.ShiftLeftLogical" (%arg0, %arg1) : (i32, i16) -> (i16)311 spirv.ReturnValue %0 : i16312}313 314// -----315 316//===----------------------------------------------------------------------===//317// spirv.ShiftRightArithmetic318//===----------------------------------------------------------------------===//319 320func.func @shift_right_arithmetic(%arg0: vector<4xi32>, %arg1 : vector<4xi8>) -> vector<4xi32> {321 // CHECK: {{%.*}} = spirv.ShiftRightArithmetic {{%.*}}, {{%.*}} : vector<4xi32>, vector<4xi8>322 %0 = spirv.ShiftRightArithmetic %arg0, %arg1: vector<4xi32>, vector<4xi8>323 spirv.ReturnValue %0 : vector<4xi32>324}325 326// -----327 328//===----------------------------------------------------------------------===//329// spirv.ShiftRightLogical330//===----------------------------------------------------------------------===//331 332func.func @shift_right_logical(%arg0: vector<2xi32>, %arg1 : vector<2xi8>) -> vector<2xi32> {333 // CHECK: {{%.*}} = spirv.ShiftRightLogical {{%.*}}, {{%.*}} : vector<2xi32>, vector<2xi8>334 %0 = spirv.ShiftRightLogical %arg0, %arg1: vector<2xi32>, vector<2xi8>335 spirv.ReturnValue %0 : vector<2xi32>336}337