1// RUN: mlir-opt -split-input-file -convert-arith-to-emitc %s | FileCheck %s 2 3// CHECK-LABEL: arith_constants 4func.func @arith_constants() { 5 // CHECK: emitc.constant 6 // CHECK-SAME: value = 0 7 // CHECK-SAME: () -> !emitc.size_t 8 %c_index = arith.constant 0 : index 9 // CHECK: emitc.constant 10 // CHECK-SAME: value = 0 : i32 11 %c_signless_int_32 = arith.constant 0 : i32 12 // CHECK: emitc.constant 13 // CHECK-SAME: value = 0.{{0+}}e+00 : f32 14 %c_float_32 = arith.constant 0.0 : f32 15 // CHECK: emitc.constant 16 // CHECK-SAME: value = dense<0> : tensor<i32> 17 %c_tensor_single_value = arith.constant dense<0> : tensor<i32> 18 // CHECK: emitc.constant 19 // CHECK-SAME: value{{.*}}[1, 2], [-3, 9], [0, 0], [2, -1]{{.*}}tensor<4x2xi64> 20 %c_tensor_value = arith.constant dense<[[1, 2], [-3, 9], [0, 0], [2, -1]]> : tensor<4x2xi64> 21 return 22} 23 24// ----- 25 26func.func @arith_ops(%arg0: f32, %arg1: f32) { 27 // CHECK: [[V0:[^ ]*]] = emitc.add %arg0, %arg1 : (f32, f32) -> f32 28 %0 = arith.addf %arg0, %arg1 : f32 29 // CHECK: [[V1:[^ ]*]] = emitc.div %arg0, %arg1 : (f32, f32) -> f32 30 %1 = arith.divf %arg0, %arg1 : f32 31 // CHECK: [[V2:[^ ]*]] = emitc.mul %arg0, %arg1 : (f32, f32) -> f32 32 %2 = arith.mulf %arg0, %arg1 : f32 33 // CHECK: [[V3:[^ ]*]] = emitc.sub %arg0, %arg1 : (f32, f32) -> f32 34 %3 = arith.subf %arg0, %arg1 : f32 35 36 return 37} 38 39// ----- 40 41// CHECK-LABEL: arith_integer_ops 42func.func @arith_integer_ops(%arg0: i32, %arg1: i32) { 43 // CHECK: %[[C1:[^ ]*]] = emitc.cast %arg0 : i32 to ui32 44 // CHECK: %[[C2:[^ ]*]] = emitc.cast %arg1 : i32 to ui32 45 // CHECK: %[[ADD:[^ ]*]] = emitc.add %[[C1]], %[[C2]] : (ui32, ui32) -> ui32 46 // CHECK: %[[C3:[^ ]*]] = emitc.cast %[[ADD]] : ui32 to i32 47 %0 = arith.addi %arg0, %arg1 : i32 48 // CHECK: %[[C1:[^ ]*]] = emitc.cast %arg0 : i32 to ui32 49 // CHECK: %[[C2:[^ ]*]] = emitc.cast %arg1 : i32 to ui32 50 // CHECK: %[[SUB:[^ ]*]] = emitc.sub %[[C1]], %[[C2]] : (ui32, ui32) -> ui32 51 // CHECK: %[[C3:[^ ]*]] = emitc.cast %[[SUB]] : ui32 to i32 52 %1 = arith.subi %arg0, %arg1 : i32 53 // CHECK: %[[C1:[^ ]*]] = emitc.cast %arg0 : i32 to ui32 54 // CHECK: %[[C2:[^ ]*]] = emitc.cast %arg1 : i32 to ui32 55 // CHECK: %[[MUL:[^ ]*]] = emitc.mul %[[C1]], %[[C2]] : (ui32, ui32) -> ui32 56 // CHECK: %[[C3:[^ ]*]] = emitc.cast %[[MUL]] : ui32 to i32 57 %2 = arith.muli %arg0, %arg1 : i32 58 59 return 60} 61 62// ----- 63 64// CHECK-LABEL: arith_integer_ops_signed_nsw 65func.func @arith_integer_ops_signed_nsw(%arg0: i32, %arg1: i32) { 66 // CHECK: emitc.add %arg0, %arg1 : (i32, i32) -> i32 67 %0 = arith.addi %arg0, %arg1 overflow<nsw> : i32 68 // CHECK: emitc.sub %arg0, %arg1 : (i32, i32) -> i32 69 %1 = arith.subi %arg0, %arg1 overflow<nsw> : i32 70 // CHECK: emitc.mul %arg0, %arg1 : (i32, i32) -> i32 71 %2 = arith.muli %arg0, %arg1 overflow<nsw> : i32 72 73 return 74} 75 76// ----- 77 78// CHECK-LABEL: arith_index 79func.func @arith_index(%arg0: i32, %arg1: i32) { 80 // CHECK: %[[CST0:.*]] = emitc.cast %{{.*}} : {{.*}} to !emitc.size_t 81 %cst0 = arith.index_cast %arg0 : i32 to index 82 // CHECK: %[[CST1:.*]] = emitc.cast %{{.*}} : {{.*}} to !emitc.size_t 83 %cst1 = arith.index_cast %arg1 : i32 to index 84 85 // CHECK: emitc.add %[[CST0]], %[[CST1]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t 86 %0 = arith.addi %cst0, %cst1 : index 87 // CHECK: emitc.sub %[[CST0]], %[[CST1]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t 88 %1 = arith.subi %cst0, %cst1 : index 89 // CHECK: emitc.mul %[[CST0]], %[[CST1]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t 90 %2 = arith.muli %cst0, %cst1 : index 91 92 return 93} 94 95// ----- 96 97// CHECK-LABEL: arith_bitwise 98// CHECK-SAME: %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32 99func.func @arith_bitwise(%arg0: i32, %arg1: i32) { 100 // CHECK: %[[C1:[^ ]*]] = emitc.cast %[[ARG0]] : i32 to ui32 101 // CHECK: %[[C2:[^ ]*]] = emitc.cast %[[ARG1]] : i32 to ui32 102 // CHECK: %[[AND:[^ ]*]] = emitc.bitwise_and %[[C1]], %[[C2]] : (ui32, ui32) -> ui32 103 // CHECK: %[[C3:[^ ]*]] = emitc.cast %[[AND]] : ui32 to i32 104 %0 = arith.andi %arg0, %arg1 : i32 105 // CHECK: %[[C1:[^ ]*]] = emitc.cast %[[ARG0]] : i32 to ui32 106 // CHECK: %[[C2:[^ ]*]] = emitc.cast %[[ARG1]] : i32 to ui32 107 // CHECK: %[[OR:[^ ]*]] = emitc.bitwise_or %[[C1]], %[[C2]] : (ui32, ui32) -> ui32 108 // CHECK: %[[C3:[^ ]*]] = emitc.cast %[[OR]] : ui32 to i32 109 %1 = arith.ori %arg0, %arg1 : i32 110 // CHECK: %[[C1:[^ ]*]] = emitc.cast %[[ARG0]] : i32 to ui32 111 // CHECK: %[[C2:[^ ]*]] = emitc.cast %[[ARG1]] : i32 to ui32 112 // CHECK: %[[XOR:[^ ]*]] = emitc.bitwise_xor %[[C1]], %[[C2]] : (ui32, ui32) -> ui32 113 // CHECK: %[[C3:[^ ]*]] = emitc.cast %[[XOR]] : ui32 to i32 114 %2 = arith.xori %arg0, %arg1 : i32 115 116 return 117} 118 119// ----- 120 121// CHECK-LABEL: arith_bitwise_bool 122// CHECK-SAME: %[[ARG0:.*]]: i1, %[[ARG1:.*]]: i1 123func.func @arith_bitwise_bool(%arg0: i1, %arg1: i1) { 124 // CHECK: %[[AND:[^ ]*]] = emitc.bitwise_and %[[ARG0]], %[[ARG1]] : (i1, i1) -> i1 125 %0 = arith.andi %arg0, %arg1 : i1 126 // CHECK: %[[OR:[^ ]*]] = emitc.bitwise_or %[[ARG0]], %[[ARG1]] : (i1, i1) -> i1 127 %1 = arith.ori %arg0, %arg1 : i1 128 // CHECK: %[[xor:[^ ]*]] = emitc.bitwise_xor %[[ARG0]], %[[ARG1]] : (i1, i1) -> i1 129 %2 = arith.xori %arg0, %arg1 : i1 130 131 return 132} 133 134// ----- 135 136// CHECK-LABEL: arith_signed_integer_div_rem 137func.func @arith_signed_integer_div_rem(%arg0: i32, %arg1: i32) { 138 // CHECK: emitc.div %arg0, %arg1 : (i32, i32) -> i32 139 %0 = arith.divsi %arg0, %arg1 : i32 140 // CHECK: emitc.rem %arg0, %arg1 : (i32, i32) -> i32 141 %1 = arith.remsi %arg0, %arg1 : i32 142 return 143} 144 145// ----- 146 147// CHECK-LABEL: arith_shift_left 148// CHECK-SAME: %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32 149func.func @arith_shift_left(%arg0: i32, %arg1: i32) { 150 // CHECK-DAG: %[[C1:[^ ]*]] = emitc.cast %[[ARG0]] : i32 to ui32 151 // CHECK-DAG: %[[C2:[^ ]*]] = emitc.cast %[[ARG1]] : i32 to ui32 152 // CHECK-DAG: %[[SizeConstant:[^ ]*]] = "emitc.constant"{{.*}}value = 32 153 // CHECK-DAG: %[[CmpNoExcess:[^ ]*]] = emitc.cmp lt, %[[C2]], %[[SizeConstant]] : (ui32, ui32) -> i1 154 // CHECK-DAG: %[[Zero:[^ ]*]] = "emitc.constant"{{.*}}value = 0 155 // CHECK: %[[ShiftRes:[^ ]*]] = emitc.expression : ui32 { 156 // CHECK-NEXT: %[[SHL:[^ ]*]] = bitwise_left_shift %[[C1]], %[[C2]] : (ui32, ui32) -> ui32 157 // CHECK-NEXT: %[[Ternary:[^ ]*]] = conditional %[[CmpNoExcess]], %[[SHL]], %[[Zero]] : ui32 158 // CHECK-NEXT: yield %[[Ternary]] : ui32 159 // CHECK-NEXT: } 160 // CHECK-NEXT: emitc.cast %[[ShiftRes]] : ui32 to i32 161 %1 = arith.shli %arg0, %arg1 : i32 162 return 163} 164 165// ----- 166 167// CHECK-LABEL: arith_shift_right 168// CHECK-SAME: %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32 169func.func @arith_shift_right(%arg0: i32, %arg1: i32) { 170 // CHECK-DAG: %[[C1:[^ ]*]] = emitc.cast %[[ARG0]] : i32 to ui32 171 // CHECK-DAG: %[[C2:[^ ]*]] = emitc.cast %[[ARG1]] : i32 to ui32 172 // CHECK-DAG: %[[SizeConstant:[^ ]*]] = "emitc.constant"{{.*}}value = 32{{.*}}ui32 173 // CHECK-DAG: %[[CmpNoExcess:[^ ]*]] = emitc.cmp lt, %[[C2]], %[[SizeConstant]] : (ui32, ui32) -> i1 174 // CHECK-DAG: %[[Zero:[^ ]*]] = "emitc.constant"{{.*}}value = 0{{.*}}ui32 175 // CHECK: %[[ShiftRes:[^ ]*]] = emitc.expression : ui32 { 176 // CHECK-NEXT: %[[SHR:[^ ]*]] = bitwise_right_shift %[[C1]], %[[C2]] : (ui32, ui32) -> ui32 177 // CHECK-NEXT: %[[Ternary:[^ ]*]] = conditional %[[CmpNoExcess]], %[[SHR]], %[[Zero]] : ui32 178 // CHECK-NEXT: yield %[[Ternary]] : ui32 179 // CHECK-NEXT: } 180 // CHECK-NEXT: emitc.cast %[[ShiftRes]] : ui32 to i32 181 %2 = arith.shrui %arg0, %arg1 : i32 182 183 // CHECK-DAG: %[[SC2:[^ ]*]] = emitc.cast %[[ARG1]] : i32 to ui32 184 // CHECK-DAG: %[[SSizeConstant:[^ ]*]] = "emitc.constant"{{.*}}value = 32{{.*}}ui32 185 // CHECK-DAG: %[[SCmpNoExcess:[^ ]*]] = emitc.cmp lt, %[[SC2]], %[[SSizeConstant]] : (ui32, ui32) -> i1 186 // CHECK-DAG: %[[SZero:[^ ]*]] = "emitc.constant"{{.*}}value = 0{{.*}}i32 187 // CHECK: %[[SShiftRes:[^ ]*]] = emitc.expression : i32 { 188 // CHECK-NEXT: %[[SHRSI:[^ ]*]] = bitwise_right_shift %[[ARG0]], %[[SC2]] : (i32, ui32) -> i32 189 // CHECK-NEXT: %[[STernary:[^ ]*]] = conditional %[[SCmpNoExcess]], %[[SHRSI]], %[[SZero]] : i32 190 // CHECK-NEXT: yield %[[STernary]] : i32 191 // CHECK-NEXT: } 192 %3 = arith.shrsi %arg0, %arg1 : i32 193 194 return 195} 196 197// ----- 198 199// CHECK-LABEL: arith_shift_left_index 200// CHECK-SAME: %[[AMOUNT:.*]]: i32 201func.func @arith_shift_left_index(%amount: i32) { 202 %cst0 = "arith.constant"() {value = 42 : index} : () -> (index) 203 %cast1 = arith.index_cast %amount : i32 to index 204 // CHECK-DAG: %[[C1:[^ ]*]] = "emitc.constant"(){{.*}}value = 42{{.*}}!emitc.size_t 205 // CHECK-DAG: %[[Cast1:[^ ]*]] = emitc.cast %[[AMOUNT]] : i32 to !emitc.ptrdiff_t 206 // CHECK-DAG: %[[AmountIdx:[^ ]*]] = emitc.cast %[[Cast1]] : !emitc.ptrdiff_t to !emitc.size_t 207 // CHECK-DAG: %[[Byte:[^ ]*]] = "emitc.constant"{{.*}}value = 8{{.*}}index 208 // CHECK-DAG: %[[SizeOf:[^ ]*]] = emitc.call_opaque "sizeof"(%[[Byte]]) : (!emitc.size_t) -> !emitc.size_t 209 // CHECK-DAG: %[[SizeConstant:[^ ]*]] = emitc.mul %[[Byte]], %[[SizeOf]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t 210 // CHECK-DAG: %[[CmpNoExcess:[^ ]*]] = emitc.cmp lt, %[[AmountIdx]], %[[SizeConstant]] : (!emitc.size_t, !emitc.size_t) -> i1 211 // CHECK-DAG: %[[Zero:[^ ]*]] = "emitc.constant"{{.*}}value = 0 212 // CHECK: %[[ShiftRes:[^ ]*]] = emitc.expression : !emitc.size_t { 213 // CHECK-NEXT: %[[SHL:[^ ]*]] = bitwise_left_shift %[[C1]], %[[AmountIdx]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t 214 // CHECK-NEXT: %[[Ternary:[^ ]*]] = conditional %[[CmpNoExcess]], %[[SHL]], %[[Zero]] : !emitc.size_t 215 // CHECK-NEXT: yield %[[Ternary]] : !emitc.size_t 216 // CHECK-NEXT: } 217 %1 = arith.shli %cst0, %cast1 : index 218 return 219} 220 221// ----- 222 223// CHECK-LABEL: arith_shift_right_index 224// CHECK-SAME: %[[AMOUNT:.*]]: i32 225func.func @arith_shift_right_index(%amount: i32) { 226 // CHECK-DAG: %[[C1:[^ ]*]] = "emitc.constant"(){{.*}}value = 42{{.*}}!emitc.size_t 227 // CHECK-DAG: %[[Cast1:[^ ]*]] = emitc.cast %[[AMOUNT]] : i32 to !emitc.ptrdiff_t 228 // CHECK-DAG: %[[AmountIdx:[^ ]*]] = emitc.cast %[[Cast1]] : !emitc.ptrdiff_t to !emitc.size_t 229 %arg0 = "arith.constant"() {value = 42 : index} : () -> (index) 230 %arg1 = arith.index_cast %amount : i32 to index 231 232 // CHECK-DAG: %[[Byte:[^ ]*]] = "emitc.constant"{{.*}}value = 8{{.*}}index 233 // CHECK-DAG: %[[SizeOf:[^ ]*]] = emitc.call_opaque "sizeof"(%[[Byte]]) : (!emitc.size_t) -> !emitc.size_t 234 // CHECK-DAG: %[[SizeConstant:[^ ]*]] = emitc.mul %[[Byte]], %[[SizeOf]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t 235 // CHECK-DAG: %[[CmpNoExcess:[^ ]*]] = emitc.cmp lt, %[[AmountIdx]], %[[SizeConstant]] : (!emitc.size_t, !emitc.size_t) -> i1 236 // CHECK-DAG: %[[Zero:[^ ]*]] = "emitc.constant"{{.*}}value = 0{{.*}}!emitc.size_t 237 // CHECK: %[[ShiftRes:[^ ]*]] = emitc.expression : !emitc.size_t { 238 // CHECK-NEXT: %[[SHR:[^ ]*]] = bitwise_right_shift %[[C1]], %[[AmountIdx]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t 239 // CHECK-NEXT: %[[Ternary:[^ ]*]] = conditional %[[CmpNoExcess]], %[[SHR]], %[[Zero]] : !emitc.size_t 240 // CHECK-NEXT: yield %[[Ternary]] : !emitc.size_t 241 // CHECK-NEXT: } 242 %2 = arith.shrui %arg0, %arg1 : index 243 244 // CHECK-DAG: %[[SC1:[^ ]*]] = emitc.cast %[[C1]] : !emitc.size_t to !emitc.ptrdiff_t 245 // CHECK-DAG: %[[SByte:[^ ]*]] = "emitc.constant"{{.*}}value = 8{{.*}}index{{.*}}!emitc.size_t 246 // CHECK-DAG: %[[SSizeOf:[^ ]*]] = emitc.call_opaque "sizeof"(%[[SByte]]) : (!emitc.size_t) -> !emitc.size_t 247 // CHECK-DAG: %[[SSizeConstant:[^ ]*]] = emitc.mul %[[SByte]], %[[SSizeOf]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t 248 // CHECK-DAG: %[[SCmpNoExcess:[^ ]*]] = emitc.cmp lt, %[[AmountIdx]], %[[SSizeConstant]] : (!emitc.size_t, !emitc.size_t) -> i1 249 // CHECK-DAG: %[[SZero:[^ ]*]] = "emitc.constant"{{.*}}value = 0{{.*}}!emitc.ptrdiff_t 250 // CHECK: %[[SShiftRes:[^ ]*]] = emitc.expression : !emitc.ptrdiff_t { 251 // CHECK-NEXT: %[[SHRSI:[^ ]*]] = bitwise_right_shift %[[SC1]], %[[AmountIdx]] : (!emitc.ptrdiff_t, !emitc.size_t) -> !emitc.ptrdiff_t 252 // CHECK-NEXT: %[[STernary:[^ ]*]] = conditional %[[SCmpNoExcess]], %[[SHRSI]], %[[SZero]] : !emitc.ptrdiff_t 253 // CHECK-NEXT: yield %[[STernary]] : !emitc.ptrdiff_t 254 // CHECK-NEXT: } 255 // CHECK-NEXT: emitc.cast %[[SShiftRes]] : !emitc.ptrdiff_t to !emitc.size_t 256 %3 = arith.shrsi %arg0, %arg1 : index 257 258 return 259} 260 261// ----- 262 263func.func @arith_select(%arg0: i1, %arg1: tensor<8xi32>, %arg2: tensor<8xi32>) -> () { 264 // CHECK: [[V0:[^ ]*]] = emitc.conditional %arg0, %arg1, %arg2 : tensor<8xi32> 265 %0 = arith.select %arg0, %arg1, %arg2 : i1, tensor<8xi32> 266 return 267} 268 269// ----- 270 271func.func @arith_cmpf_false(%arg0: f32, %arg1: f32) -> i1 { 272 // CHECK-LABEL: arith_cmpf_false 273 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32) 274 // CHECK-DAG: [[False:[^ ]*]] = "emitc.constant"() <{value = false}> : () -> i1 275 %false = arith.cmpf false, %arg0, %arg1 : f32 276 // CHECK: return [[False]] 277 return %false: i1 278} 279 280// ----- 281 282func.func @arith_cmpf_oeq(%arg0: f32, %arg1: f32) -> i1 { 283 // CHECK-LABEL: arith_cmpf_oeq 284 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32) 285 // CHECK-DAG: [[EQ:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg1]] : (f32, f32) -> i1 286 // CHECK-DAG: [[NotNaNArg0:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg0]] : (f32, f32) -> i1 287 // CHECK-DAG: [[NotNaNArg1:[^ ]*]] = emitc.cmp eq, [[Arg1]], [[Arg1]] : (f32, f32) -> i1 288 // CHECK-DAG: [[Ordered:[^ ]*]] = emitc.logical_and [[NotNaNArg0]], [[NotNaNArg1]] : i1, i1 289 // CHECK-DAG: [[OEQ:[^ ]*]] = emitc.logical_and [[Ordered]], [[EQ]] : i1, i1 290 %oeq = arith.cmpf oeq, %arg0, %arg1 : f32 291 // CHECK: return [[OEQ]] 292 return %oeq: i1 293} 294 295// ----- 296 297func.func @arith_cmpf_ogt(%arg0: f32, %arg1: f32) -> i1 { 298 // CHECK-LABEL: arith_cmpf_ogt 299 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32) 300 // CHECK-DAG: [[GT:[^ ]*]] = emitc.cmp gt, [[Arg0]], [[Arg1]] : (f32, f32) -> i1 301 // CHECK-DAG: [[NotNaNArg0:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg0]] : (f32, f32) -> i1 302 // CHECK-DAG: [[NotNaNArg1:[^ ]*]] = emitc.cmp eq, [[Arg1]], [[Arg1]] : (f32, f32) -> i1 303 // CHECK-DAG: [[Ordered:[^ ]*]] = emitc.logical_and [[NotNaNArg0]], [[NotNaNArg1]] : i1, i1 304 // CHECK-DAG: [[OGT:[^ ]*]] = emitc.logical_and [[Ordered]], [[GT]] : i1, i1 305 %ogt = arith.cmpf ogt, %arg0, %arg1 : f32 306 // CHECK: return [[OGT]] 307 return %ogt: i1 308} 309 310// ----- 311 312func.func @arith_cmpf_oge(%arg0: f32, %arg1: f32) -> i1 { 313 // CHECK-LABEL: arith_cmpf_oge 314 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32) 315 // CHECK-DAG: [[GE:[^ ]*]] = emitc.cmp ge, [[Arg0]], [[Arg1]] : (f32, f32) -> i1 316 // CHECK-DAG: [[NotNaNArg0:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg0]] : (f32, f32) -> i1 317 // CHECK-DAG: [[NotNaNArg1:[^ ]*]] = emitc.cmp eq, [[Arg1]], [[Arg1]] : (f32, f32) -> i1 318 // CHECK-DAG: [[Ordered:[^ ]*]] = emitc.logical_and [[NotNaNArg0]], [[NotNaNArg1]] : i1, i1 319 // CHECK-DAG: [[OGE:[^ ]*]] = emitc.logical_and [[Ordered]], [[GE]] : i1, i1 320 %oge = arith.cmpf oge, %arg0, %arg1 : f32 321 // CHECK: return [[OGE]] 322 return %oge: i1 323} 324 325// ----- 326 327func.func @arith_cmpf_olt(%arg0: f32, %arg1: f32) -> i1 { 328 // CHECK-LABEL: arith_cmpf_olt 329 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32) 330 // CHECK-DAG: [[LT:[^ ]*]] = emitc.cmp lt, [[Arg0]], [[Arg1]] : (f32, f32) -> i1 331 // CHECK-DAG: [[NotNaNArg0:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg0]] : (f32, f32) -> i1 332 // CHECK-DAG: [[NotNaNArg1:[^ ]*]] = emitc.cmp eq, [[Arg1]], [[Arg1]] : (f32, f32) -> i1 333 // CHECK-DAG: [[Ordered:[^ ]*]] = emitc.logical_and [[NotNaNArg0]], [[NotNaNArg1]] : i1, i1 334 // CHECK-DAG: [[OLT:[^ ]*]] = emitc.logical_and [[Ordered]], [[LT]] : i1, i1 335 %olt = arith.cmpf olt, %arg0, %arg1 : f32 336 // CHECK: return [[OLT]] 337 return %olt: i1 338} 339 340// ----- 341 342func.func @arith_cmpf_ole(%arg0: f32, %arg1: f32) -> i1 { 343 // CHECK-LABEL: arith_cmpf_ole 344 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32) 345 // CHECK-DAG: [[LT:[^ ]*]] = emitc.cmp le, [[Arg0]], [[Arg1]] : (f32, f32) -> i1 346 // CHECK-DAG: [[NotNaNArg0:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg0]] : (f32, f32) -> i1 347 // CHECK-DAG: [[NotNaNArg1:[^ ]*]] = emitc.cmp eq, [[Arg1]], [[Arg1]] : (f32, f32) -> i1 348 // CHECK-DAG: [[Ordered:[^ ]*]] = emitc.logical_and [[NotNaNArg0]], [[NotNaNArg1]] : i1, i1 349 // CHECK-DAG: [[OLE:[^ ]*]] = emitc.logical_and [[Ordered]], [[LT]] : i1, i1 350 %ole = arith.cmpf ole, %arg0, %arg1 : f32 351 // CHECK: return [[OLE]] 352 return %ole: i1 353} 354 355// ----- 356 357func.func @arith_cmpf_one(%arg0: f32, %arg1: f32) -> i1 { 358 // CHECK-LABEL: arith_cmpf_one 359 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32) 360 // CHECK-DAG: [[NEQ:[^ ]*]] = emitc.cmp ne, [[Arg0]], [[Arg1]] : (f32, f32) -> i1 361 // CHECK-DAG: [[NotNaNArg0:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg0]] : (f32, f32) -> i1 362 // CHECK-DAG: [[NotNaNArg1:[^ ]*]] = emitc.cmp eq, [[Arg1]], [[Arg1]] : (f32, f32) -> i1 363 // CHECK-DAG: [[Ordered:[^ ]*]] = emitc.logical_and [[NotNaNArg0]], [[NotNaNArg1]] : i1, i1 364 // CHECK-DAG: [[ONE:[^ ]*]] = emitc.logical_and [[Ordered]], [[NEQ]] : i1, i1 365 %one = arith.cmpf one, %arg0, %arg1 : f32 366 // CHECK: return [[ONE]] 367 return %one: i1 368} 369 370// ----- 371 372func.func @arith_cmpf_ord(%arg0: f32, %arg1: f32) -> i1 { 373 // CHECK-LABEL: arith_cmpf_ord 374 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32) 375 // CHECK-DAG: [[NotNaNArg0:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg0]] : (f32, f32) -> i1 376 // CHECK-DAG: [[NotNaNArg1:[^ ]*]] = emitc.cmp eq, [[Arg1]], [[Arg1]] : (f32, f32) -> i1 377 // CHECK-DAG: [[Ordered:[^ ]*]] = emitc.logical_and [[NotNaNArg0]], [[NotNaNArg1]] : i1, i1 378 %ord = arith.cmpf ord, %arg0, %arg1 : f32 379 // CHECK: return [[Ordered]] 380 return %ord: i1 381} 382 383// ----- 384 385func.func @arith_cmpf_ueq(%arg0: f32, %arg1: f32) -> i1 { 386 // CHECK-LABEL: arith_cmpf_ueq 387 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32) 388 // CHECK-DAG: [[EQ:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg1]] : (f32, f32) -> i1 389 // CHECK-DAG: [[NaNArg0:[^ ]*]] = emitc.cmp ne, [[Arg0]], [[Arg0]] : (f32, f32) -> i1 390 // CHECK-DAG: [[NaNArg1:[^ ]*]] = emitc.cmp ne, [[Arg1]], [[Arg1]] : (f32, f32) -> i1 391 // CHECK-DAG: [[Unordered:[^ ]*]] = emitc.logical_or [[NaNArg0]], [[NaNArg1]] : i1, i1 392 // CHECK-DAG: [[UEQ:[^ ]*]] = emitc.logical_or [[Unordered]], [[EQ]] : i1, i1 393 %ueq = arith.cmpf ueq, %arg0, %arg1 : f32 394 // CHECK: return [[UEQ]] 395 return %ueq: i1 396} 397 398// ----- 399 400func.func @arith_cmpf_ugt(%arg0: f32, %arg1: f32) -> i1 { 401 // CHECK-LABEL: arith_cmpf_ugt 402 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32) 403 // CHECK-DAG: [[GT:[^ ]*]] = emitc.cmp gt, [[Arg0]], [[Arg1]] : (f32, f32) -> i1 404 // CHECK-DAG: [[NaNArg0:[^ ]*]] = emitc.cmp ne, [[Arg0]], [[Arg0]] : (f32, f32) -> i1 405 // CHECK-DAG: [[NaNArg1:[^ ]*]] = emitc.cmp ne, [[Arg1]], [[Arg1]] : (f32, f32) -> i1 406 // CHECK-DAG: [[Unordered:[^ ]*]] = emitc.logical_or [[NaNArg0]], [[NaNArg1]] : i1, i1 407 // CHECK-DAG: [[UGT:[^ ]*]] = emitc.logical_or [[Unordered]], [[GT]] : i1, i1 408 %ugt = arith.cmpf ugt, %arg0, %arg1 : f32 409 // CHECK: return [[UGT]] 410 return %ugt: i1 411} 412 413// ----- 414 415func.func @arith_cmpf_uge(%arg0: f32, %arg1: f32) -> i1 { 416 // CHECK-LABEL: arith_cmpf_uge 417 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32) 418 // CHECK-DAG: [[GE:[^ ]*]] = emitc.cmp ge, [[Arg0]], [[Arg1]] : (f32, f32) -> i1 419 // CHECK-DAG: [[NaNArg0:[^ ]*]] = emitc.cmp ne, [[Arg0]], [[Arg0]] : (f32, f32) -> i1 420 // CHECK-DAG: [[NaNArg1:[^ ]*]] = emitc.cmp ne, [[Arg1]], [[Arg1]] : (f32, f32) -> i1 421 // CHECK-DAG: [[Unordered:[^ ]*]] = emitc.logical_or [[NaNArg0]], [[NaNArg1]] : i1, i1 422 // CHECK-DAG: [[UGE:[^ ]*]] = emitc.logical_or [[Unordered]], [[GE]] : i1, i1 423 %uge = arith.cmpf uge, %arg0, %arg1 : f32 424 // CHECK: return [[UGE]] 425 return %uge: i1 426} 427 428// ----- 429 430func.func @arith_cmpf_ult(%arg0: f32, %arg1: f32) -> i1 { 431 // CHECK-LABEL: arith_cmpf_ult 432 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32) 433 // CHECK-DAG: [[LT:[^ ]*]] = emitc.cmp lt, [[Arg0]], [[Arg1]] : (f32, f32) -> i1 434 // CHECK-DAG: [[NaNArg0:[^ ]*]] = emitc.cmp ne, [[Arg0]], [[Arg0]] : (f32, f32) -> i1 435 // CHECK-DAG: [[NaNArg1:[^ ]*]] = emitc.cmp ne, [[Arg1]], [[Arg1]] : (f32, f32) -> i1 436 // CHECK-DAG: [[Unordered:[^ ]*]] = emitc.logical_or [[NaNArg0]], [[NaNArg1]] : i1, i1 437 // CHECK-DAG: [[ULT:[^ ]*]] = emitc.logical_or [[Unordered]], [[LT]] : i1, i1 438 %ult = arith.cmpf ult, %arg0, %arg1 : f32 439 // CHECK: return [[ULT]] 440 return %ult: i1 441} 442 443// ----- 444 445func.func @arith_cmpf_ule(%arg0: f32, %arg1: f32) -> i1 { 446 // CHECK-LABEL: arith_cmpf_ule 447 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32) 448 // CHECK-DAG: [[LE:[^ ]*]] = emitc.cmp le, [[Arg0]], [[Arg1]] : (f32, f32) -> i1 449 // CHECK-DAG: [[NaNArg0:[^ ]*]] = emitc.cmp ne, [[Arg0]], [[Arg0]] : (f32, f32) -> i1 450 // CHECK-DAG: [[NaNArg1:[^ ]*]] = emitc.cmp ne, [[Arg1]], [[Arg1]] : (f32, f32) -> i1 451 // CHECK-DAG: [[Unordered:[^ ]*]] = emitc.logical_or [[NaNArg0]], [[NaNArg1]] : i1, i1 452 // CHECK-DAG: [[ULE:[^ ]*]] = emitc.logical_or [[Unordered]], [[LE]] : i1, i1 453 %ule = arith.cmpf ule, %arg0, %arg1 : f32 454 // CHECK: return [[ULE]] 455 return %ule: i1 456} 457 458// ----- 459 460func.func @arith_cmpf_une(%arg0: f32, %arg1: f32) -> i1 { 461 // CHECK-LABEL: arith_cmpf_une 462 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32) 463 // CHECK-DAG: [[NEQ:[^ ]*]] = emitc.cmp ne, [[Arg0]], [[Arg1]] : (f32, f32) -> i1 464 // CHECK-DAG: [[NaNArg0:[^ ]*]] = emitc.cmp ne, [[Arg0]], [[Arg0]] : (f32, f32) -> i1 465 // CHECK-DAG: [[NaNArg1:[^ ]*]] = emitc.cmp ne, [[Arg1]], [[Arg1]] : (f32, f32) -> i1 466 // CHECK-DAG: [[Unordered:[^ ]*]] = emitc.logical_or [[NaNArg0]], [[NaNArg1]] : i1, i1 467 // CHECK-DAG: [[UNE:[^ ]*]] = emitc.logical_or [[Unordered]], [[NEQ]] : i1, i1 468 %une = arith.cmpf une, %arg0, %arg1 : f32 469 // CHECK: return [[UNE]] 470 return %une: i1 471} 472 473// ----- 474 475func.func @arith_cmpf_uno(%arg0: f32, %arg1: f32) -> i1 { 476 // CHECK-LABEL: arith_cmpf_uno 477 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32) 478 // CHECK-DAG: [[NaNArg0:[^ ]*]] = emitc.cmp ne, [[Arg0]], [[Arg0]] : (f32, f32) -> i1 479 // CHECK-DAG: [[NaNArg1:[^ ]*]] = emitc.cmp ne, [[Arg1]], [[Arg1]] : (f32, f32) -> i1 480 // CHECK-DAG: [[Unordered:[^ ]*]] = emitc.logical_or [[NaNArg0]], [[NaNArg1]] : i1, i1 481 %uno = arith.cmpf uno, %arg0, %arg1 : f32 482 // CHECK: return [[Unordered]] 483 return %uno: i1 484} 485 486// ----- 487 488func.func @arith_cmpf_true(%arg0: f32, %arg1: f32) -> i1 { 489 // CHECK-LABEL: arith_cmpf_true 490 // CHECK-SAME: ([[Arg0:[^ ]*]]: f32, [[Arg1:[^ ]*]]: f32) 491 // CHECK-DAG: [[True:[^ ]*]] = "emitc.constant"() <{value = true}> : () -> i1 492 %ueq = arith.cmpf true, %arg0, %arg1 : f32 493 // CHECK: return [[True]] 494 return %ueq: i1 495} 496 497// ----- 498 499func.func @arith_cmpi_eq(%arg0: i32, %arg1: i32) -> i1 { 500 // CHECK-LABEL: arith_cmpi_eq 501 // CHECK-SAME: ([[Arg0:[^ ]*]]: i32, [[Arg1:[^ ]*]]: i32) 502 // CHECK-DAG: [[EQ:[^ ]*]] = emitc.cmp eq, [[Arg0]], [[Arg1]] : (i32, i32) -> i1 503 %eq = arith.cmpi eq, %arg0, %arg1 : i32 504 // CHECK: return [[EQ]] 505 return %eq: i1 506} 507 508func.func @arith_cmpi_ult(%arg0: i32, %arg1: i32) -> i1 { 509 // CHECK-LABEL: arith_cmpi_ult 510 // CHECK-SAME: ([[Arg0:[^ ]*]]: i32, [[Arg1:[^ ]*]]: i32) 511 // CHECK-DAG: [[CastArg0:[^ ]*]] = emitc.cast [[Arg0]] : i32 to ui32 512 // CHECK-DAG: [[CastArg1:[^ ]*]] = emitc.cast [[Arg1]] : i32 to ui32 513 // CHECK-DAG: [[ULT:[^ ]*]] = emitc.cmp lt, [[CastArg0]], [[CastArg1]] : (ui32, ui32) -> i1 514 %ult = arith.cmpi ult, %arg0, %arg1 : i32 515 516 // CHECK: return [[ULT]] 517 return %ult: i1 518} 519 520func.func @arith_cmpi_predicates(%arg0: i32, %arg1: i32) { 521 // CHECK: emitc.cmp lt, {{.*}} : (ui32, ui32) -> i1 522 %ult = arith.cmpi ult, %arg0, %arg1 : i32 523 // CHECK: emitc.cmp lt, {{.*}} : (i32, i32) -> i1 524 %slt = arith.cmpi slt, %arg0, %arg1 : i32 525 // CHECK: emitc.cmp le, {{.*}} : (ui32, ui32) -> i1 526 %ule = arith.cmpi ule, %arg0, %arg1 : i32 527 // CHECK: emitc.cmp le, {{.*}} : (i32, i32) -> i1 528 %sle = arith.cmpi sle, %arg0, %arg1 : i32 529 // CHECK: emitc.cmp gt, {{.*}} : (ui32, ui32) -> i1 530 %ugt = arith.cmpi ugt, %arg0, %arg1 : i32 531 // CHECK: emitc.cmp gt, {{.*}} : (i32, i32) -> i1 532 %sgt = arith.cmpi sgt, %arg0, %arg1 : i32 533 // CHECK: emitc.cmp ge, {{.*}} : (ui32, ui32) -> i1 534 %uge = arith.cmpi uge, %arg0, %arg1 : i32 535 // CHECK: emitc.cmp ge, {{.*}} : (i32, i32) -> i1 536 %sge = arith.cmpi sge, %arg0, %arg1 : i32 537 // CHECK: emitc.cmp eq, {{.*}} : (i32, i32) -> i1 538 %eq = arith.cmpi eq, %arg0, %arg1 : i32 539 // CHECK: emitc.cmp ne, {{.*}} : (i32, i32) -> i1 540 %ne = arith.cmpi ne, %arg0, %arg1 : i32 541 542 return 543} 544 545func.func @arith_cmpi_index(%arg0: i32, %arg1: i32) -> i1 { 546 // CHECK-LABEL: arith_cmpi_index 547 548 // CHECK: %[[Cst0:.*]] = emitc.cast %{{.*}} : {{.*}} to !emitc.size_t 549 %idx0 = arith.index_cast %arg0 : i32 to index 550 // CHECK: %[[Cst1:.*]] = emitc.cast %{{.*}} : {{.*}} to !emitc.size_t 551 %idx1 = arith.index_cast %arg0 : i32 to index 552 553 // CHECK-DAG: [[ULT:[^ ]*]] = emitc.cmp lt, %[[Cst0]], %[[Cst1]] : (!emitc.size_t, !emitc.size_t) -> i1 554 %ult = arith.cmpi ult, %idx0, %idx1 : index 555 556 // CHECK-DAG: %[[CastArg0:[^ ]*]] = emitc.cast %[[Cst0]] : !emitc.size_t to !emitc.ptrdiff_t 557 // CHECK-DAG: %[[CastArg1:[^ ]*]] = emitc.cast %[[Cst1]] : !emitc.size_t to !emitc.ptrdiff_t 558 // CHECK-DAG: %[[SLT:[^ ]*]] = emitc.cmp lt, %[[CastArg0]], %[[CastArg1]] : (!emitc.ptrdiff_t, !emitc.ptrdiff_t) -> i1 559 %slt = arith.cmpi slt, %idx0, %idx1 : index 560 561 // CHECK: return %[[SLT]] 562 return %slt: i1 563} 564 565 566// ----- 567 568func.func @arith_negf(%arg0: f32) -> f32 { 569 // CHECK-LABEL: arith_negf 570 // CHECK-SAME: %[[Arg0:[^ ]*]]: f32 571 // CHECK: %[[N:[^ ]*]] = emitc.unary_minus %[[Arg0]] : (f32) -> f32 572 %n = arith.negf %arg0 : f32 573 // CHECK: return %[[N]] 574 return %n: f32 575} 576 577// ----- 578 579func.func @arith_float_to_int_cast_ops(%arg0: f32, %arg1: f64) { 580 // CHECK: emitc.cast %arg0 : f32 to i32 581 %0 = arith.fptosi %arg0 : f32 to i32 582 583 // CHECK: emitc.cast %arg1 : f64 to i32 584 %1 = arith.fptosi %arg1 : f64 to i32 585 586 // CHECK: emitc.cast %arg0 : f32 to i16 587 %2 = arith.fptosi %arg0 : f32 to i16 588 589 // CHECK: emitc.cast %arg1 : f64 to i16 590 %3 = arith.fptosi %arg1 : f64 to i16 591 592 // CHECK: %[[CAST0:.*]] = emitc.cast %arg0 : f32 to ui32 593 // CHECK: emitc.cast %[[CAST0]] : ui32 to i32 594 %4 = arith.fptoui %arg0 : f32 to i32 595 596 // CHECK: %[[CAST0:.*]] = emitc.cast %arg0 : f32 to ui16 597 // CHECK: emitc.cast %[[CAST0]] : ui16 to i16 598 %5 = arith.fptoui %arg0 : f32 to i16 599 600 return 601} 602 603func.func @arith_int_to_float_cast_ops(%arg0: i8, %arg1: i64) { 604 // CHECK: emitc.cast %arg0 : i8 to f32 605 %0 = arith.sitofp %arg0 : i8 to f32 606 607 // CHECK: emitc.cast %arg1 : i64 to f32 608 %1 = arith.sitofp %arg1 : i64 to f32 609 610 // CHECK: %[[CAST_UNS:.*]] = emitc.cast %arg0 : i8 to ui8 611 // CHECK: emitc.cast %[[CAST_UNS]] : ui8 to f32 612 %2 = arith.uitofp %arg0 : i8 to f32 613 614 return 615} 616 617// ----- 618 619func.func @arith_trunci(%arg0: i32) -> i8 { 620 // CHECK-LABEL: arith_trunci 621 // CHECK-SAME: (%[[Arg0:[^ ]*]]: i32) 622 // CHECK: %[[CastUI:.*]] = emitc.cast %[[Arg0]] : i32 to ui32 623 // CHECK: %[[Trunc:.*]] = emitc.cast %[[CastUI]] : ui32 to ui8 624 // CHECK: emitc.cast %[[Trunc]] : ui8 to i8 625 %truncd = arith.trunci %arg0 : i32 to i8 626 627 // CHECK: %[[Const:.*]] = "emitc.constant" 628 // CHECK-SAME: value = 1 629 // CHECK-SAME: () -> i32 630 // CHECK: %[[AndOne:.*]] = emitc.bitwise_and %[[Arg0]], %[[Const]] : (i32, i32) -> i32 631 // CHECK: %[[Conv:.*]] = emitc.cast %[[AndOne]] : i32 to i1 632 %bool = arith.trunci %arg0 : i32 to i1 633 634 return %truncd : i8 635} 636 637// ----- 638 639func.func @arith_trunci_to_i1(%arg0: i32) -> i1 { 640 // CHECK-LABEL: arith_trunci_to_i1 641 // CHECK-SAME: (%[[Arg0:[^ ]*]]: i32) 642 // CHECK: %[[Const:.*]] = "emitc.constant" 643 // CHECK-SAME: value = 1 644 // CHECK: %[[And:.*]] = emitc.bitwise_and %[[Arg0]], %[[Const]] : (i32, i32) -> i32 645 // CHECK: emitc.cast %[[And]] : i32 to i1 646 %truncd = arith.trunci %arg0 : i32 to i1 647 648 return %truncd : i1 649} 650 651// ----- 652 653func.func @arith_extsi(%arg0: i32) { 654 // CHECK-LABEL: arith_extsi 655 // CHECK-SAME: ([[Arg0:[^ ]*]]: i32) 656 // CHECK: emitc.cast [[Arg0]] : i32 to i64 657 %extd = arith.extsi %arg0 : i32 to i64 658 659 return 660} 661 662// ----- 663 664func.func @arith_extui(%arg0: i32) { 665 // CHECK-LABEL: arith_extui 666 // CHECK-SAME: (%[[Arg0:[^ ]*]]: i32) 667 // CHECK: %[[Conv0:.*]] = emitc.cast %[[Arg0]] : i32 to ui32 668 // CHECK: %[[Conv1:.*]] = emitc.cast %[[Conv0]] : ui32 to ui64 669 // CHECK: emitc.cast %[[Conv1]] : ui64 to i64 670 %extd = arith.extui %arg0 : i32 to i64 671 672 return 673} 674 675// ----- 676 677func.func @arith_extui_i1_to_i32(%arg0: i1) { 678 // CHECK-LABEL: arith_extui_i1_to_i32 679 // CHECK-SAME: (%[[Arg0:[^ ]*]]: i1) 680 // CHECK: %[[Conv0:.*]] = emitc.cast %[[Arg0]] : i1 to ui1 681 // CHECK: %[[Conv1:.*]] = emitc.cast %[[Conv0]] : ui1 to ui32 682 // CHECK: emitc.cast %[[Conv1]] : ui32 to i32 683 %idx = arith.extui %arg0 : i1 to i32 684 return 685} 686 687// ----- 688 689func.func @arith_index_cast(%arg0: i32) -> i32 { 690 // CHECK-LABEL: arith_index_cast 691 // CHECK-SAME: (%[[Arg0:[^ ]*]]: i32) 692 // CHECK: %[[Conv0:.*]] = emitc.cast %[[Arg0]] : i32 to !emitc.ptrdiff_t 693 // CHECK: %[[Conv1:.*]] = emitc.cast %[[Conv0]] : !emitc.ptrdiff_t to !emitc.size_t 694 %idx = arith.index_cast %arg0 : i32 to index 695 // CHECK: %[[Conv2:.*]] = emitc.cast %[[Conv1]] : !emitc.size_t to !emitc.ptrdiff_t 696 // CHECK: %[[Conv3:.*]] = emitc.cast %[[Conv2]] : !emitc.ptrdiff_t to i32 697 %int = arith.index_cast %idx : index to i32 698 699 // CHECK: %[[Const:.*]] = "emitc.constant" 700 // CHECK-SAME: value = 1 701 // CHECK-SAME: () -> !emitc.size_t 702 // CHECK: %[[AndOne:.*]] = emitc.bitwise_and %[[Conv1]], %[[Const]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t 703 // CHECK: %[[Conv4:.*]] = emitc.cast %[[AndOne]] : !emitc.size_t to i1 704 %bool = arith.index_cast %idx : index to i1 705 706 return %int : i32 707} 708 709// ----- 710 711func.func @arith_index_castui(%arg0: i32) -> i32 { 712 // CHECK-LABEL: arith_index_castui 713 // CHECK-SAME: (%[[Arg0:[^ ]*]]: i32) 714 // CHECK: %[[Conv0:.*]] = emitc.cast %[[Arg0]] : i32 to ui32 715 // CHECK: %[[Conv1:.*]] = emitc.cast %[[Conv0]] : ui32 to !emitc.size_t 716 %idx = arith.index_castui %arg0 : i32 to index 717 // CHECK: %[[Conv2:.*]] = emitc.cast %[[Conv1]] : !emitc.size_t to ui32 718 // CHECK: %[[Conv3:.*]] = emitc.cast %[[Conv2]] : ui32 to i32 719 %int = arith.index_castui %idx : index to i32 720 721 // CHECK: %[[Const:.*]] = "emitc.constant" 722 // CHECK-SAME: value = 1 723 // CHECK-SAME: () -> !emitc.size_t 724 // CHECK: %[[AndOne:.*]] = emitc.bitwise_and %[[Conv1]], %[[Const]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t 725 // CHECK: %[[Conv4:.*]] = emitc.cast %[[AndOne]] : !emitc.size_t to i1 726 %bool = arith.index_castui %idx : index to i1 727 728 return %int : i32 729} 730 731// ----- 732 733func.func @arith_divui_remui(%arg0: i32, %arg1: i32) -> i32 { 734 // CHECK-LABEL: arith_divui_remui 735 // CHECK-SAME: (%[[Arg0:[^ ]*]]: i32, %[[Arg1:[^ ]*]]: i32) 736 // CHECK: %[[Conv0:.*]] = emitc.cast %[[Arg0]] : i32 to ui32 737 // CHECK: %[[Conv1:.*]] = emitc.cast %[[Arg1]] : i32 to ui32 738 // CHECK: %[[Div:.*]] = emitc.div %[[Conv0]], %[[Conv1]] : (ui32, ui32) -> ui32 739 %div = arith.divui %arg0, %arg1 : i32 740 741 // CHECK: %[[Conv2:.*]] = emitc.cast %[[Arg0]] : i32 to ui32 742 // CHECK: %[[Conv3:.*]] = emitc.cast %[[Arg1]] : i32 to ui32 743 // CHECK: %[[Rem:.*]] = emitc.rem %[[Conv2]], %[[Conv3]] : (ui32, ui32) -> ui32 744 %rem = arith.remui %arg0, %arg1 : i32 745 746 return %div : i32 747} 748 749// ----- 750 751func.func @arith_extf(%arg0: f16) -> f64 { 752 // CHECK-LABEL: arith_extf 753 // CHECK-SAME: (%[[Arg0:[^ ]*]]: f16) 754 // CHECK: %[[Extd0:.*]] = emitc.cast %[[Arg0]] : f16 to f32 755 %extd0 = arith.extf %arg0 : f16 to f32 756 // CHECK: %[[Extd1:.*]] = emitc.cast %[[Extd0]] : f32 to f64 757 %extd1 = arith.extf %extd0 : f32 to f64 758 759 return %extd1 : f64 760} 761 762// ----- 763 764func.func @arith_truncf(%arg0: f64) -> f16 { 765 // CHECK-LABEL: arith_truncf 766 // CHECK-SAME: (%[[Arg0:[^ ]*]]: f64) 767 // CHECK: %[[Truncd0:.*]] = emitc.cast %[[Arg0]] : f64 to f32 768 %truncd0 = arith.truncf %arg0 : f64 to f32 769 // CHECK: %[[Truncd1:.*]] = emitc.cast %[[Truncd0]] : f32 to f16 770 %truncd1 = arith.truncf %truncd0 : f32 to f16 771 772 return %truncd1 : f16 773} 774