775 lines · plain
1// RUN: mlir-opt -split-input-file -convert-arith-to-emitc %s | FileCheck %s2// RUN: mlir-opt -split-input-file -convert-to-emitc="filter-dialects=arith" %s | FileCheck %s3 4// CHECK-LABEL: arith_constants5func.func @arith_constants() {6 // CHECK: emitc.constant7 // CHECK-SAME: value = 08 // CHECK-SAME: () -> !emitc.size_t9 %c_index = arith.constant 0 : index10 // CHECK: emitc.constant11 // CHECK-SAME: value = 0 : i3212 %c_signless_int_32 = arith.constant 0 : i3213 // CHECK: emitc.constant14 // CHECK-SAME: value = 0.{{0+}}e+00 : f3215 %c_float_32 = arith.constant 0.0 : f3216 // CHECK: emitc.constant17 // CHECK-SAME: value = dense<0> : tensor<i32>18 %c_tensor_single_value = arith.constant dense<0> : tensor<i32>19 // CHECK: emitc.constant20 // CHECK-SAME: value{{.*}}[1, 2], [-3, 9], [0, 0], [2, -1]{{.*}}tensor<4x2xi64>21 %c_tensor_value = arith.constant dense<[[1, 2], [-3, 9], [0, 0], [2, -1]]> : tensor<4x2xi64>22 return23}24 25// -----26 27func.func @arith_ops(%arg0: f32, %arg1: f32) {28 // CHECK: [[V0:[^ ]*]] = emitc.add %arg0, %arg1 : (f32, f32) -> f3229 %0 = arith.addf %arg0, %arg1 : f3230 // CHECK: [[V1:[^ ]*]] = emitc.div %arg0, %arg1 : (f32, f32) -> f3231 %1 = arith.divf %arg0, %arg1 : f32 32 // CHECK: [[V2:[^ ]*]] = emitc.mul %arg0, %arg1 : (f32, f32) -> f3233 %2 = arith.mulf %arg0, %arg1 : f3234 // CHECK: [[V3:[^ ]*]] = emitc.sub %arg0, %arg1 : (f32, f32) -> f3235 %3 = arith.subf %arg0, %arg1 : f3236 37 return38}39 40// -----41 42// CHECK-LABEL: arith_integer_ops43func.func @arith_integer_ops(%arg0: i32, %arg1: i32) {44 // CHECK: %[[C1:[^ ]*]] = emitc.cast %arg0 : i32 to ui3245 // CHECK: %[[C2:[^ ]*]] = emitc.cast %arg1 : i32 to ui3246 // CHECK: %[[ADD:[^ ]*]] = emitc.add %[[C1]], %[[C2]] : (ui32, ui32) -> ui3247 // CHECK: %[[C3:[^ ]*]] = emitc.cast %[[ADD]] : ui32 to i3248 %0 = arith.addi %arg0, %arg1 : i3249 // CHECK: %[[C1:[^ ]*]] = emitc.cast %arg0 : i32 to ui3250 // CHECK: %[[C2:[^ ]*]] = emitc.cast %arg1 : i32 to ui3251 // CHECK: %[[SUB:[^ ]*]] = emitc.sub %[[C1]], %[[C2]] : (ui32, ui32) -> ui3252 // CHECK: %[[C3:[^ ]*]] = emitc.cast %[[SUB]] : ui32 to i3253 %1 = arith.subi %arg0, %arg1 : i3254 // CHECK: %[[C1:[^ ]*]] = emitc.cast %arg0 : i32 to ui3255 // CHECK: %[[C2:[^ ]*]] = emitc.cast %arg1 : i32 to ui3256 // CHECK: %[[MUL:[^ ]*]] = emitc.mul %[[C1]], %[[C2]] : (ui32, ui32) -> ui3257 // CHECK: %[[C3:[^ ]*]] = emitc.cast %[[MUL]] : ui32 to i3258 %2 = arith.muli %arg0, %arg1 : i3259 60 return61}62 63// -----64 65// CHECK-LABEL: arith_integer_ops_signed_nsw66func.func @arith_integer_ops_signed_nsw(%arg0: i32, %arg1: i32) {67 // CHECK: emitc.add %arg0, %arg1 : (i32, i32) -> i3268 %0 = arith.addi %arg0, %arg1 overflow<nsw> : i3269 // CHECK: emitc.sub %arg0, %arg1 : (i32, i32) -> i3270 %1 = arith.subi %arg0, %arg1 overflow<nsw> : i3271 // CHECK: emitc.mul %arg0, %arg1 : (i32, i32) -> i3272 %2 = arith.muli %arg0, %arg1 overflow<nsw> : i3273 74 return75}76 77// -----78 79// CHECK-LABEL: arith_index80func.func @arith_index(%arg0: i32, %arg1: i32) {81 // CHECK: %[[CST0:.*]] = emitc.cast %{{.*}} : {{.*}} to !emitc.size_t82 %cst0 = arith.index_cast %arg0 : i32 to index83 // CHECK: %[[CST1:.*]] = emitc.cast %{{.*}} : {{.*}} to !emitc.size_t84 %cst1 = arith.index_cast %arg1 : i32 to index85 86 // CHECK: emitc.add %[[CST0]], %[[CST1]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t87 %0 = arith.addi %cst0, %cst1 : index88 // CHECK: emitc.sub %[[CST0]], %[[CST1]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t89 %1 = arith.subi %cst0, %cst1 : index90 // CHECK: emitc.mul %[[CST0]], %[[CST1]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t91 %2 = arith.muli %cst0, %cst1 : index92 93 return94}95 96// -----97 98// CHECK-LABEL: arith_bitwise99// CHECK-SAME: %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32100func.func @arith_bitwise(%arg0: i32, %arg1: i32) {101 // CHECK: %[[C1:[^ ]*]] = emitc.cast %[[ARG0]] : i32 to ui32102 // CHECK: %[[C2:[^ ]*]] = emitc.cast %[[ARG1]] : i32 to ui32103 // CHECK: %[[AND:[^ ]*]] = emitc.bitwise_and %[[C1]], %[[C2]] : (ui32, ui32) -> ui32104 // CHECK: %[[C3:[^ ]*]] = emitc.cast %[[AND]] : ui32 to i32105 %0 = arith.andi %arg0, %arg1 : i32106 // CHECK: %[[C1:[^ ]*]] = emitc.cast %[[ARG0]] : i32 to ui32107 // CHECK: %[[C2:[^ ]*]] = emitc.cast %[[ARG1]] : i32 to ui32108 // CHECK: %[[OR:[^ ]*]] = emitc.bitwise_or %[[C1]], %[[C2]] : (ui32, ui32) -> ui32109 // CHECK: %[[C3:[^ ]*]] = emitc.cast %[[OR]] : ui32 to i32110 %1 = arith.ori %arg0, %arg1 : i32111 // CHECK: %[[C1:[^ ]*]] = emitc.cast %[[ARG0]] : i32 to ui32112 // CHECK: %[[C2:[^ ]*]] = emitc.cast %[[ARG1]] : i32 to ui32113 // CHECK: %[[XOR:[^ ]*]] = emitc.bitwise_xor %[[C1]], %[[C2]] : (ui32, ui32) -> ui32114 // CHECK: %[[C3:[^ ]*]] = emitc.cast %[[XOR]] : ui32 to i32115 %2 = arith.xori %arg0, %arg1 : i32116 117 return118}119 120// -----121 122// CHECK-LABEL: arith_bitwise_bool123// CHECK-SAME: %[[ARG0:.*]]: i1, %[[ARG1:.*]]: i1124func.func @arith_bitwise_bool(%arg0: i1, %arg1: i1) {125 // CHECK: %[[AND:[^ ]*]] = emitc.bitwise_and %[[ARG0]], %[[ARG1]] : (i1, i1) -> i1126 %0 = arith.andi %arg0, %arg1 : i1127 // CHECK: %[[OR:[^ ]*]] = emitc.bitwise_or %[[ARG0]], %[[ARG1]] : (i1, i1) -> i1128 %1 = arith.ori %arg0, %arg1 : i1129 // CHECK: %[[xor:[^ ]*]] = emitc.bitwise_xor %[[ARG0]], %[[ARG1]] : (i1, i1) -> i1130 %2 = arith.xori %arg0, %arg1 : i1131 132 return133}134 135// -----136 137// CHECK-LABEL: arith_signed_integer_div_rem138func.func @arith_signed_integer_div_rem(%arg0: i32, %arg1: i32) {139 // CHECK: emitc.div %arg0, %arg1 : (i32, i32) -> i32140 %0 = arith.divsi %arg0, %arg1 : i32141 // CHECK: emitc.rem %arg0, %arg1 : (i32, i32) -> i32142 %1 = arith.remsi %arg0, %arg1 : i32143 return144}145 146// -----147 148// CHECK-LABEL: arith_shift_left149// CHECK-SAME: %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32150func.func @arith_shift_left(%arg0: i32, %arg1: i32) {151 // CHECK-DAG: %[[C1:[^ ]*]] = emitc.cast %[[ARG0]] : i32 to ui32152 // CHECK-DAG: %[[C2:[^ ]*]] = emitc.cast %[[ARG1]] : i32 to ui32153 // CHECK-DAG: %[[SizeConstant:[^ ]*]] = "emitc.constant"{{.*}}value = 32154 // CHECK-DAG: %[[CmpNoExcess:[^ ]*]] = emitc.cmp lt, %[[C2]], %[[SizeConstant]] : (ui32, ui32) -> i1155 // CHECK-DAG: %[[Zero:[^ ]*]] = "emitc.constant"{{.*}}value = 0156 // CHECK: %[[ShiftRes:[^ ]*]] = emitc.expression %[[C1]], %[[C2]], %[[CmpNoExcess]], %[[Zero]] : (ui32, ui32, i1, ui32) -> ui32 {157 // CHECK-NEXT: %[[SHL:[^ ]*]] = bitwise_left_shift %[[C1]], %[[C2]] : (ui32, ui32) -> ui32158 // CHECK-NEXT: %[[Ternary:[^ ]*]] = conditional %[[CmpNoExcess]], %[[SHL]], %[[Zero]] : ui32159 // CHECK-NEXT: yield %[[Ternary]] : ui32160 // CHECK-NEXT: }161 // CHECK-NEXT: emitc.cast %[[ShiftRes]] : ui32 to i32162 %1 = arith.shli %arg0, %arg1 : i32163 return164}165 166// -----167 168// CHECK-LABEL: arith_shift_right169// CHECK-SAME: %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32170func.func @arith_shift_right(%arg0: i32, %arg1: i32) {171 // CHECK-DAG: %[[C1:[^ ]*]] = emitc.cast %[[ARG0]] : i32 to ui32172 // CHECK-DAG: %[[C2:[^ ]*]] = emitc.cast %[[ARG1]] : i32 to ui32173 // CHECK-DAG: %[[SizeConstant:[^ ]*]] = "emitc.constant"{{.*}}value = 32{{.*}}ui32174 // CHECK-DAG: %[[CmpNoExcess:[^ ]*]] = emitc.cmp lt, %[[C2]], %[[SizeConstant]] : (ui32, ui32) -> i1175 // CHECK-DAG: %[[Zero:[^ ]*]] = "emitc.constant"{{.*}}value = 0{{.*}}ui32176 // CHECK: %[[ShiftRes:[^ ]*]] = emitc.expression %[[C1]], %[[C2]], %[[CmpNoExcess]], %[[Zero]] : (ui32, ui32, i1, ui32) -> ui32 {177 // CHECK-NEXT: %[[SHR:[^ ]*]] = bitwise_right_shift %[[C1]], %[[C2]] : (ui32, ui32) -> ui32178 // CHECK-NEXT: %[[Ternary:[^ ]*]] = conditional %[[CmpNoExcess]], %[[SHR]], %[[Zero]] : ui32179 // CHECK-NEXT: yield %[[Ternary]] : ui32180 // CHECK-NEXT: }181 // CHECK-NEXT: emitc.cast %[[ShiftRes]] : ui32 to i32182 %2 = arith.shrui %arg0, %arg1 : i32183 184 // CHECK-DAG: %[[SC2:[^ ]*]] = emitc.cast %[[ARG1]] : i32 to ui32185 // CHECK-DAG: %[[SSizeConstant:[^ ]*]] = "emitc.constant"{{.*}}value = 32{{.*}}ui32186 // CHECK-DAG: %[[SCmpNoExcess:[^ ]*]] = emitc.cmp lt, %[[SC2]], %[[SSizeConstant]] : (ui32, ui32) -> i1187 // CHECK-DAG: %[[SZero:[^ ]*]] = "emitc.constant"{{.*}}value = 0{{.*}}i32188 // CHECK: %[[SShiftRes:[^ ]*]] = emitc.expression %[[ARG0]], %[[SC2]], %[[SCmpNoExcess]], %[[SZero]] : (i32, ui32, i1, i32) -> i32 {189 // CHECK-NEXT: %[[SHRSI:[^ ]*]] = bitwise_right_shift %[[ARG0]], %[[SC2]] : (i32, ui32) -> i32190 // CHECK-NEXT: %[[STernary:[^ ]*]] = conditional %[[SCmpNoExcess]], %[[SHRSI]], %[[SZero]] : i32191 // CHECK-NEXT: yield %[[STernary]] : i32192 // CHECK-NEXT: }193 %3 = arith.shrsi %arg0, %arg1 : i32194 195 return196}197 198// -----199 200// CHECK-LABEL: arith_shift_left_index201// CHECK-SAME: %[[AMOUNT:.*]]: i32202func.func @arith_shift_left_index(%amount: i32) {203 %cst0 = "arith.constant"() {value = 42 : index} : () -> (index)204 %cast1 = arith.index_cast %amount : i32 to index205 // CHECK-DAG: %[[C1:[^ ]*]] = "emitc.constant"(){{.*}}value = 42{{.*}}!emitc.size_t206 // CHECK-DAG: %[[Cast1:[^ ]*]] = emitc.cast %[[AMOUNT]] : i32 to !emitc.ptrdiff_t207 // CHECK-DAG: %[[AmountIdx:[^ ]*]] = emitc.cast %[[Cast1]] : !emitc.ptrdiff_t to !emitc.size_t208 // CHECK-DAG: %[[Byte:[^ ]*]] = "emitc.constant"{{.*}}value = 8{{.*}}index209 // CHECK-DAG: %[[SizeOf:[^ ]*]] = emitc.call_opaque "sizeof"(%[[Byte]]) : (!emitc.size_t) -> !emitc.size_t210 // CHECK-DAG: %[[SizeConstant:[^ ]*]] = emitc.mul %[[Byte]], %[[SizeOf]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t211 // CHECK-DAG: %[[CmpNoExcess:[^ ]*]] = emitc.cmp lt, %[[AmountIdx]], %[[SizeConstant]] : (!emitc.size_t, !emitc.size_t) -> i1212 // CHECK-DAG: %[[Zero:[^ ]*]] = "emitc.constant"{{.*}}value = 0213 // CHECK: %[[ShiftRes:[^ ]*]] = emitc.expression %[[C1]], %[[AmountIdx]], %[[CmpNoExcess]], %[[Zero]] : (!emitc.size_t, !emitc.size_t, i1, !emitc.size_t) -> !emitc.size_t {214 // CHECK-NEXT: %[[SHL:[^ ]*]] = bitwise_left_shift %[[C1]], %[[AmountIdx]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t215 // CHECK-NEXT: %[[Ternary:[^ ]*]] = conditional %[[CmpNoExcess]], %[[SHL]], %[[Zero]] : !emitc.size_t216 // CHECK-NEXT: yield %[[Ternary]] : !emitc.size_t217 // CHECK-NEXT: }218 %1 = arith.shli %cst0, %cast1 : index219 return220}221 222// -----223 224// CHECK-LABEL: arith_shift_right_index225// CHECK-SAME: %[[AMOUNT:.*]]: i32226func.func @arith_shift_right_index(%amount: i32) {227 // CHECK-DAG: %[[C1:[^ ]*]] = "emitc.constant"(){{.*}}value = 42{{.*}}!emitc.size_t228 // CHECK-DAG: %[[Cast1:[^ ]*]] = emitc.cast %[[AMOUNT]] : i32 to !emitc.ptrdiff_t229 // CHECK-DAG: %[[AmountIdx:[^ ]*]] = emitc.cast %[[Cast1]] : !emitc.ptrdiff_t to !emitc.size_t230 %arg0 = "arith.constant"() {value = 42 : index} : () -> (index)231 %arg1 = arith.index_cast %amount : i32 to index232 233 // CHECK-DAG: %[[Byte:[^ ]*]] = "emitc.constant"{{.*}}value = 8{{.*}}index234 // CHECK-DAG: %[[SizeOf:[^ ]*]] = emitc.call_opaque "sizeof"(%[[Byte]]) : (!emitc.size_t) -> !emitc.size_t235 // CHECK-DAG: %[[SizeConstant:[^ ]*]] = emitc.mul %[[Byte]], %[[SizeOf]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t236 // CHECK-DAG: %[[CmpNoExcess:[^ ]*]] = emitc.cmp lt, %[[AmountIdx]], %[[SizeConstant]] : (!emitc.size_t, !emitc.size_t) -> i1237 // CHECK-DAG: %[[Zero:[^ ]*]] = "emitc.constant"{{.*}}value = 0{{.*}}!emitc.size_t238 // CHECK: %[[ShiftRes:[^ ]*]] = emitc.expression %[[C1]], %[[AmountIdx]], %[[CmpNoExcess]], %[[Zero]] : (!emitc.size_t, !emitc.size_t, i1, !emitc.size_t) -> !emitc.size_t {239 // CHECK-NEXT: %[[SHR:[^ ]*]] = bitwise_right_shift %[[C1]], %[[AmountIdx]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t240 // CHECK-NEXT: %[[Ternary:[^ ]*]] = conditional %[[CmpNoExcess]], %[[SHR]], %[[Zero]] : !emitc.size_t241 // CHECK-NEXT: yield %[[Ternary]] : !emitc.size_t242 // CHECK-NEXT: }243 %2 = arith.shrui %arg0, %arg1 : index244 245 // CHECK-DAG: %[[SC1:[^ ]*]] = emitc.cast %[[C1]] : !emitc.size_t to !emitc.ptrdiff_t246 // CHECK-DAG: %[[SByte:[^ ]*]] = "emitc.constant"{{.*}}value = 8{{.*}}index{{.*}}!emitc.size_t247 // CHECK-DAG: %[[SSizeOf:[^ ]*]] = emitc.call_opaque "sizeof"(%[[SByte]]) : (!emitc.size_t) -> !emitc.size_t248 // CHECK-DAG: %[[SSizeConstant:[^ ]*]] = emitc.mul %[[SByte]], %[[SSizeOf]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t249 // CHECK-DAG: %[[SCmpNoExcess:[^ ]*]] = emitc.cmp lt, %[[AmountIdx]], %[[SSizeConstant]] : (!emitc.size_t, !emitc.size_t) -> i1250 // CHECK-DAG: %[[SZero:[^ ]*]] = "emitc.constant"{{.*}}value = 0{{.*}}!emitc.ptrdiff_t251 // CHECK: %[[SShiftRes:[^ ]*]] = emitc.expression %[[SC1]], %[[AmountIdx]], %[[SCmpNoExcess]], %[[SZero]] : (!emitc.ptrdiff_t, !emitc.size_t, i1, !emitc.ptrdiff_t) -> !emitc.ptrdiff_t {252 // CHECK-NEXT: %[[SHRSI:[^ ]*]] = bitwise_right_shift %[[SC1]], %[[AmountIdx]] : (!emitc.ptrdiff_t, !emitc.size_t) -> !emitc.ptrdiff_t253 // CHECK-NEXT: %[[STernary:[^ ]*]] = conditional %[[SCmpNoExcess]], %[[SHRSI]], %[[SZero]] : !emitc.ptrdiff_t254 // CHECK-NEXT: yield %[[STernary]] : !emitc.ptrdiff_t255 // CHECK-NEXT: }256 // CHECK-NEXT: emitc.cast %[[SShiftRes]] : !emitc.ptrdiff_t to !emitc.size_t257 %3 = arith.shrsi %arg0, %arg1 : index258 259 return260}261 262// -----263 264func.func @arith_select(%arg0: i1, %arg1: tensor<8xi32>, %arg2: tensor<8xi32>) -> () {265 // CHECK: [[V0:[^ ]*]] = emitc.conditional %arg0, %arg1, %arg2 : tensor<8xi32>266 %0 = arith.select %arg0, %arg1, %arg2 : i1, tensor<8xi32>267 return268}269 270// -----271 272func.func @arith_cmpf_false(%arg0: f32, %arg1: f32) -> i1 {273 // CHECK-LABEL: arith_cmpf_false274 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32)275 // CHECK-DAG: [[False:[^ ]*]] = "emitc.constant"() <{value = false}> : () -> i1276 %false = arith.cmpf false, %arg0, %arg1 : f32277 // CHECK: return [[False]]278 return %false: i1279}280 281// -----282 283func.func @arith_cmpf_oeq(%arg0: f32, %arg1: f32) -> i1 {284 // CHECK-LABEL: arith_cmpf_oeq285 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32)286 // CHECK-DAG: [[EQ:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg1]] : (f32, f32) -> i1287 // CHECK-DAG: [[NotNaNArg0:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg0]] : (f32, f32) -> i1288 // CHECK-DAG: [[NotNaNArg1:[^ ]*]] = emitc.cmp eq, [[Arg1]], [[Arg1]] : (f32, f32) -> i1289 // CHECK-DAG: [[Ordered:[^ ]*]] = emitc.logical_and [[NotNaNArg0]], [[NotNaNArg1]] : i1, i1290 // CHECK-DAG: [[OEQ:[^ ]*]] = emitc.logical_and [[Ordered]], [[EQ]] : i1, i1291 %oeq = arith.cmpf oeq, %arg0, %arg1 : f32292 // CHECK: return [[OEQ]]293 return %oeq: i1294}295 296// -----297 298func.func @arith_cmpf_ogt(%arg0: f32, %arg1: f32) -> i1 {299 // CHECK-LABEL: arith_cmpf_ogt300 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32)301 // CHECK-DAG: [[GT:[^ ]*]] = emitc.cmp gt, [[Arg0]], [[Arg1]] : (f32, f32) -> i1302 // CHECK-DAG: [[NotNaNArg0:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg0]] : (f32, f32) -> i1303 // CHECK-DAG: [[NotNaNArg1:[^ ]*]] = emitc.cmp eq, [[Arg1]], [[Arg1]] : (f32, f32) -> i1304 // CHECK-DAG: [[Ordered:[^ ]*]] = emitc.logical_and [[NotNaNArg0]], [[NotNaNArg1]] : i1, i1305 // CHECK-DAG: [[OGT:[^ ]*]] = emitc.logical_and [[Ordered]], [[GT]] : i1, i1306 %ogt = arith.cmpf ogt, %arg0, %arg1 : f32307 // CHECK: return [[OGT]]308 return %ogt: i1309}310 311// -----312 313func.func @arith_cmpf_oge(%arg0: f32, %arg1: f32) -> i1 {314 // CHECK-LABEL: arith_cmpf_oge315 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32)316 // CHECK-DAG: [[GE:[^ ]*]] = emitc.cmp ge, [[Arg0]], [[Arg1]] : (f32, f32) -> i1317 // CHECK-DAG: [[NotNaNArg0:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg0]] : (f32, f32) -> i1318 // CHECK-DAG: [[NotNaNArg1:[^ ]*]] = emitc.cmp eq, [[Arg1]], [[Arg1]] : (f32, f32) -> i1319 // CHECK-DAG: [[Ordered:[^ ]*]] = emitc.logical_and [[NotNaNArg0]], [[NotNaNArg1]] : i1, i1320 // CHECK-DAG: [[OGE:[^ ]*]] = emitc.logical_and [[Ordered]], [[GE]] : i1, i1321 %oge = arith.cmpf oge, %arg0, %arg1 : f32322 // CHECK: return [[OGE]]323 return %oge: i1324}325 326// -----327 328func.func @arith_cmpf_olt(%arg0: f32, %arg1: f32) -> i1 {329 // CHECK-LABEL: arith_cmpf_olt330 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32)331 // CHECK-DAG: [[LT:[^ ]*]] = emitc.cmp lt, [[Arg0]], [[Arg1]] : (f32, f32) -> i1332 // CHECK-DAG: [[NotNaNArg0:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg0]] : (f32, f32) -> i1333 // CHECK-DAG: [[NotNaNArg1:[^ ]*]] = emitc.cmp eq, [[Arg1]], [[Arg1]] : (f32, f32) -> i1334 // CHECK-DAG: [[Ordered:[^ ]*]] = emitc.logical_and [[NotNaNArg0]], [[NotNaNArg1]] : i1, i1335 // CHECK-DAG: [[OLT:[^ ]*]] = emitc.logical_and [[Ordered]], [[LT]] : i1, i1336 %olt = arith.cmpf olt, %arg0, %arg1 : f32337 // CHECK: return [[OLT]]338 return %olt: i1339}340 341// -----342 343func.func @arith_cmpf_ole(%arg0: f32, %arg1: f32) -> i1 {344 // CHECK-LABEL: arith_cmpf_ole345 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32)346 // CHECK-DAG: [[LT:[^ ]*]] = emitc.cmp le, [[Arg0]], [[Arg1]] : (f32, f32) -> i1347 // CHECK-DAG: [[NotNaNArg0:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg0]] : (f32, f32) -> i1348 // CHECK-DAG: [[NotNaNArg1:[^ ]*]] = emitc.cmp eq, [[Arg1]], [[Arg1]] : (f32, f32) -> i1349 // CHECK-DAG: [[Ordered:[^ ]*]] = emitc.logical_and [[NotNaNArg0]], [[NotNaNArg1]] : i1, i1350 // CHECK-DAG: [[OLE:[^ ]*]] = emitc.logical_and [[Ordered]], [[LT]] : i1, i1351 %ole = arith.cmpf ole, %arg0, %arg1 : f32352 // CHECK: return [[OLE]]353 return %ole: i1354}355 356// -----357 358func.func @arith_cmpf_one(%arg0: f32, %arg1: f32) -> i1 {359 // CHECK-LABEL: arith_cmpf_one360 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32)361 // CHECK-DAG: [[NEQ:[^ ]*]] = emitc.cmp ne, [[Arg0]], [[Arg1]] : (f32, f32) -> i1362 // CHECK-DAG: [[NotNaNArg0:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg0]] : (f32, f32) -> i1363 // CHECK-DAG: [[NotNaNArg1:[^ ]*]] = emitc.cmp eq, [[Arg1]], [[Arg1]] : (f32, f32) -> i1364 // CHECK-DAG: [[Ordered:[^ ]*]] = emitc.logical_and [[NotNaNArg0]], [[NotNaNArg1]] : i1, i1365 // CHECK-DAG: [[ONE:[^ ]*]] = emitc.logical_and [[Ordered]], [[NEQ]] : i1, i1366 %one = arith.cmpf one, %arg0, %arg1 : f32367 // CHECK: return [[ONE]]368 return %one: i1369}370 371// -----372 373func.func @arith_cmpf_ord(%arg0: f32, %arg1: f32) -> i1 {374 // CHECK-LABEL: arith_cmpf_ord375 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32)376 // CHECK-DAG: [[NotNaNArg0:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg0]] : (f32, f32) -> i1377 // CHECK-DAG: [[NotNaNArg1:[^ ]*]] = emitc.cmp eq, [[Arg1]], [[Arg1]] : (f32, f32) -> i1378 // CHECK-DAG: [[Ordered:[^ ]*]] = emitc.logical_and [[NotNaNArg0]], [[NotNaNArg1]] : i1, i1379 %ord = arith.cmpf ord, %arg0, %arg1 : f32380 // CHECK: return [[Ordered]]381 return %ord: i1382}383 384// -----385 386func.func @arith_cmpf_ueq(%arg0: f32, %arg1: f32) -> i1 {387 // CHECK-LABEL: arith_cmpf_ueq388 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32)389 // CHECK-DAG: [[EQ:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg1]] : (f32, f32) -> i1390 // CHECK-DAG: [[NaNArg0:[^ ]*]] = emitc.cmp ne, [[Arg0]], [[Arg0]] : (f32, f32) -> i1391 // CHECK-DAG: [[NaNArg1:[^ ]*]] = emitc.cmp ne, [[Arg1]], [[Arg1]] : (f32, f32) -> i1392 // CHECK-DAG: [[Unordered:[^ ]*]] = emitc.logical_or [[NaNArg0]], [[NaNArg1]] : i1, i1393 // CHECK-DAG: [[UEQ:[^ ]*]] = emitc.logical_or [[Unordered]], [[EQ]] : i1, i1394 %ueq = arith.cmpf ueq, %arg0, %arg1 : f32395 // CHECK: return [[UEQ]]396 return %ueq: i1397}398 399// -----400 401func.func @arith_cmpf_ugt(%arg0: f32, %arg1: f32) -> i1 {402 // CHECK-LABEL: arith_cmpf_ugt403 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32)404 // CHECK-DAG: [[GT:[^ ]*]] = emitc.cmp gt, [[Arg0]], [[Arg1]] : (f32, f32) -> i1405 // CHECK-DAG: [[NaNArg0:[^ ]*]] = emitc.cmp ne, [[Arg0]], [[Arg0]] : (f32, f32) -> i1406 // CHECK-DAG: [[NaNArg1:[^ ]*]] = emitc.cmp ne, [[Arg1]], [[Arg1]] : (f32, f32) -> i1407 // CHECK-DAG: [[Unordered:[^ ]*]] = emitc.logical_or [[NaNArg0]], [[NaNArg1]] : i1, i1408 // CHECK-DAG: [[UGT:[^ ]*]] = emitc.logical_or [[Unordered]], [[GT]] : i1, i1409 %ugt = arith.cmpf ugt, %arg0, %arg1 : f32410 // CHECK: return [[UGT]]411 return %ugt: i1412}413 414// -----415 416func.func @arith_cmpf_uge(%arg0: f32, %arg1: f32) -> i1 {417 // CHECK-LABEL: arith_cmpf_uge418 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32)419 // CHECK-DAG: [[GE:[^ ]*]] = emitc.cmp ge, [[Arg0]], [[Arg1]] : (f32, f32) -> i1420 // CHECK-DAG: [[NaNArg0:[^ ]*]] = emitc.cmp ne, [[Arg0]], [[Arg0]] : (f32, f32) -> i1421 // CHECK-DAG: [[NaNArg1:[^ ]*]] = emitc.cmp ne, [[Arg1]], [[Arg1]] : (f32, f32) -> i1422 // CHECK-DAG: [[Unordered:[^ ]*]] = emitc.logical_or [[NaNArg0]], [[NaNArg1]] : i1, i1423 // CHECK-DAG: [[UGE:[^ ]*]] = emitc.logical_or [[Unordered]], [[GE]] : i1, i1424 %uge = arith.cmpf uge, %arg0, %arg1 : f32425 // CHECK: return [[UGE]]426 return %uge: i1427}428 429// -----430 431func.func @arith_cmpf_ult(%arg0: f32, %arg1: f32) -> i1 {432 // CHECK-LABEL: arith_cmpf_ult433 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32)434 // CHECK-DAG: [[LT:[^ ]*]] = emitc.cmp lt, [[Arg0]], [[Arg1]] : (f32, f32) -> i1435 // CHECK-DAG: [[NaNArg0:[^ ]*]] = emitc.cmp ne, [[Arg0]], [[Arg0]] : (f32, f32) -> i1436 // CHECK-DAG: [[NaNArg1:[^ ]*]] = emitc.cmp ne, [[Arg1]], [[Arg1]] : (f32, f32) -> i1437 // CHECK-DAG: [[Unordered:[^ ]*]] = emitc.logical_or [[NaNArg0]], [[NaNArg1]] : i1, i1438 // CHECK-DAG: [[ULT:[^ ]*]] = emitc.logical_or [[Unordered]], [[LT]] : i1, i1439 %ult = arith.cmpf ult, %arg0, %arg1 : f32440 // CHECK: return [[ULT]]441 return %ult: i1442}443 444// -----445 446func.func @arith_cmpf_ule(%arg0: f32, %arg1: f32) -> i1 {447 // CHECK-LABEL: arith_cmpf_ule448 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32)449 // CHECK-DAG: [[LE:[^ ]*]] = emitc.cmp le, [[Arg0]], [[Arg1]] : (f32, f32) -> i1450 // CHECK-DAG: [[NaNArg0:[^ ]*]] = emitc.cmp ne, [[Arg0]], [[Arg0]] : (f32, f32) -> i1451 // CHECK-DAG: [[NaNArg1:[^ ]*]] = emitc.cmp ne, [[Arg1]], [[Arg1]] : (f32, f32) -> i1452 // CHECK-DAG: [[Unordered:[^ ]*]] = emitc.logical_or [[NaNArg0]], [[NaNArg1]] : i1, i1453 // CHECK-DAG: [[ULE:[^ ]*]] = emitc.logical_or [[Unordered]], [[LE]] : i1, i1454 %ule = arith.cmpf ule, %arg0, %arg1 : f32455 // CHECK: return [[ULE]]456 return %ule: i1457}458 459// -----460 461func.func @arith_cmpf_une(%arg0: f32, %arg1: f32) -> i1 {462 // CHECK-LABEL: arith_cmpf_une463 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32)464 // CHECK-DAG: [[NEQ:[^ ]*]] = emitc.cmp ne, [[Arg0]], [[Arg1]] : (f32, f32) -> i1465 // CHECK-DAG: [[NaNArg0:[^ ]*]] = emitc.cmp ne, [[Arg0]], [[Arg0]] : (f32, f32) -> i1466 // CHECK-DAG: [[NaNArg1:[^ ]*]] = emitc.cmp ne, [[Arg1]], [[Arg1]] : (f32, f32) -> i1467 // CHECK-DAG: [[Unordered:[^ ]*]] = emitc.logical_or [[NaNArg0]], [[NaNArg1]] : i1, i1468 // CHECK-DAG: [[UNE:[^ ]*]] = emitc.logical_or [[Unordered]], [[NEQ]] : i1, i1469 %une = arith.cmpf une, %arg0, %arg1 : f32470 // CHECK: return [[UNE]]471 return %une: i1472}473 474// -----475 476func.func @arith_cmpf_uno(%arg0: f32, %arg1: f32) -> i1 {477 // CHECK-LABEL: arith_cmpf_uno478 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32)479 // CHECK-DAG: [[NaNArg0:[^ ]*]] = emitc.cmp ne, [[Arg0]], [[Arg0]] : (f32, f32) -> i1480 // CHECK-DAG: [[NaNArg1:[^ ]*]] = emitc.cmp ne, [[Arg1]], [[Arg1]] : (f32, f32) -> i1481 // CHECK-DAG: [[Unordered:[^ ]*]] = emitc.logical_or [[NaNArg0]], [[NaNArg1]] : i1, i1482 %uno = arith.cmpf uno, %arg0, %arg1 : f32483 // CHECK: return [[Unordered]]484 return %uno: i1485}486 487// -----488 489func.func @arith_cmpf_true(%arg0: f32, %arg1: f32) -> i1 {490 // CHECK-LABEL: arith_cmpf_true491 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32)492 // CHECK-DAG: [[True:[^ ]*]] = "emitc.constant"() <{value = true}> : () -> i1493 %ueq = arith.cmpf true, %arg0, %arg1 : f32494 // CHECK: return [[True]]495 return %ueq: i1496}497 498// -----499 500func.func @arith_cmpi_eq(%arg0: i32, %arg1: i32) -> i1 {501 // CHECK-LABEL: arith_cmpi_eq502 // CHECK-SAME: ([[Arg0:[^ ]*]]: i32, [[Arg1:[^ ]*]]: i32)503 // CHECK-DAG: [[EQ:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg1]] : (i32, i32) -> i1504 %eq = arith.cmpi eq, %arg0, %arg1 : i32505 // CHECK: return [[EQ]]506 return %eq: i1507}508 509func.func @arith_cmpi_ult(%arg0: i32, %arg1: i32) -> i1 {510 // CHECK-LABEL: arith_cmpi_ult511 // CHECK-SAME: ([[Arg0:[^ ]*]]: i32, [[Arg1:[^ ]*]]: i32)512 // CHECK-DAG: [[CastArg0:[^ ]*]] = emitc.cast [[Arg0]] : i32 to ui32513 // CHECK-DAG: [[CastArg1:[^ ]*]] = emitc.cast [[Arg1]] : i32 to ui32514 // CHECK-DAG: [[ULT:[^ ]*]] = emitc.cmp lt, [[CastArg0]], [[CastArg1]] : (ui32, ui32) -> i1515 %ult = arith.cmpi ult, %arg0, %arg1 : i32516 517 // CHECK: return [[ULT]]518 return %ult: i1519}520 521func.func @arith_cmpi_predicates(%arg0: i32, %arg1: i32) {522 // CHECK: emitc.cmp lt, {{.*}} : (ui32, ui32) -> i1523 %ult = arith.cmpi ult, %arg0, %arg1 : i32524 // CHECK: emitc.cmp lt, {{.*}} : (i32, i32) -> i1525 %slt = arith.cmpi slt, %arg0, %arg1 : i32526 // CHECK: emitc.cmp le, {{.*}} : (ui32, ui32) -> i1527 %ule = arith.cmpi ule, %arg0, %arg1 : i32528 // CHECK: emitc.cmp le, {{.*}} : (i32, i32) -> i1529 %sle = arith.cmpi sle, %arg0, %arg1 : i32530 // CHECK: emitc.cmp gt, {{.*}} : (ui32, ui32) -> i1531 %ugt = arith.cmpi ugt, %arg0, %arg1 : i32532 // CHECK: emitc.cmp gt, {{.*}} : (i32, i32) -> i1533 %sgt = arith.cmpi sgt, %arg0, %arg1 : i32534 // CHECK: emitc.cmp ge, {{.*}} : (ui32, ui32) -> i1535 %uge = arith.cmpi uge, %arg0, %arg1 : i32536 // CHECK: emitc.cmp ge, {{.*}} : (i32, i32) -> i1537 %sge = arith.cmpi sge, %arg0, %arg1 : i32538 // CHECK: emitc.cmp eq, {{.*}} : (i32, i32) -> i1539 %eq = arith.cmpi eq, %arg0, %arg1 : i32540 // CHECK: emitc.cmp ne, {{.*}} : (i32, i32) -> i1541 %ne = arith.cmpi ne, %arg0, %arg1 : i32542 543 return544}545 546func.func @arith_cmpi_index(%arg0: i32, %arg1: i32) -> i1 {547 // CHECK-LABEL: arith_cmpi_index548 549 // CHECK: %[[Cst0:.*]] = emitc.cast %{{.*}} : {{.*}} to !emitc.size_t550 %idx0 = arith.index_cast %arg0 : i32 to index551 // CHECK: %[[Cst1:.*]] = emitc.cast %{{.*}} : {{.*}} to !emitc.size_t552 %idx1 = arith.index_cast %arg0 : i32 to index553 554 // CHECK-DAG: [[ULT:[^ ]*]] = emitc.cmp lt, %[[Cst0]], %[[Cst1]] : (!emitc.size_t, !emitc.size_t) -> i1555 %ult = arith.cmpi ult, %idx0, %idx1 : index556 557 // CHECK-DAG: %[[CastArg0:[^ ]*]] = emitc.cast %[[Cst0]] : !emitc.size_t to !emitc.ptrdiff_t558 // CHECK-DAG: %[[CastArg1:[^ ]*]] = emitc.cast %[[Cst1]] : !emitc.size_t to !emitc.ptrdiff_t559 // CHECK-DAG: %[[SLT:[^ ]*]] = emitc.cmp lt, %[[CastArg0]], %[[CastArg1]] : (!emitc.ptrdiff_t, !emitc.ptrdiff_t) -> i1560 %slt = arith.cmpi slt, %idx0, %idx1 : index561 562 // CHECK: return %[[SLT]]563 return %slt: i1564}565 566 567// -----568 569func.func @arith_negf(%arg0: f32) -> f32 {570 // CHECK-LABEL: arith_negf571 // CHECK-SAME: %[[Arg0:[^ ]*]]: f32572 // CHECK: %[[N:[^ ]*]] = emitc.unary_minus %[[Arg0]] : (f32) -> f32573 %n = arith.negf %arg0 : f32574 // CHECK: return %[[N]]575 return %n: f32576}577 578// -----579 580func.func @arith_float_to_int_cast_ops(%arg0: f32, %arg1: f64) {581 // CHECK: emitc.cast %arg0 : f32 to i32582 %0 = arith.fptosi %arg0 : f32 to i32583 584 // CHECK: emitc.cast %arg1 : f64 to i32585 %1 = arith.fptosi %arg1 : f64 to i32586 587 // CHECK: emitc.cast %arg0 : f32 to i16588 %2 = arith.fptosi %arg0 : f32 to i16589 590 // CHECK: emitc.cast %arg1 : f64 to i16591 %3 = arith.fptosi %arg1 : f64 to i16592 593 // CHECK: %[[CAST0:.*]] = emitc.cast %arg0 : f32 to ui32594 // CHECK: emitc.cast %[[CAST0]] : ui32 to i32595 %4 = arith.fptoui %arg0 : f32 to i32596 597 // CHECK: %[[CAST0:.*]] = emitc.cast %arg0 : f32 to ui16598 // CHECK: emitc.cast %[[CAST0]] : ui16 to i16599 %5 = arith.fptoui %arg0 : f32 to i16600 601 return602}603 604func.func @arith_int_to_float_cast_ops(%arg0: i8, %arg1: i64) {605 // CHECK: emitc.cast %arg0 : i8 to f32606 %0 = arith.sitofp %arg0 : i8 to f32607 608 // CHECK: emitc.cast %arg1 : i64 to f32609 %1 = arith.sitofp %arg1 : i64 to f32610 611 // CHECK: %[[CAST_UNS:.*]] = emitc.cast %arg0 : i8 to ui8612 // CHECK: emitc.cast %[[CAST_UNS]] : ui8 to f32613 %2 = arith.uitofp %arg0 : i8 to f32614 615 return616}617 618// -----619 620func.func @arith_trunci(%arg0: i32) -> i8 {621 // CHECK-LABEL: arith_trunci622 // CHECK-SAME: (%[[Arg0:[^ ]*]]: i32)623 // CHECK: %[[CastUI:.*]] = emitc.cast %[[Arg0]] : i32 to ui32624 // CHECK: %[[Trunc:.*]] = emitc.cast %[[CastUI]] : ui32 to ui8625 // CHECK: emitc.cast %[[Trunc]] : ui8 to i8626 %truncd = arith.trunci %arg0 : i32 to i8627 628 // CHECK: %[[Const:.*]] = "emitc.constant"629 // CHECK-SAME: value = 1630 // CHECK-SAME: () -> i32631 // CHECK: %[[AndOne:.*]] = emitc.bitwise_and %[[Arg0]], %[[Const]] : (i32, i32) -> i32632 // CHECK: %[[Conv:.*]] = emitc.cast %[[AndOne]] : i32 to i1633 %bool = arith.trunci %arg0 : i32 to i1634 635 return %truncd : i8636}637 638// -----639 640func.func @arith_trunci_to_i1(%arg0: i32) -> i1 {641 // CHECK-LABEL: arith_trunci_to_i1642 // CHECK-SAME: (%[[Arg0:[^ ]*]]: i32)643 // CHECK: %[[Const:.*]] = "emitc.constant"644 // CHECK-SAME: value = 1645 // CHECK: %[[And:.*]] = emitc.bitwise_and %[[Arg0]], %[[Const]] : (i32, i32) -> i32646 // CHECK: emitc.cast %[[And]] : i32 to i1647 %truncd = arith.trunci %arg0 : i32 to i1648 649 return %truncd : i1650}651 652// -----653 654func.func @arith_extsi(%arg0: i32) {655 // CHECK-LABEL: arith_extsi656 // CHECK-SAME: ([[Arg0:[^ ]*]]: i32)657 // CHECK: emitc.cast [[Arg0]] : i32 to i64658 %extd = arith.extsi %arg0 : i32 to i64659 660 return661}662 663// -----664 665func.func @arith_extui(%arg0: i32) {666 // CHECK-LABEL: arith_extui667 // CHECK-SAME: (%[[Arg0:[^ ]*]]: i32)668 // CHECK: %[[Conv0:.*]] = emitc.cast %[[Arg0]] : i32 to ui32669 // CHECK: %[[Conv1:.*]] = emitc.cast %[[Conv0]] : ui32 to ui64670 // CHECK: emitc.cast %[[Conv1]] : ui64 to i64671 %extd = arith.extui %arg0 : i32 to i64672 673 return674}675 676// -----677 678func.func @arith_extui_i1_to_i32(%arg0: i1) {679 // CHECK-LABEL: arith_extui_i1_to_i32680 // CHECK-SAME: (%[[Arg0:[^ ]*]]: i1)681 // CHECK: %[[Conv0:.*]] = emitc.cast %[[Arg0]] : i1 to ui1682 // CHECK: %[[Conv1:.*]] = emitc.cast %[[Conv0]] : ui1 to ui32683 // CHECK: emitc.cast %[[Conv1]] : ui32 to i32684 %idx = arith.extui %arg0 : i1 to i32685 return686}687 688// -----689 690func.func @arith_index_cast(%arg0: i32) -> i32 {691 // CHECK-LABEL: arith_index_cast692 // CHECK-SAME: (%[[Arg0:[^ ]*]]: i32)693 // CHECK: %[[Conv0:.*]] = emitc.cast %[[Arg0]] : i32 to !emitc.ptrdiff_t694 // CHECK: %[[Conv1:.*]] = emitc.cast %[[Conv0]] : !emitc.ptrdiff_t to !emitc.size_t695 %idx = arith.index_cast %arg0 : i32 to index696 // CHECK: %[[Conv2:.*]] = emitc.cast %[[Conv1]] : !emitc.size_t to !emitc.ptrdiff_t697 // CHECK: %[[Conv3:.*]] = emitc.cast %[[Conv2]] : !emitc.ptrdiff_t to i32698 %int = arith.index_cast %idx : index to i32699 700 // CHECK: %[[Const:.*]] = "emitc.constant"701 // CHECK-SAME: value = 1702 // CHECK-SAME: () -> !emitc.size_t703 // CHECK: %[[AndOne:.*]] = emitc.bitwise_and %[[Conv1]], %[[Const]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t704 // CHECK: %[[Conv4:.*]] = emitc.cast %[[AndOne]] : !emitc.size_t to i1705 %bool = arith.index_cast %idx : index to i1706 707 return %int : i32708}709 710// -----711 712func.func @arith_index_castui(%arg0: i32) -> i32 {713 // CHECK-LABEL: arith_index_castui714 // CHECK-SAME: (%[[Arg0:[^ ]*]]: i32)715 // CHECK: %[[Conv0:.*]] = emitc.cast %[[Arg0]] : i32 to ui32716 // CHECK: %[[Conv1:.*]] = emitc.cast %[[Conv0]] : ui32 to !emitc.size_t717 %idx = arith.index_castui %arg0 : i32 to index718 // CHECK: %[[Conv2:.*]] = emitc.cast %[[Conv1]] : !emitc.size_t to ui32719 // CHECK: %[[Conv3:.*]] = emitc.cast %[[Conv2]] : ui32 to i32720 %int = arith.index_castui %idx : index to i32721 722 // CHECK: %[[Const:.*]] = "emitc.constant"723 // CHECK-SAME: value = 1724 // CHECK-SAME: () -> !emitc.size_t725 // CHECK: %[[AndOne:.*]] = emitc.bitwise_and %[[Conv1]], %[[Const]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t726 // CHECK: %[[Conv4:.*]] = emitc.cast %[[AndOne]] : !emitc.size_t to i1727 %bool = arith.index_castui %idx : index to i1728 729 return %int : i32730}731 732// -----733 734func.func @arith_divui_remui(%arg0: i32, %arg1: i32) -> i32 {735 // CHECK-LABEL: arith_divui_remui736 // CHECK-SAME: (%[[Arg0:[^ ]*]]: i32, %[[Arg1:[^ ]*]]: i32)737 // CHECK: %[[Conv0:.*]] = emitc.cast %[[Arg0]] : i32 to ui32738 // CHECK: %[[Conv1:.*]] = emitc.cast %[[Arg1]] : i32 to ui32739 // CHECK: %[[Div:.*]] = emitc.div %[[Conv0]], %[[Conv1]] : (ui32, ui32) -> ui32740 %div = arith.divui %arg0, %arg1 : i32741 742 // CHECK: %[[Conv2:.*]] = emitc.cast %[[Arg0]] : i32 to ui32743 // CHECK: %[[Conv3:.*]] = emitc.cast %[[Arg1]] : i32 to ui32744 // CHECK: %[[Rem:.*]] = emitc.rem %[[Conv2]], %[[Conv3]] : (ui32, ui32) -> ui32745 %rem = arith.remui %arg0, %arg1 : i32746 747 return %div : i32748}749 750// -----751 752func.func @arith_extf(%arg0: f16) -> f64 {753 // CHECK-LABEL: arith_extf754 // CHECK-SAME: (%[[Arg0:[^ ]*]]: f16)755 // CHECK: %[[Extd0:.*]] = emitc.cast %[[Arg0]] : f16 to f32756 %extd0 = arith.extf %arg0 : f16 to f32757 // CHECK: %[[Extd1:.*]] = emitc.cast %[[Extd0]] : f32 to f64758 %extd1 = arith.extf %extd0 : f32 to f64759 760 return %extd1 : f64761}762 763// -----764 765func.func @arith_truncf(%arg0: f64) -> f16 {766 // CHECK-LABEL: arith_truncf767 // CHECK-SAME: (%[[Arg0:[^ ]*]]: f64)768 // CHECK: %[[Truncd0:.*]] = emitc.cast %[[Arg0]] : f64 to f32769 %truncd0 = arith.truncf %arg0 : f64 to f32770 // CHECK: %[[Truncd1:.*]] = emitc.cast %[[Truncd0]] : f32 to f16771 %truncd1 = arith.truncf %truncd0 : f32 to f16772 773 return %truncd1 : f16774}775