798 lines · plain
1// RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-arith-to-llvm))" %s -split-input-file | FileCheck %s2 3// Same below, but using the `ConvertToLLVMPatternInterface` entry point4// and the generic `convert-to-llvm` pass.5// RUN: mlir-opt --convert-to-llvm="filter-dialects=arith" --split-input-file %s | FileCheck %s6// RUN: mlir-opt --convert-to-llvm="filter-dialects=arith allow-pattern-rollback=0" --split-input-file %s | FileCheck %s7 8// CHECK-LABEL: @vector_ops9func.func @vector_ops(%arg0: vector<4xf32>, %arg1: vector<4xi1>, %arg2: vector<4xi64>, %arg3: vector<4xi64>) -> vector<4xf32> {10// CHECK-NEXT: %0 = llvm.mlir.constant(dense<4.200000e+01> : vector<4xf32>) : vector<4xf32>11 %0 = arith.constant dense<42.> : vector<4xf32>12// CHECK-NEXT: %1 = llvm.fadd %arg0, %0 : vector<4xf32>13 %1 = arith.addf %arg0, %0 : vector<4xf32>14// CHECK-NEXT: %2 = llvm.sdiv %arg2, %arg2 : vector<4xi64>15 %3 = arith.divsi %arg2, %arg2 : vector<4xi64>16// CHECK-NEXT: %3 = llvm.udiv %arg2, %arg2 : vector<4xi64>17 %4 = arith.divui %arg2, %arg2 : vector<4xi64>18// CHECK-NEXT: %4 = llvm.srem %arg2, %arg2 : vector<4xi64>19 %5 = arith.remsi %arg2, %arg2 : vector<4xi64>20// CHECK-NEXT: %5 = llvm.urem %arg2, %arg2 : vector<4xi64>21 %6 = arith.remui %arg2, %arg2 : vector<4xi64>22// CHECK-NEXT: %6 = llvm.fdiv %arg0, %0 : vector<4xf32>23 %7 = arith.divf %arg0, %0 : vector<4xf32>24// CHECK-NEXT: %7 = llvm.frem %arg0, %0 : vector<4xf32>25 %8 = arith.remf %arg0, %0 : vector<4xf32>26// CHECK-NEXT: %8 = llvm.and %arg2, %arg3 : vector<4xi64>27 %9 = arith.andi %arg2, %arg3 : vector<4xi64>28// CHECK-NEXT: %9 = llvm.or %arg2, %arg3 : vector<4xi64>29 %10 = arith.ori %arg2, %arg3 : vector<4xi64>30// CHECK-NEXT: %10 = llvm.xor %arg2, %arg3 : vector<4xi64>31 %11 = arith.xori %arg2, %arg3 : vector<4xi64>32// CHECK-NEXT: %11 = llvm.shl %arg2, %arg2 : vector<4xi64>33 %12 = arith.shli %arg2, %arg2 : vector<4xi64>34// CHECK-NEXT: %12 = llvm.ashr %arg2, %arg2 : vector<4xi64>35 %13 = arith.shrsi %arg2, %arg2 : vector<4xi64>36// CHECK-NEXT: %13 = llvm.lshr %arg2, %arg2 : vector<4xi64>37 %14 = arith.shrui %arg2, %arg2 : vector<4xi64>38 return %1 : vector<4xf32>39}40 41// -----42 43// CHECK-LABEL: @ops44func.func @ops(f32, f32, i32, i32, f64) -> (f32, i32) {45^bb0(%arg0: f32, %arg1: f32, %arg2: i32, %arg3: i32, %arg4: f64):46// CHECK: = llvm.fsub %arg0, %arg1 : f3247 %0 = arith.subf %arg0, %arg1: f3248// CHECK: = llvm.sub %arg2, %arg3 : i3249 %1 = arith.subi %arg2, %arg3: i3250// CHECK: = llvm.icmp "slt" %arg2, %1 : i3251 %2 = arith.cmpi slt, %arg2, %1 : i3252// CHECK: = llvm.icmp "sle" %arg2, %1 : i3253 %3 = arith.cmpi sle, %arg2, %1 : i3254// CHECK: = llvm.icmp "sgt" %arg2, %1 : i3255 %4 = arith.cmpi sgt, %arg2, %1 : i3256// CHECK: = llvm.icmp "ult" %arg2, %1 : i3257 %5 = arith.cmpi ult, %arg2, %1 : i3258// CHECK: = llvm.icmp "ule" %arg2, %1 : i3259 %6 = arith.cmpi ule, %arg2, %1 : i3260// CHECK: = llvm.icmp "ugt" %arg2, %1 : i3261 %7 = arith.cmpi ugt, %arg2, %1 : i3262// CHECK: = llvm.icmp "eq" %arg2, %1 : i3263 %8 = arith.cmpi eq, %arg2, %1 : i3264// CHECK: = llvm.sdiv %arg2, %arg3 : i3265 %9 = arith.divsi %arg2, %arg3 : i3266// CHECK: = llvm.udiv %arg2, %arg3 : i3267 %10 = arith.divui %arg2, %arg3 : i3268// CHECK: = llvm.srem %arg2, %arg3 : i3269 %11 = arith.remsi %arg2, %arg3 : i3270// CHECK: = llvm.urem %arg2, %arg3 : i3271 %12 = arith.remui %arg2, %arg3 : i3272// CHECK: = llvm.fdiv %arg0, %arg1 : f3273 %13 = arith.divf %arg0, %arg1 : f3274// CHECK: = llvm.frem %arg0, %arg1 : f3275 %14 = arith.remf %arg0, %arg1 : f3276// CHECK: = llvm.and %arg2, %arg3 : i3277 %15 = arith.andi %arg2, %arg3 : i3278// CHECK: = llvm.or %arg2, %arg3 : i3279 %16 = arith.ori %arg2, %arg3 : i3280// CHECK: = llvm.xor %arg2, %arg3 : i3281 %17 = arith.xori %arg2, %arg3 : i3282// CHECK: = llvm.mlir.constant(7.900000e-01 : f64) : f6483 %18 = arith.constant 7.9e-01 : f6484// CHECK: = llvm.shl %arg2, %arg3 : i3285 %19 = arith.shli %arg2, %arg3 : i3286// CHECK: = llvm.ashr %arg2, %arg3 : i3287 %20 = arith.shrsi %arg2, %arg3 : i3288// CHECK: = llvm.lshr %arg2, %arg3 : i3289 %21 = arith.shrui %arg2, %arg3 : i3290// CHECK: arith.constant 2.000000e+00 : tf3291 // There is no type conversion rule for tf32.92 %22 = arith.constant 2.0 : tf3293 return %0, %10 : f32, i3294}95 96// -----97 98// Checking conversion of index types to integers using i1, assuming no target99// system would have a 1-bit address space. Otherwise, we would have had to100// make this test dependent on the pointer size on the target system.101// CHECK-LABEL: @index_cast102func.func @index_cast(%arg0: index, %arg1: i1) {103// CHECK: = llvm.trunc %0 : i{{.*}} to i1104 %0 = arith.index_cast %arg0: index to i1105// CHECK-NEXT: = llvm.sext %arg1 : i1 to i{{.*}}106 %1 = arith.index_cast %arg1: i1 to index107 return108}109 110// -----111 112// CHECK-LABEL: @vector_index_cast113func.func @vector_index_cast(%arg0: vector<2xindex>, %arg1: vector<2xi1>) {114// CHECK: = llvm.trunc %{{.*}} : vector<2xi{{.*}}> to vector<2xi1>115 %0 = arith.index_cast %arg0: vector<2xindex> to vector<2xi1>116// CHECK-NEXT: = llvm.sext %{{.*}} : vector<2xi1> to vector<2xi{{.*}}>117 %1 = arith.index_cast %arg1: vector<2xi1> to vector<2xindex>118 return119}120 121// -----122 123func.func @index_castui(%arg0: index, %arg1: i1) {124// CHECK: = llvm.trunc %0 : i{{.*}} to i1125 %0 = arith.index_castui %arg0: index to i1126// CHECK-NEXT: = llvm.zext %arg1 : i1 to i{{.*}}127 %1 = arith.index_castui %arg1: i1 to index128 return129}130 131// -----132 133// CHECK-LABEL: @vector_index_castui134func.func @vector_index_castui(%arg0: vector<2xindex>, %arg1: vector<2xi1>) {135// CHECK: = llvm.trunc %{{.*}} : vector<2xi{{.*}}> to vector<2xi1>136 %0 = arith.index_castui %arg0: vector<2xindex> to vector<2xi1>137// CHECK-NEXT: = llvm.zext %{{.*}} : vector<2xi1> to vector<2xi{{.*}}>138 %1 = arith.index_castui %arg1: vector<2xi1> to vector<2xindex>139 return140}141 142// -----143 144// Checking conversion of signed integer types to floating point.145// CHECK-LABEL: @sitofp146func.func @sitofp(%arg0 : i32, %arg1 : i64) {147// CHECK-NEXT: = llvm.sitofp {{.*}} : i32 to f32148 %0 = arith.sitofp %arg0: i32 to f32149// CHECK-NEXT: = llvm.sitofp {{.*}} : i32 to f64150 %1 = arith.sitofp %arg0: i32 to f64151// CHECK-NEXT: = llvm.sitofp {{.*}} : i64 to f32152 %2 = arith.sitofp %arg1: i64 to f32153// CHECK-NEXT: = llvm.sitofp {{.*}} : i64 to f64154 %3 = arith.sitofp %arg1: i64 to f64155 return156}157 158// -----159 160// Checking conversion of integer vectors to floating point vector types.161// CHECK-LABEL: @sitofp_vector162func.func @sitofp_vector(%arg0 : vector<2xi16>, %arg1 : vector<2xi32>, %arg2 : vector<2xi64>) {163// CHECK-NEXT: = llvm.sitofp {{.*}} : vector<2xi16> to vector<2xf32>164 %0 = arith.sitofp %arg0: vector<2xi16> to vector<2xf32>165// CHECK-NEXT: = llvm.sitofp {{.*}} : vector<2xi16> to vector<2xf64>166 %1 = arith.sitofp %arg0: vector<2xi16> to vector<2xf64>167// CHECK-NEXT: = llvm.sitofp {{.*}} : vector<2xi32> to vector<2xf32>168 %2 = arith.sitofp %arg1: vector<2xi32> to vector<2xf32>169// CHECK-NEXT: = llvm.sitofp {{.*}} : vector<2xi32> to vector<2xf64>170 %3 = arith.sitofp %arg1: vector<2xi32> to vector<2xf64>171// CHECK-NEXT: = llvm.sitofp {{.*}} : vector<2xi64> to vector<2xf32>172 %4 = arith.sitofp %arg2: vector<2xi64> to vector<2xf32>173// CHECK-NEXT: = llvm.sitofp {{.*}} : vector<2xi64> to vector<2xf64>174 %5 = arith.sitofp %arg2: vector<2xi64> to vector<2xf64>175 return176}177 178// -----179 180// Checking conversion of unsigned integer types to floating point.181// CHECK-LABEL: @uitofp182func.func @uitofp(%arg0 : i32, %arg1 : i64) {183// CHECK-NEXT: = llvm.uitofp {{.*}} : i32 to f32184 %0 = arith.uitofp %arg0: i32 to f32185// CHECK-NEXT: = llvm.uitofp {{.*}} : i32 to f64186 %1 = arith.uitofp %arg0: i32 to f64187// CHECK-NEXT: = llvm.uitofp {{.*}} : i64 to f32188 %2 = arith.uitofp %arg1: i64 to f32189// CHECK-NEXT: = llvm.uitofp {{.*}} : i64 to f64190 %3 = arith.uitofp %arg1: i64 to f64191 return192}193 194// -----195 196// Checking conversion of integer types to floating point.197// CHECK-LABEL: @fpext198func.func @fpext(%arg0 : f16, %arg1 : f32) {199// CHECK-NEXT: = llvm.fpext {{.*}} : f16 to f32200 %0 = arith.extf %arg0: f16 to f32201// CHECK-NEXT: = llvm.fpext {{.*}} : f16 to f64202 %1 = arith.extf %arg0: f16 to f64203// CHECK-NEXT: = llvm.fpext {{.*}} : f32 to f64204 %2 = arith.extf %arg1: f32 to f64205 return206}207 208// -----209 210// Checking conversion of integer types to floating point.211// CHECK-LABEL: @fpext212func.func @fpext_vector(%arg0 : vector<2xf16>, %arg1 : vector<2xf32>) {213// CHECK-NEXT: = llvm.fpext {{.*}} : vector<2xf16> to vector<2xf32>214 %0 = arith.extf %arg0: vector<2xf16> to vector<2xf32>215// CHECK-NEXT: = llvm.fpext {{.*}} : vector<2xf16> to vector<2xf64>216 %1 = arith.extf %arg0: vector<2xf16> to vector<2xf64>217// CHECK-NEXT: = llvm.fpext {{.*}} : vector<2xf32> to vector<2xf64>218 %2 = arith.extf %arg1: vector<2xf32> to vector<2xf64>219 return220}221 222// -----223 224// Checking conversion of floating point to integer types.225// CHECK-LABEL: @fptosi226func.func @fptosi(%arg0 : f32, %arg1 : f64) {227// CHECK-NEXT: = llvm.fptosi {{.*}} : f32 to i32228 %0 = arith.fptosi %arg0: f32 to i32229// CHECK-NEXT: = llvm.fptosi {{.*}} : f32 to i64230 %1 = arith.fptosi %arg0: f32 to i64231// CHECK-NEXT: = llvm.fptosi {{.*}} : f64 to i32232 %2 = arith.fptosi %arg1: f64 to i32233// CHECK-NEXT: = llvm.fptosi {{.*}} : f64 to i64234 %3 = arith.fptosi %arg1: f64 to i64235 return236}237 238// -----239 240// Checking conversion of floating point vectors to integer vector types.241// CHECK-LABEL: @fptosi_vector242func.func @fptosi_vector(%arg0 : vector<2xf16>, %arg1 : vector<2xf32>, %arg2 : vector<2xf64>) {243// CHECK-NEXT: = llvm.fptosi {{.*}} : vector<2xf16> to vector<2xi32>244 %0 = arith.fptosi %arg0: vector<2xf16> to vector<2xi32>245// CHECK-NEXT: = llvm.fptosi {{.*}} : vector<2xf16> to vector<2xi64>246 %1 = arith.fptosi %arg0: vector<2xf16> to vector<2xi64>247// CHECK-NEXT: = llvm.fptosi {{.*}} : vector<2xf32> to vector<2xi32>248 %2 = arith.fptosi %arg1: vector<2xf32> to vector<2xi32>249// CHECK-NEXT: = llvm.fptosi {{.*}} : vector<2xf32> to vector<2xi64>250 %3 = arith.fptosi %arg1: vector<2xf32> to vector<2xi64>251// CHECK-NEXT: = llvm.fptosi {{.*}} : vector<2xf64> to vector<2xi32>252 %4 = arith.fptosi %arg2: vector<2xf64> to vector<2xi32>253// CHECK-NEXT: = llvm.fptosi {{.*}} : vector<2xf64> to vector<2xi64>254 %5 = arith.fptosi %arg2: vector<2xf64> to vector<2xi64>255 return256}257 258// -----259 260// Checking conversion of floating point to integer types.261// CHECK-LABEL: @fptoui262func.func @fptoui(%arg0 : f32, %arg1 : f64) {263// CHECK-NEXT: = llvm.fptoui {{.*}} : f32 to i32264 %0 = arith.fptoui %arg0: f32 to i32265// CHECK-NEXT: = llvm.fptoui {{.*}} : f32 to i64266 %1 = arith.fptoui %arg0: f32 to i64267// CHECK-NEXT: = llvm.fptoui {{.*}} : f64 to i32268 %2 = arith.fptoui %arg1: f64 to i32269// CHECK-NEXT: = llvm.fptoui {{.*}} : f64 to i64270 %3 = arith.fptoui %arg1: f64 to i64271 return272}273 274// -----275 276// Checking conversion of floating point vectors to integer vector types.277// CHECK-LABEL: @fptoui_vector278func.func @fptoui_vector(%arg0 : vector<2xf16>, %arg1 : vector<2xf32>, %arg2 : vector<2xf64>) {279// CHECK-NEXT: = llvm.fptoui {{.*}} : vector<2xf16> to vector<2xi32>280 %0 = arith.fptoui %arg0: vector<2xf16> to vector<2xi32>281// CHECK-NEXT: = llvm.fptoui {{.*}} : vector<2xf16> to vector<2xi64>282 %1 = arith.fptoui %arg0: vector<2xf16> to vector<2xi64>283// CHECK-NEXT: = llvm.fptoui {{.*}} : vector<2xf32> to vector<2xi32>284 %2 = arith.fptoui %arg1: vector<2xf32> to vector<2xi32>285// CHECK-NEXT: = llvm.fptoui {{.*}} : vector<2xf32> to vector<2xi64>286 %3 = arith.fptoui %arg1: vector<2xf32> to vector<2xi64>287// CHECK-NEXT: = llvm.fptoui {{.*}} : vector<2xf64> to vector<2xi32>288 %4 = arith.fptoui %arg2: vector<2xf64> to vector<2xi32>289// CHECK-NEXT: = llvm.fptoui {{.*}} : vector<2xf64> to vector<2xi64>290 %5 = arith.fptoui %arg2: vector<2xf64> to vector<2xi64>291 return292}293 294// -----295 296// Checking conversion of integer vectors to floating point vector types.297// CHECK-LABEL: @uitofp_vector298func.func @uitofp_vector(%arg0 : vector<2xi16>, %arg1 : vector<2xi32>, %arg2 : vector<2xi64>) {299// CHECK-NEXT: = llvm.uitofp {{.*}} : vector<2xi16> to vector<2xf32>300 %0 = arith.uitofp %arg0: vector<2xi16> to vector<2xf32>301// CHECK-NEXT: = llvm.uitofp {{.*}} : vector<2xi16> to vector<2xf64>302 %1 = arith.uitofp %arg0: vector<2xi16> to vector<2xf64>303// CHECK-NEXT: = llvm.uitofp {{.*}} : vector<2xi32> to vector<2xf32>304 %2 = arith.uitofp %arg1: vector<2xi32> to vector<2xf32>305// CHECK-NEXT: = llvm.uitofp {{.*}} : vector<2xi32> to vector<2xf64>306 %3 = arith.uitofp %arg1: vector<2xi32> to vector<2xf64>307// CHECK-NEXT: = llvm.uitofp {{.*}} : vector<2xi64> to vector<2xf32>308 %4 = arith.uitofp %arg2: vector<2xi64> to vector<2xf32>309// CHECK-NEXT: = llvm.uitofp {{.*}} : vector<2xi64> to vector<2xf64>310 %5 = arith.uitofp %arg2: vector<2xi64> to vector<2xf64>311 return312}313 314// -----315 316// Checking conversion of integer types to floating point.317// CHECK-LABEL: @fptrunc318func.func @fptrunc(%arg0 : f32, %arg1 : f64) {319// CHECK-NEXT: = llvm.fptrunc {{.*}} : f32 to f16320 %0 = arith.truncf %arg0: f32 to f16321// CHECK-NEXT: = llvm.fptrunc {{.*}} : f64 to f16322 %1 = arith.truncf %arg1: f64 to f16323// CHECK-NEXT: = llvm.fptrunc {{.*}} : f64 to f32324 %2 = arith.truncf %arg1: f64 to f32325 return326}327 328// -----329 330// Checking conversion of integer types to floating point.331// CHECK-LABEL: @fptrunc332func.func @fptrunc_vector(%arg0 : vector<2xf32>, %arg1 : vector<2xf64>) {333// CHECK-NEXT: = llvm.fptrunc {{.*}} : vector<2xf32> to vector<2xf16>334 %0 = arith.truncf %arg0: vector<2xf32> to vector<2xf16>335// CHECK-NEXT: = llvm.fptrunc {{.*}} : vector<2xf64> to vector<2xf16>336 %1 = arith.truncf %arg1: vector<2xf64> to vector<2xf16>337// CHECK-NEXT: = llvm.fptrunc {{.*}} : vector<2xf64> to vector<2xf32>338 %2 = arith.truncf %arg1: vector<2xf64> to vector<2xf32>339 return340}341 342// -----343 344// CHECK-LABEL: experimental_constrained_fptrunc345func.func @experimental_constrained_fptrunc(%arg0 : f64) {346// CHECK-NEXT: = llvm.intr.experimental.constrained.fptrunc {{.*}} tonearest ignore : f64 to f32347 %0 = arith.truncf %arg0 to_nearest_even : f64 to f32348// CHECK-NEXT: = llvm.intr.experimental.constrained.fptrunc {{.*}} downward ignore : f64 to f32349 %1 = arith.truncf %arg0 downward : f64 to f32350// CHECK-NEXT: = llvm.intr.experimental.constrained.fptrunc {{.*}} upward ignore : f64 to f32351 %2 = arith.truncf %arg0 upward : f64 to f32352// CHECK-NEXT: = llvm.intr.experimental.constrained.fptrunc {{.*}} towardzero ignore : f64 to f32353 %3 = arith.truncf %arg0 toward_zero : f64 to f32354// CHECK-NEXT: = llvm.intr.experimental.constrained.fptrunc {{.*}} tonearestaway ignore : f64 to f32355 %4 = arith.truncf %arg0 to_nearest_away : f64 to f32356 return357}358 359// -----360 361// Check sign and zero extension and truncation of integers.362// CHECK-LABEL: @integer_extension_and_truncation363func.func @integer_extension_and_truncation(%arg0 : i3) {364// CHECK-NEXT: = llvm.sext %arg0 : i3 to i6365 %0 = arith.extsi %arg0 : i3 to i6366// CHECK-NEXT: = llvm.zext %arg0 : i3 to i6367 %1 = arith.extui %arg0 : i3 to i6368// CHECK-NEXT: = llvm.trunc %arg0 : i3 to i2369 %2 = arith.trunci %arg0 : i3 to i2370 return371}372 373// -----374 375// CHECK-LABEL: @integer_cast_0d_vector376func.func @integer_cast_0d_vector(%arg0 : vector<i3>) {377// CHECK: = llvm.sext %{{.*}}: vector<1xi3> to vector<1xi6>378 %0 = arith.extsi %arg0 : vector<i3> to vector<i6>379// CHECK-NEXT: = llvm.zext %{{.*}} : vector<1xi3> to vector<1xi6>380 %1 = arith.extui %arg0 : vector<i3> to vector<i6>381// CHECK-NEXT: = llvm.trunc %{{.*}} : vector<1xi3> to vector<1xi2>382 %2 = arith.trunci %arg0 : vector<i3> to vector<i2>383 return384}385 386// -----387 388// CHECK-LABEL: func @fcmp(%arg0: f32, %arg1: f32) {389func.func @fcmp(f32, f32) -> () {390^bb0(%arg0: f32, %arg1: f32):391 // CHECK: llvm.fcmp "oeq" %arg0, %arg1 : f32392 // CHECK-NEXT: llvm.fcmp "ogt" %arg0, %arg1 : f32393 // CHECK-NEXT: llvm.fcmp "oge" %arg0, %arg1 : f32394 // CHECK-NEXT: llvm.fcmp "olt" %arg0, %arg1 : f32395 // CHECK-NEXT: llvm.fcmp "ole" %arg0, %arg1 : f32396 // CHECK-NEXT: llvm.fcmp "one" %arg0, %arg1 : f32397 // CHECK-NEXT: llvm.fcmp "ord" %arg0, %arg1 : f32398 // CHECK-NEXT: llvm.fcmp "ueq" %arg0, %arg1 : f32399 // CHECK-NEXT: llvm.fcmp "ugt" %arg0, %arg1 : f32400 // CHECK-NEXT: llvm.fcmp "uge" %arg0, %arg1 : f32401 // CHECK-NEXT: llvm.fcmp "ult" %arg0, %arg1 : f32402 // CHECK-NEXT: llvm.fcmp "ule" %arg0, %arg1 : f32403 // CHECK-NEXT: llvm.fcmp "une" %arg0, %arg1 : f32404 // CHECK-NEXT: llvm.fcmp "uno" %arg0, %arg1 : f32405 // CHECK-NEXT: llvm.fcmp "oeq" %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32406 // CHECK-NEXT: return407 %1 = arith.cmpf oeq, %arg0, %arg1 : f32408 %2 = arith.cmpf ogt, %arg0, %arg1 : f32409 %3 = arith.cmpf oge, %arg0, %arg1 : f32410 %4 = arith.cmpf olt, %arg0, %arg1 : f32411 %5 = arith.cmpf ole, %arg0, %arg1 : f32412 %6 = arith.cmpf one, %arg0, %arg1 : f32413 %7 = arith.cmpf ord, %arg0, %arg1 : f32414 %8 = arith.cmpf ueq, %arg0, %arg1 : f32415 %9 = arith.cmpf ugt, %arg0, %arg1 : f32416 %10 = arith.cmpf uge, %arg0, %arg1 : f32417 %11 = arith.cmpf ult, %arg0, %arg1 : f32418 %12 = arith.cmpf ule, %arg0, %arg1 : f32419 %13 = arith.cmpf une, %arg0, %arg1 : f32420 %14 = arith.cmpf uno, %arg0, %arg1 : f32421 422 %15 = arith.cmpf oeq, %arg0, %arg1 {fastmath = #arith.fastmath<fast>} : f32423 424 return425}426 427// -----428 429// CHECK-LABEL: @index_vector430func.func @index_vector(%arg0: vector<4xindex>) {431 // CHECK: %[[CST:.*]] = llvm.mlir.constant(dense<[0, 1, 2, 3]> : vector<4xindex>) : vector<4xi64>432 %0 = arith.constant dense<[0, 1, 2, 3]> : vector<4xindex>433 // CHECK: %[[V:.*]] = llvm.add %{{.*}}, %[[CST]] : vector<4xi64>434 %1 = arith.addi %arg0, %0 : vector<4xindex>435 func.return436}437 438// -----439 440// CHECK-LABEL: @bitcast_1d441func.func @bitcast_1d(%arg0: vector<2xf32>) {442 // CHECK: llvm.bitcast %{{.*}} : vector<2xf32> to vector<2xi32>443 arith.bitcast %arg0 : vector<2xf32> to vector<2xi32>444 return445}446 447// -----448 449// CHECK-LABEL: @addui_extended_scalar450// CHECK-SAME: ([[ARG0:%.+]]: i32, [[ARG1:%.+]]: i32) -> (i32, i1)451func.func @addui_extended_scalar(%arg0: i32, %arg1: i32) -> (i32, i1) {452 // CHECK-NEXT: [[RES:%.+]] = "llvm.intr.uadd.with.overflow"([[ARG0]], [[ARG1]]) : (i32, i32) -> !llvm.struct<(i32, i1)>453 // CHECK-NEXT: [[SUM:%.+]] = llvm.extractvalue [[RES]][0] : !llvm.struct<(i32, i1)>454 // CHECK-NEXT: [[CARRY:%.+]] = llvm.extractvalue [[RES]][1] : !llvm.struct<(i32, i1)>455 %sum, %carry = arith.addui_extended %arg0, %arg1 : i32, i1456 // CHECK-NEXT: return [[SUM]], [[CARRY]] : i32, i1457 return %sum, %carry : i32, i1458}459 460// CHECK-LABEL: @addui_extended_vector1d461// CHECK-SAME: ([[ARG0:%.+]]: vector<3xi16>, [[ARG1:%.+]]: vector<3xi16>) -> (vector<3xi16>, vector<3xi1>)462func.func @addui_extended_vector1d(%arg0: vector<3xi16>, %arg1: vector<3xi16>) -> (vector<3xi16>, vector<3xi1>) {463 // CHECK-NEXT: [[RES:%.+]] = "llvm.intr.uadd.with.overflow"([[ARG0]], [[ARG1]]) : (vector<3xi16>, vector<3xi16>) -> !llvm.struct<(vector<3xi16>, vector<3xi1>)>464 // CHECK-NEXT: [[SUM:%.+]] = llvm.extractvalue [[RES]][0] : !llvm.struct<(vector<3xi16>, vector<3xi1>)>465 // CHECK-NEXT: [[CARRY:%.+]] = llvm.extractvalue [[RES]][1] : !llvm.struct<(vector<3xi16>, vector<3xi1>)>466 %sum, %carry = arith.addui_extended %arg0, %arg1 : vector<3xi16>, vector<3xi1>467 // CHECK-NEXT: return [[SUM]], [[CARRY]] : vector<3xi16>, vector<3xi1>468 return %sum, %carry : vector<3xi16>, vector<3xi1>469}470 471// -----472 473// CHECK-LABEL: @mulsi_extended_scalar474// CHECK-SAME: ([[ARG0:%.+]]: i32, [[ARG1:%.+]]: i32) -> (i32, i32)475func.func @mulsi_extended_scalar(%arg0: i32, %arg1: i32) -> (i32, i32) {476 // CHECK-NEXT: [[LHS:%.+]] = llvm.sext [[ARG0]] : i32 to i64477 // CHECK-NEXT: [[RHS:%.+]] = llvm.sext [[ARG1]] : i32 to i64478 // CHECK-NEXT: [[MUL:%.+]] = llvm.mul [[LHS]], [[RHS]] : i64479 // CHECK-NEXT: [[LOW:%.+]] = llvm.trunc [[MUL]] : i64 to i32480 // CHECK-NEXT: [[C32:%.+]] = llvm.mlir.constant(32 : i64) : i64481 // CHECK-NEXT: [[SHL:%.+]] = llvm.lshr [[MUL]], [[C32]] : i64482 // CHECK-NEXT: [[HIGH:%.+]] = llvm.trunc [[SHL]] : i64 to i32483 %low, %high = arith.mulsi_extended %arg0, %arg1 : i32484 // CHECK-NEXT: return [[LOW]], [[HIGH]] : i32, i32485 return %low, %high : i32, i32486}487 488// CHECK-LABEL: @mulsi_extended_vector1d489// CHECK-SAME: ([[ARG0:%.+]]: vector<3xi64>, [[ARG1:%.+]]: vector<3xi64>) -> (vector<3xi64>, vector<3xi64>)490func.func @mulsi_extended_vector1d(%arg0: vector<3xi64>, %arg1: vector<3xi64>) -> (vector<3xi64>, vector<3xi64>) {491 // CHECK-NEXT: [[LHS:%.+]] = llvm.sext [[ARG0]] : vector<3xi64> to vector<3xi128>492 // CHECK-NEXT: [[RHS:%.+]] = llvm.sext [[ARG1]] : vector<3xi64> to vector<3xi128>493 // CHECK-NEXT: [[MUL:%.+]] = llvm.mul [[LHS]], [[RHS]] : vector<3xi128>494 // CHECK-NEXT: [[LOW:%.+]] = llvm.trunc [[MUL]] : vector<3xi128> to vector<3xi64>495 // CHECK-NEXT: [[C64:%.+]] = llvm.mlir.constant(dense<64> : vector<3xi128>) : vector<3xi128>496 // CHECK-NEXT: [[SHL:%.+]] = llvm.lshr [[MUL]], [[C64]] : vector<3xi128>497 // CHECK-NEXT: [[HIGH:%.+]] = llvm.trunc [[SHL]] : vector<3xi128> to vector<3xi64>498 %low, %high = arith.mulsi_extended %arg0, %arg1 : vector<3xi64>499 // CHECK-NEXT: return [[LOW]], [[HIGH]] : vector<3xi64>, vector<3xi64>500 return %low, %high : vector<3xi64>, vector<3xi64>501}502 503// -----504 505// CHECK-LABEL: @mului_extended_scalar506// CHECK-SAME: ([[ARG0:%.+]]: i32, [[ARG1:%.+]]: i32) -> (i32, i32)507func.func @mului_extended_scalar(%arg0: i32, %arg1: i32) -> (i32, i32) {508 // CHECK-NEXT: [[LHS:%.+]] = llvm.zext [[ARG0]] : i32 to i64509 // CHECK-NEXT: [[RHS:%.+]] = llvm.zext [[ARG1]] : i32 to i64510 // CHECK-NEXT: [[MUL:%.+]] = llvm.mul [[LHS]], [[RHS]] : i64511 // CHECK-NEXT: [[LOW:%.+]] = llvm.trunc [[MUL]] : i64 to i32512 // CHECK-NEXT: [[C32:%.+]] = llvm.mlir.constant(32 : i64) : i64513 // CHECK-NEXT: [[SHL:%.+]] = llvm.lshr [[MUL]], [[C32]] : i64514 // CHECK-NEXT: [[HIGH:%.+]] = llvm.trunc [[SHL]] : i64 to i32515 %low, %high = arith.mului_extended %arg0, %arg1 : i32516 // CHECK-NEXT: return [[LOW]], [[HIGH]] : i32, i32517 return %low, %high : i32, i32518}519 520// CHECK-LABEL: @mului_extended_vector1d521// CHECK-SAME: ([[ARG0:%.+]]: vector<3xi64>, [[ARG1:%.+]]: vector<3xi64>) -> (vector<3xi64>, vector<3xi64>)522func.func @mului_extended_vector1d(%arg0: vector<3xi64>, %arg1: vector<3xi64>) -> (vector<3xi64>, vector<3xi64>) {523 // CHECK-NEXT: [[LHS:%.+]] = llvm.zext [[ARG0]] : vector<3xi64> to vector<3xi128>524 // CHECK-NEXT: [[RHS:%.+]] = llvm.zext [[ARG1]] : vector<3xi64> to vector<3xi128>525 // CHECK-NEXT: [[MUL:%.+]] = llvm.mul [[LHS]], [[RHS]] : vector<3xi128>526 // CHECK-NEXT: [[LOW:%.+]] = llvm.trunc [[MUL]] : vector<3xi128> to vector<3xi64>527 // CHECK-NEXT: [[C64:%.+]] = llvm.mlir.constant(dense<64> : vector<3xi128>) : vector<3xi128>528 // CHECK-NEXT: [[SHL:%.+]] = llvm.lshr [[MUL]], [[C64]] : vector<3xi128>529 // CHECK-NEXT: [[HIGH:%.+]] = llvm.trunc [[SHL]] : vector<3xi128> to vector<3xi64>530 %low, %high = arith.mului_extended %arg0, %arg1 : vector<3xi64>531 // CHECK-NEXT: return [[LOW]], [[HIGH]] : vector<3xi64>, vector<3xi64>532 return %low, %high : vector<3xi64>, vector<3xi64>533}534 535// -----536 537// CHECK-LABEL: func @cmpf_2dvector(538// CHECK-SAME: %[[OARG0:.*]]: vector<4x3xf32>, %[[OARG1:.*]]: vector<4x3xf32>)539func.func @cmpf_2dvector(%arg0 : vector<4x3xf32>, %arg1 : vector<4x3xf32>) {540 // CHECK-DAG: %[[ARG0:.*]] = builtin.unrealized_conversion_cast %[[OARG0]]541 // CHECK-DAG: %[[ARG1:.*]] = builtin.unrealized_conversion_cast %[[OARG1]]542 // CHECK: %[[EXTRACT1:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.array<4 x vector<3xf32>>543 // CHECK: %[[EXTRACT2:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.array<4 x vector<3xf32>>544 // CHECK: %[[CMP:.*]] = llvm.fcmp "olt" %[[EXTRACT1]], %[[EXTRACT2]] : vector<3xf32>545 // CHECK: %[[INSERT:.*]] = llvm.insertvalue %[[CMP]], %2[0] : !llvm.array<4 x vector<3xi1>>546 %0 = arith.cmpf olt, %arg0, %arg1 : vector<4x3xf32>547 func.return548}549 550// -----551 552// CHECK-LABEL: func @cmpi_0dvector(553// CHECK-SAME: %[[OARG0:.*]]: vector<i32>, %[[OARG1:.*]]: vector<i32>)554func.func @cmpi_0dvector(%arg0 : vector<i32>, %arg1 : vector<i32>) {555 // CHECK-DAG: %[[ARG0:.*]] = builtin.unrealized_conversion_cast %[[OARG0]]556 // CHECK-DAG: %[[ARG1:.*]] = builtin.unrealized_conversion_cast %[[OARG1]]557 // CHECK: %[[CMP:.*]] = llvm.icmp "ult" %[[ARG0]], %[[ARG1]] : vector<1xi32>558 %0 = arith.cmpi ult, %arg0, %arg1 : vector<i32>559 func.return560}561 562// -----563 564// CHECK-LABEL: func @cmpi_2dvector(565// CHECK-SAME: %[[OARG0:.*]]: vector<4x3xi32>, %[[OARG1:.*]]: vector<4x3xi32>)566func.func @cmpi_2dvector(%arg0 : vector<4x3xi32>, %arg1 : vector<4x3xi32>) {567 // CHECK-DAG: %[[ARG0:.*]] = builtin.unrealized_conversion_cast %[[OARG0]]568 // CHECK-DAG: %[[ARG1:.*]] = builtin.unrealized_conversion_cast %[[OARG1]]569 // CHECK: %[[EXTRACT1:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.array<4 x vector<3xi32>>570 // CHECK: %[[EXTRACT2:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.array<4 x vector<3xi32>>571 // CHECK: %[[CMP:.*]] = llvm.icmp "ult" %[[EXTRACT1]], %[[EXTRACT2]] : vector<3xi32>572 // CHECK: %[[INSERT:.*]] = llvm.insertvalue %[[CMP]], %2[0] : !llvm.array<4 x vector<3xi1>>573 %0 = arith.cmpi ult, %arg0, %arg1 : vector<4x3xi32>574 func.return575}576 577// -----578 579// CHECK-LABEL: @select580// CHECK-SAME: (%[[ARG0:.*]]: i1, %[[ARG1:.*]]: i32, %[[ARG2:.*]]: i32)581func.func @select(%arg0 : i1, %arg1 : i32, %arg2 : i32) -> i32 {582 // CHECK: %[[RES:.*]] = llvm.select %[[ARG0]], %[[ARG1]], %[[ARG2]] : i1, i32583 // CHECK: return %[[RES]]584 %0 = arith.select %arg0, %arg1, %arg2 : i32585 return %0 : i32586}587 588// CHECK-LABEL: @select_complex589// CHECK-SAME: (%[[ARG0:.*]]: i1, %[[ARG1:.*]]: complex<f32>, %[[ARG2:.*]]: complex<f32>)590func.func @select_complex(%arg0 : i1, %arg1 : complex<f32>, %arg2 : complex<f32>) -> complex<f32> {591 // CHECK-DAG: %[[ARGC1:.*]] = builtin.unrealized_conversion_cast %[[ARG1]] : complex<f32> to !llvm.struct<(f32, f32)>592 // CHECK-DAG: %[[ARGC2:.*]] = builtin.unrealized_conversion_cast %[[ARG2]] : complex<f32> to !llvm.struct<(f32, f32)>593 // CHECK: %[[RES:.*]] = llvm.select %[[ARG0]], %[[ARGC1]], %[[ARGC2]] : i1, !llvm.struct<(f32, f32)>594 // CHECK: %[[RESC:.*]] = builtin.unrealized_conversion_cast %[[RES]] : !llvm.struct<(f32, f32)> to complex<f32>595 // CHECK: return %[[RESC]]596 %0 = arith.select %arg0, %arg1, %arg2 : complex<f32>597 return %0 : complex<f32>598}599 600// -----601 602// CHECK-LABEL: @ceildivsi603// CHECK-SAME: %[[ARG0:.*]]: i64, %[[ARG1:.*]]: i64) -> i64604func.func @ceildivsi(%arg0 : i64, %arg1 : i64) -> i64 {605 // CHECK: %[[ZERO:.+]] = llvm.mlir.constant(0 : i64) : i64606 // CHECK: %[[ONE:.+]] = llvm.mlir.constant(1 : i64) : i64607 // CHECK: %[[DIV:.+]] = llvm.sdiv %[[ARG0]], %[[ARG1]] : i64608 // CHECK: %[[MUL:.+]] = llvm.mul %[[DIV]], %[[ARG1]] : i64609 // CHECK: %[[NEXACT:.+]] = llvm.icmp "ne" %[[ARG0]], %[[MUL]] : i64610 // CHECK: %[[NNEG:.+]] = llvm.icmp "slt" %[[ARG0]], %[[ZERO]] : i64611 // CHECK: %[[MNEG:.+]] = llvm.icmp "slt" %[[ARG1]], %[[ZERO]] : i64612 // CHECK: %[[SAMESIGN:.+]] = llvm.icmp "eq" %[[NNEG]], %[[MNEG]] : i1613 // CHECK: %[[SHOULDROUND:.+]] = llvm.and %[[NEXACT]], %[[SAMESIGN]] : i1614 // CHECK: %[[CEIL:.+]] = llvm.add %[[DIV]], %[[ONE]] : i64615 // CHECK: %[[RES:.+]] = llvm.select %[[SHOULDROUND]], %[[CEIL]], %[[DIV]] : i1, i64616 %0 = arith.ceildivsi %arg0, %arg1 : i64617 return %0: i64618}619 620// CHECK-LABEL: @ceildivui621// CHECK-SAME: %[[ARG0:.*]]: i32) -> i32622func.func @ceildivui(%arg0 : i32) -> i32 {623// CHECK: %[[CST0:.*]] = llvm.mlir.constant(0 : i32) : i32624// CHECK: %[[CMP0:.*]] = llvm.icmp "eq" %[[ARG0]], %[[CST0]] : i32625// CHECK: %[[CST1:.*]] = llvm.mlir.constant(1 : i32) : i32626// CHECK: %[[SUB0:.*]] = llvm.sub %[[ARG0]], %[[CST1]] : i32627// CHECK: %[[DIV0:.*]] = llvm.udiv %[[SUB0]], %[[ARG0]] : i32628// CHECK: %[[ADD0:.*]] = llvm.add %[[DIV0]], %[[CST1]] : i32629// CHECK: %[[SEL0:.*]] = llvm.select %[[CMP0]], %[[CST0]], %[[ADD0]] : i1, i32630 %0 = arith.ceildivui %arg0, %arg0 : i32631 return %0: i32632}633 634// -----635 636// CHECK-LABEL: @floordivsi637// CHECK-SAME: %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32) -> i32638func.func @floordivsi(%arg0 : i32, %arg1 : i32) -> i32 {639 // CHECK: %[[SDIV:.*]] = llvm.sdiv %[[ARG0]], %[[ARG1]] : i32640 // CHECK: %[[MUL0:.*]] = llvm.mul %[[SDIV]], %[[ARG1]] : i32641 // CHECK: %[[CMP0:.*]] = llvm.icmp "ne" %[[ARG0]], %[[MUL0]] : i32642 // CHECK: %[[CST0:.*]] = llvm.mlir.constant(0 : i32) : i32643 // CHECK: %[[CMP1:.*]] = llvm.icmp "slt" %[[ARG0]], %[[CST0]] : i32644 // CHECK: %[[CMP2:.*]] = llvm.icmp "slt" %[[ARG1]], %[[CST0]] : i32645 // CHECK: %[[CMP3:.*]] = llvm.icmp "ne" %[[CMP1]], %[[CMP2]] : i1646 // CHECK: %[[AND:.*]] = llvm.and %[[CMP0]], %[[CMP3]] : i1647 // CHECK: %[[CST1:.*]] = llvm.mlir.constant(-1 : i32) : i32648 // CHECK: %[[ADD:.*]] = llvm.add %[[SDIV]], %[[CST1]] : i32649 // CHECK: %[[SEL:.*]] = llvm.select %[[AND]], %[[ADD]], %[[SDIV]] : i1, i32650 %0 = arith.floordivsi %arg0, %arg1 : i32651 return %0 : i32652}653 654// -----655 656// CHECK-LABEL: @minmaxi657func.func @minmaxi(%arg0 : i32, %arg1 : i32) -> i32 {658 // CHECK: = llvm.intr.smin(%arg0, %arg1) : (i32, i32) -> i32659 %0 = arith.minsi %arg0, %arg1 : i32660 // CHECK: = llvm.intr.smax(%arg0, %arg1) : (i32, i32) -> i32661 %1 = arith.maxsi %arg0, %arg1 : i32662 // CHECK: = llvm.intr.umin(%arg0, %arg1) : (i32, i32) -> i32663 %2 = arith.minui %arg0, %arg1 : i32664 // CHECK: = llvm.intr.umax(%arg0, %arg1) : (i32, i32) -> i32665 %3 = arith.maxui %arg0, %arg1 : i32666 return %0 : i32667}668 669// CHECK-LABEL: @minmaxf670func.func @minmaxf(%arg0 : f32, %arg1 : f32) -> f32 {671 // CHECK: = llvm.intr.minimum(%arg0, %arg1) : (f32, f32) -> f32672 %0 = arith.minimumf %arg0, %arg1 : f32673 // CHECK: = llvm.intr.maximum(%arg0, %arg1) : (f32, f32) -> f32674 %1 = arith.maximumf %arg0, %arg1 : f32675 // CHECK: = llvm.intr.minnum(%arg0, %arg1) : (f32, f32) -> f32676 %2 = arith.minnumf %arg0, %arg1 : f32677 // CHECK: = llvm.intr.maxnum(%arg0, %arg1) : (f32, f32) -> f32678 %3 = arith.maxnumf %arg0, %arg1 : f32679 return %0 : f32680}681 682// -----683 684// CHECK-LABEL: @fastmath685func.func @fastmath(%arg0: f32, %arg1: f32, %arg2: i32) {686// CHECK: llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32687// CHECK: llvm.fmul %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32688// CHECK: llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<fast>} : f32689// CHECK: llvm.fadd %arg0, %arg1 : f32690// CHECK: llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32691 %0 = arith.addf %arg0, %arg1 fastmath<fast> : f32692 %1 = arith.mulf %arg0, %arg1 fastmath<fast> : f32693 %2 = arith.negf %arg0 fastmath<fast> : f32694 %3 = arith.addf %arg0, %arg1 fastmath<none> : f32695 %4 = arith.addf %arg0, %arg1 fastmath<nnan,ninf> : f32696 return697}698 699// -----700 701// CHECK-LABEL: @ops_supporting_fastmath702func.func @ops_supporting_fastmath(%arg0: f32, %arg1: f32, %arg2: i32) {703// CHECK: llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32704 %0 = arith.addf %arg0, %arg1 fastmath<fast> : f32705// CHECK: llvm.fdiv %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32706 %1 = arith.divf %arg0, %arg1 fastmath<fast> : f32707// CHECK: llvm.intr.maximum(%arg0, %arg1) {fastmathFlags = #llvm.fastmath<fast>} : (f32, f32) -> f32708 %2 = arith.maximumf %arg0, %arg1 fastmath<fast> : f32709// CHECK: llvm.intr.minimum(%arg0, %arg1) {fastmathFlags = #llvm.fastmath<fast>} : (f32, f32) -> f32710 %3 = arith.minimumf %arg0, %arg1 fastmath<fast> : f32711// CHECK: llvm.fmul %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32712 %4 = arith.mulf %arg0, %arg1 fastmath<fast> : f32713// CHECK: llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<fast>} : f32714 %5 = arith.negf %arg0 fastmath<fast> : f32715// CHECK: llvm.frem %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32716 %6 = arith.remf %arg0, %arg1 fastmath<fast> : f32717// CHECK: llvm.fsub %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32718 %7 = arith.subf %arg0, %arg1 fastmath<fast> : f32719 return720}721 722// -----723 724// CHECK-LABEL: @ops_supporting_overflow725func.func @ops_supporting_overflow(%arg0: i64, %arg1: i64) {726 // CHECK: %{{.*}} = llvm.add %{{.*}}, %{{.*}} overflow<nsw> : i64727 %0 = arith.addi %arg0, %arg1 overflow<nsw> : i64728 // CHECK: %{{.*}} = llvm.sub %{{.*}}, %{{.*}} overflow<nuw> : i64729 %1 = arith.subi %arg0, %arg1 overflow<nuw> : i64730 // CHECK: %{{.*}} = llvm.mul %{{.*}}, %{{.*}} overflow<nsw, nuw> : i64731 %2 = arith.muli %arg0, %arg1 overflow<nsw, nuw> : i64732 // CHECK: %{{.*}} = llvm.shl %{{.*}}, %{{.*}} overflow<nsw, nuw> : i64733 %3 = arith.shli %arg0, %arg1 overflow<nsw, nuw> : i64734 // CHECK: %{{.*}} = llvm.trunc %{{.*}} overflow<nsw, nuw> : i64 to i32735 %4 = arith.trunci %arg0 overflow<nsw, nuw> : i64 to i32736 return737}738 739// -----740 741// CHECK-LABEL: @ops_supporting_exact742func.func @ops_supporting_exact(i32, i32) {743^bb0(%arg0: i32, %arg1: i32):744// CHECK: = llvm.ashr exact %arg0, %arg1 : i32745 %0 = arith.shrsi %arg0, %arg1 exact : i32746// CHECK: = llvm.lshr exact %arg0, %arg1 : i32747 %1 = arith.shrui %arg0, %arg1 exact : i32748// CHECK: = llvm.sdiv exact %arg0, %arg1 : i32749 %2 = arith.divsi %arg0, %arg1 exact : i32750// CHECK: = llvm.udiv exact %arg0, %arg1 : i32751 %3 = arith.divui %arg0, %arg1 exact : i32752 return753}754 755// -----756 757// CHECK-LABEL: func @memref_bitcast758// CHECK-SAME: (%[[ARG:.*]]: memref<?xi16>)759// CHECK: %[[V1:.*]] = builtin.unrealized_conversion_cast %[[ARG]] : memref<?xi16> to !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>760// CHECK: %[[V2:.*]] = builtin.unrealized_conversion_cast %[[V1]] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> to memref<?xbf16>761// CHECK: return %[[V2]]762func.func @memref_bitcast(%1: memref<?xi16>) -> memref<?xbf16> {763 %2 = arith.bitcast %1 : memref<?xi16> to memref<?xbf16>764 func.return %2 : memref<?xbf16>765}766 767// -----768 769// CHECK-LABEL: func @unsupported_fp_type770// CHECK: arith.addf {{.*}} : f4E2M1FN771// CHECK: arith.addf {{.*}} : vector<4xf4E2M1FN>772// CHECK: arith.addf {{.*}} : vector<8x4xf4E2M1FN>773// CHECK: arith.cmpf {{.*}} : f4E2M1FN774// CHECK: llvm.select {{.*}} : i1, i4775func.func @unsupported_fp_type(%arg0: f4E2M1FN, %arg1: vector<4xf4E2M1FN>, %arg2: vector<8x4xf4E2M1FN>, %arg3: f4E2M1FN, %arg4: i1) {776 %0 = arith.addf %arg0, %arg0 : f4E2M1FN777 %1 = arith.addf %arg1, %arg1 : vector<4xf4E2M1FN>778 %2 = arith.addf %arg2, %arg2 : vector<8x4xf4E2M1FN>779 %3 = arith.cmpf oeq, %arg0, %arg3 : f4E2M1FN780 %4 = arith.select %arg4, %arg0, %arg3 : f4E2M1FN781 return782}783 784// -----785 786// CHECK-LABEL: func @supported_fp_type787// CHECK: llvm.fadd {{.*}} : f32788// CHECK: llvm.fadd {{.*}} : vector<4xf32>789// CHECK-COUNT-4: llvm.fadd {{.*}} : vector<8xf32>790// CHECK: llvm.fcmp {{.*}} : f32791func.func @supported_fp_type(%arg0: f32, %arg1: vector<4xf32>, %arg2: vector<4x8xf32>, %arg3: f32) {792 %0 = arith.addf %arg0, %arg0 : f32793 %1 = arith.addf %arg1, %arg1 : vector<4xf32>794 %2 = arith.addf %arg2, %arg2 : vector<4x8xf32>795 %3 = arith.cmpf oeq, %arg0, %arg3 : f32796 return797}798