631 lines · plain
1// RUN: mlir-opt %s -split-input-file -pass-pipeline="builtin.module(func.func(convert-math-to-llvm))" | 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=math" --split-input-file %s | FileCheck %s6// RUN: mlir-opt --convert-to-llvm="filter-dialects=math allow-pattern-rollback=0" --split-input-file %s | FileCheck %s7 8// CHECK-LABEL: @ops9func.func @ops(%arg0: f32, %arg1: f32, %arg2: i32, %arg3: i32, %arg4: f64) {10 // CHECK: = llvm.intr.exp(%{{.*}}) : (f32) -> f3211 %0 = math.exp %arg0 : f3212 // CHECK: = llvm.intr.exp2(%{{.*}}) : (f32) -> f3213 %1 = math.exp2 %arg0 : f3214 // CHECK: = llvm.intr.sqrt(%{{.*}}) : (f32) -> f3215 %2 = math.sqrt %arg0 : f3216 // CHECK: = llvm.intr.sqrt(%{{.*}}) : (f64) -> f6417 %3 = math.sqrt %arg4 : f6418 func.return19}20 21// -----22 23// CHECK-LABEL: func @absi(24// CHECK-SAME: i3225func.func @absi(%arg0: i32) -> i32 {26 // CHECK: = "llvm.intr.abs"(%{{.*}}) <{is_int_min_poison = false}> : (i32) -> i3227 %0 = math.absi %arg0 : i3228 return %0 : i3229}30 31// -----32 33// CHECK-LABEL: func @absi_0dvector(34// CHECK-SAME: vector<i32>35func.func @absi_0dvector(%arg0 : vector<i32>) {36 // CHECK: %[[CAST:.+]] = builtin.unrealized_conversion_cast %arg0 : vector<i32> to vector<1xi32>37 // CHECK: "llvm.intr.abs"(%[[CAST]]) <{is_int_min_poison = false}> : (vector<1xi32>) -> vector<1xi32>38 %0 = math.absi %arg0 : vector<i32>39 func.return40}41 42// -----43 44// CHECK-LABEL: func @log1p(45// CHECK-SAME: f3246func.func @log1p(%arg0 : f32) {47 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1.000000e+00 : f32) : f3248 // CHECK: %[[ADD:.*]] = llvm.fadd %[[ONE]], %arg0 : f3249 // CHECK: %[[LOG:.*]] = llvm.intr.log(%[[ADD]]) : (f32) -> f3250 %0 = math.log1p %arg0 : f3251 func.return52}53 54// -----55 56// CHECK-LABEL: func @log1p_fmf(57// CHECK-SAME: f3258func.func @log1p_fmf(%arg0 : f32) {59 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1.000000e+00 : f32) : f3260 // CHECK: %[[ADD:.*]] = llvm.fadd %[[ONE]], %arg0 {fastmathFlags = #llvm.fastmath<fast>} : f3261 // CHECK: %[[LOG:.*]] = llvm.intr.log(%[[ADD]]) {fastmathFlags = #llvm.fastmath<fast>} : (f32) -> f3262 %0 = math.log1p %arg0 fastmath<fast> : f3263 func.return64}65 66// -----67 68// CHECK-LABEL: func @log1p_2dvector(69func.func @log1p_2dvector(%arg0 : vector<4x3xf32>) {70 // CHECK: %[[EXTRACT:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.array<4 x vector<3xf32>>71 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<3xf32>) : vector<3xf32>72 // CHECK: %[[ADD:.*]] = llvm.fadd %[[ONE]], %[[EXTRACT]] : vector<3xf32>73 // CHECK: %[[LOG:.*]] = llvm.intr.log(%[[ADD]]) : (vector<3xf32>) -> vector<3xf32>74 // CHECK: %[[INSERT:.*]] = llvm.insertvalue %[[LOG]], %{{.*}}[0] : !llvm.array<4 x vector<3xf32>>75 %0 = math.log1p %arg0 : vector<4x3xf32>76 func.return77}78 79// -----80 81// CHECK-LABEL: func @log1p_2dvector_fmf(82func.func @log1p_2dvector_fmf(%arg0 : vector<4x3xf32>) {83 // CHECK: %[[EXTRACT:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.array<4 x vector<3xf32>>84 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<3xf32>) : vector<3xf32>85 // CHECK: %[[ADD:.*]] = llvm.fadd %[[ONE]], %[[EXTRACT]] {fastmathFlags = #llvm.fastmath<fast>} : vector<3xf32>86 // CHECK: %[[LOG:.*]] = llvm.intr.log(%[[ADD]]) {fastmathFlags = #llvm.fastmath<fast>} : (vector<3xf32>) -> vector<3xf32>87 // CHECK: %[[INSERT:.*]] = llvm.insertvalue %[[LOG]], %{{.*}}[0] : !llvm.array<4 x vector<3xf32>>88 %0 = math.log1p %arg0 fastmath<fast> : vector<4x3xf32>89 func.return90}91 92// -----93 94// CHECK-LABEL: func @log1p_scalable_vector(95// CHECK-SAME: %[[VEC:.*]]: vector<[4]xf32>96func.func @log1p_scalable_vector(%arg0 : vector<[4]xf32>) -> vector<[4]xf32> {97 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<[4]xf32>) : vector<[4]xf32>98 // CHECK: %[[ADD:.*]] = llvm.fadd %[[ONE]], %[[VEC]] : vector<[4]xf32>99 // CHECK: %[[LOG:.*]] = llvm.intr.log(%[[ADD]]) : (vector<[4]xf32>) -> vector<[4]xf32>100 %0 = math.log1p %arg0 : vector<[4]xf32>101 func.return %0 : vector<[4]xf32>102}103 104// -----105 106// CHECK-LABEL: func @log1p_0dvector(107// CHECK-SAME: vector<f32>108func.func @log1p_0dvector(%arg0 : vector<f32>) {109 // CHECK: %[[CAST:.+]] = builtin.unrealized_conversion_cast %arg0 : vector<f32> to vector<1xf32>110 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<1xf32>) : vector<1xf32>111 // CHECK: %[[ADD:.*]] = llvm.fadd %[[ONE]], %[[CAST]] : vector<1xf32>112 // CHECK: %[[LOG:.*]] = llvm.intr.log(%[[ADD]]) : (vector<1xf32>) -> vector<1xf32>113 %0 = math.log1p %arg0 : vector<f32>114 func.return115}116 117// -----118 119// CHECK-LABEL: func @expm1(120// CHECK-SAME: f32121func.func @expm1(%arg0 : f32) {122 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1.000000e+00 : f32) : f32123 // CHECK: %[[EXP:.*]] = llvm.intr.exp(%arg0) : (f32) -> f32124 // CHECK: %[[SUB:.*]] = llvm.fsub %[[EXP]], %[[ONE]] : f32125 %0 = math.expm1 %arg0 : f32126 func.return127}128 129// -----130 131// CHECK-LABEL: func @expm1_fmf(132// CHECK-SAME: f32133func.func @expm1_fmf(%arg0 : f32) {134 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1.000000e+00 : f32) : f32135 // CHECK: %[[EXP:.*]] = llvm.intr.exp(%arg0) {fastmathFlags = #llvm.fastmath<fast>} : (f32) -> f32136 // CHECK: %[[SUB:.*]] = llvm.fsub %[[EXP]], %[[ONE]] {fastmathFlags = #llvm.fastmath<fast>} : f32137 %0 = math.expm1 %arg0 fastmath<fast> : f32138 func.return139}140 141// -----142 143// CHECK-LABEL: func @expm1_vector(144// CHECK-SAME: vector<4xf32>145func.func @expm1_vector(%arg0 : vector<4xf32>) {146 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<4xf32>) : vector<4xf32>147 // CHECK: %[[EXP:.*]] = llvm.intr.exp(%arg0) : (vector<4xf32>) -> vector<4xf32>148 // CHECK: %[[SUB:.*]] = llvm.fsub %[[EXP]], %[[ONE]] : vector<4xf32>149 %0 = math.expm1 %arg0 : vector<4xf32>150 func.return151}152 153// -----154 155// CHECK-LABEL: func @expm1_scalable_vector(156// CHECK-SAME: %[[VEC:.*]]: vector<[4]xf32>157func.func @expm1_scalable_vector(%arg0 : vector<[4]xf32>) -> vector<[4]xf32> {158 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<[4]xf32>) : vector<[4]xf32>159 // CHECK: %[[EXP:.*]] = llvm.intr.exp(%[[VEC]]) : (vector<[4]xf32>) -> vector<[4]xf32>160 // CHECK: %[[SUB:.*]] = llvm.fsub %[[EXP]], %[[ONE]] : vector<[4]xf32>161 %0 = math.expm1 %arg0 : vector<[4]xf32>162 func.return %0 : vector<[4]xf32>163}164 165// -----166 167// CHECK-LABEL: func @expm1_vector_fmf(168// CHECK-SAME: vector<4xf32>169func.func @expm1_vector_fmf(%arg0 : vector<4xf32>) {170 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<4xf32>) : vector<4xf32>171 // CHECK: %[[EXP:.*]] = llvm.intr.exp(%arg0) {fastmathFlags = #llvm.fastmath<fast>} : (vector<4xf32>) -> vector<4xf32>172 // CHECK: %[[SUB:.*]] = llvm.fsub %[[EXP]], %[[ONE]] {fastmathFlags = #llvm.fastmath<fast>} : vector<4xf32>173 %0 = math.expm1 %arg0 fastmath<fast> : vector<4xf32>174 func.return175}176 177// -----178 179// CHECK-LABEL: func @expm1_0dvector(180// CHECK-SAME: vector<f32>181func.func @expm1_0dvector(%arg0 : vector<f32>) {182 // CHECK: %[[CAST:.+]] = builtin.unrealized_conversion_cast %arg0 : vector<f32> to vector<1xf32>183 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<1xf32>) : vector<1xf32>184 // CHECK: %[[EXP:.*]] = llvm.intr.exp(%[[CAST]]) : (vector<1xf32>) -> vector<1xf32>185 // CHECK: %[[SUB:.*]] = llvm.fsub %[[EXP]], %[[ONE]] : vector<1xf32>186 %0 = math.expm1 %arg0 : vector<f32>187 func.return188}189 190// -----191 192// CHECK-LABEL: func @rsqrt(193// CHECK-SAME: f32194func.func @rsqrt(%arg0 : f32) {195 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1.000000e+00 : f32) : f32196 // CHECK: %[[SQRT:.*]] = llvm.intr.sqrt(%arg0) : (f32) -> f32197 // CHECK: %[[DIV:.*]] = llvm.fdiv %[[ONE]], %[[SQRT]] : f32198 %0 = math.rsqrt %arg0 : f32199 func.return200}201 202// -----203 204// CHECK-LABEL: func @rsqrt_0dvector(205// CHECK-SAME: vector<f32>206func.func @rsqrt_0dvector(%arg0 : vector<f32>) {207 // CHECK: %[[CAST:.+]] = builtin.unrealized_conversion_cast %arg0 : vector<f32> to vector<1xf32>208 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<1xf32>) : vector<1xf32>209 // CHECK: %[[SQRT:.*]] = llvm.intr.sqrt(%[[CAST]]) : (vector<1xf32>) -> vector<1xf32>210 // CHECK: %[[SUB:.*]] = llvm.fdiv %[[ONE]], %[[SQRT]] : vector<1xf32>211 %0 = math.rsqrt %arg0 : vector<f32>212 func.return213}214 215// -----216 217// CHECK-LABEL: func @trigonometrics218// CHECK-SAME: [[ARG0:%.+]]: f32219func.func @trigonometrics(%arg0: f32) {220 // CHECK: llvm.intr.sin([[ARG0]]) : (f32) -> f32221 %0 = math.sin %arg0 : f32222 223 // CHECK: llvm.intr.cos([[ARG0]]) : (f32) -> f32224 %1 = math.cos %arg0 : f32225 226 // CHECK: llvm.intr.tan([[ARG0]]) : (f32) -> f32227 %2 = math.tan %arg0 : f32228 func.return229}230 231// -----232 233// CHECK-LABEL: func @sincos234// CHECK-SAME: [[ARG0:%.+]]: f32235func.func @sincos(%arg0: f32) {236 // CHECK: llvm.intr.sincos([[ARG0]]) : (f32) -> !llvm.struct<(f32, f32)>237 %0:2 = math.sincos %arg0 : f32238 func.return239}240 241// -----242 243// CHECK-LABEL: func @inverse_trigonometrics244// CHECK-SAME: [[ARG0:%.+]]: f32245func.func @inverse_trigonometrics(%arg0: f32) {246 // CHECK: llvm.intr.asin([[ARG0]]) : (f32) -> f32247 %0 = math.asin %arg0 : f32248 249 // CHECK: llvm.intr.acos([[ARG0]]) : (f32) -> f32250 %1 = math.acos %arg0 : f32251 252 // CHECK: llvm.intr.atan([[ARG0]]) : (f32) -> f32253 %2 = math.atan %arg0 : f32254 func.return255}256 257// -----258 259// CHECK-LABEL: func @atan2260// CHECK-SAME: [[ARG0:%.+]]: f32, [[ARG1:%.+]]: f32261func.func @atan2(%arg0: f32, %arg1: f32) {262 // CHECK: llvm.intr.atan2([[ARG0]], [[ARG1]]) : (f32, f32) -> f32263 %0 = math.atan2 %arg0, %arg1 : f32264 func.return265}266 267// -----268 269// CHECK-LABEL: func @inverse_trigonometrics_vector270// CHECK-SAME: [[ARG0:%.+]]: vector<4xf32>271func.func @inverse_trigonometrics_vector(%arg0: vector<4xf32>) {272 // CHECK: llvm.intr.asin([[ARG0]]) : (vector<4xf32>) -> vector<4xf32>273 %0 = math.asin %arg0 : vector<4xf32>274 275 // CHECK: llvm.intr.acos([[ARG0]]) : (vector<4xf32>) -> vector<4xf32>276 %1 = math.acos %arg0 : vector<4xf32>277 278 // CHECK: llvm.intr.atan([[ARG0]]) : (vector<4xf32>) -> vector<4xf32>279 %2 = math.atan %arg0 : vector<4xf32>280 func.return281}282 283// -----284 285// CHECK-LABEL: func @atan2_vector286// CHECK-SAME: [[ARG0:%.+]]: vector<4xf32>, [[ARG1:%.+]]: vector<4xf32>287func.func @atan2_vector(%arg0: vector<4xf32>, %arg1: vector<4xf32>) {288 // CHECK: llvm.intr.atan2([[ARG0]], [[ARG1]]) : (vector<4xf32>, vector<4xf32>) -> vector<4xf32>289 %0 = math.atan2 %arg0, %arg1 : vector<4xf32>290 func.return291}292 293// -----294 295// CHECK-LABEL: func @inverse_trigonometrics_fmf296// CHECK-SAME: [[ARG0:%.+]]: f32297func.func @inverse_trigonometrics_fmf(%arg0: f32) {298 // CHECK: llvm.intr.asin([[ARG0]]) {fastmathFlags = #llvm.fastmath<fast>} : (f32) -> f32299 %0 = math.asin %arg0 fastmath<fast> : f32300 301 // CHECK: llvm.intr.acos([[ARG0]]) {fastmathFlags = #llvm.fastmath<fast>} : (f32) -> f32302 %1 = math.acos %arg0 fastmath<fast> : f32303 304 // CHECK: llvm.intr.atan([[ARG0]]) {fastmathFlags = #llvm.fastmath<fast>} : (f32) -> f32305 %2 = math.atan %arg0 fastmath<fast> : f32306 func.return307}308 309// -----310 311// CHECK-LABEL: func @atan2_fmf312// CHECK-SAME: [[ARG0:%.+]]: f32, [[ARG1:%.+]]: f32313func.func @atan2_fmf(%arg0: f32, %arg1: f32) {314 // CHECK: llvm.intr.atan2([[ARG0]], [[ARG1]]) {fastmathFlags = #llvm.fastmath<fast>} : (f32, f32) -> f32315 %0 = math.atan2 %arg0, %arg1 fastmath<fast> : f32316 func.return317}318 319// -----320 321// CHECK-LABEL: func @hyperbolics322// CHECK-SAME: [[ARG0:%.+]]: f32323func.func @hyperbolics(%arg0: f32) {324 // CHECK: llvm.intr.sinh([[ARG0]]) : (f32) -> f32325 %0 = math.sinh %arg0 : f32326 327 // CHECK: llvm.intr.cosh([[ARG0]]) : (f32) -> f32328 %1 = math.cosh %arg0 : f32329 330 // CHECK: llvm.intr.tanh([[ARG0]]) : (f32) -> f32331 %2 = math.tanh %arg0 : f32332 func.return333}334 335// -----336 337// CHECK-LABEL: func @ctlz(338// CHECK-SAME: i32339func.func @ctlz(%arg0 : i32) {340 // CHECK: "llvm.intr.ctlz"(%arg0) <{is_zero_poison = false}> : (i32) -> i32341 %0 = math.ctlz %arg0 : i32342 func.return343}344 345// CHECK-LABEL: func @ctlz_0dvector(346// CHECK-SAME: vector<i32>347func.func @ctlz_0dvector(%arg0 : vector<i32>) {348 // CHECK: %[[CAST:.+]] = builtin.unrealized_conversion_cast %arg0 : vector<i32> to vector<1xi32>349 // CHECK: "llvm.intr.ctlz"(%[[CAST]]) <{is_zero_poison = false}> : (vector<1xi32>) -> vector<1xi32>350 %0 = math.ctlz %arg0 : vector<i32>351 func.return352}353 354// -----355 356// CHECK-LABEL: func @cttz(357// CHECK-SAME: i32358func.func @cttz(%arg0 : i32) {359 // CHECK: "llvm.intr.cttz"(%arg0) <{is_zero_poison = false}> : (i32) -> i32360 %0 = math.cttz %arg0 : i32361 func.return362}363 364// -----365 366// CHECK-LABEL: func @cttz_0dvector(367// CHECK-SAME: vector<i32>368func.func @cttz_0dvector(%arg0 : vector<i32>) {369 // CHECK: %[[CAST:.+]] = builtin.unrealized_conversion_cast %arg0 : vector<i32> to vector<1xi32>370 // CHECK: "llvm.intr.cttz"(%[[CAST]]) <{is_zero_poison = false}> : (vector<1xi32>) -> vector<1xi32>371 %0 = math.cttz %arg0 : vector<i32>372 func.return373}374 375// -----376 377// CHECK-LABEL: func @cttz_vec(378// CHECK-SAME: i32379func.func @cttz_vec(%arg0 : vector<4xi32>) {380 // CHECK: "llvm.intr.cttz"(%arg0) <{is_zero_poison = false}> : (vector<4xi32>) -> vector<4xi32>381 %0 = math.cttz %arg0 : vector<4xi32>382 func.return383}384 385// -----386 387// CHECK-LABEL: func @cttz_scalable_vec(388// CHECK-SAME: %[[VEC:.*]]: vector<[4]xi32>389func.func @cttz_scalable_vec(%arg0 : vector<[4]xi32>) -> vector<[4]xi32> {390 // CHECK: "llvm.intr.cttz"(%[[VEC]]) <{is_zero_poison = false}> : (vector<[4]xi32>) -> vector<[4]xi32>391 %0 = math.cttz %arg0 : vector<[4]xi32>392 func.return %0 : vector<[4]xi32>393}394 395// -----396 397// CHECK-LABEL: func @ctpop(398// CHECK-SAME: i32399func.func @ctpop(%arg0 : i32) {400 // CHECK: llvm.intr.ctpop(%arg0) : (i32) -> i32401 %0 = math.ctpop %arg0 : i32402 func.return403}404 405// -----406 407// CHECK-LABEL: func @ctpop_vector(408// CHECK-SAME: vector<3xi32>409func.func @ctpop_vector(%arg0 : vector<3xi32>) {410 // CHECK: llvm.intr.ctpop(%arg0) : (vector<3xi32>) -> vector<3xi32>411 %0 = math.ctpop %arg0 : vector<3xi32>412 func.return413}414 415// -----416 417// CHECK-LABEL: func @ctpop_scalable_vector(418// CHECK-SAME: %[[VEC:.*]]: vector<[4]xi32>419func.func @ctpop_scalable_vector(%arg0 : vector<[4]xi32>) -> vector<[4]xi32> {420 // CHECK: llvm.intr.ctpop(%[[VEC]]) : (vector<[4]xi32>) -> vector<[4]xi32>421 %0 = math.ctpop %arg0 : vector<[4]xi32>422 func.return %0 : vector<[4]xi32>423}424 425// -----426 427// CHECK-LABEL: func @isnan_double(428// CHECK-SAME: f64429func.func @isnan_double(%arg0 : f64) {430 // CHECK: "llvm.intr.is.fpclass"(%arg0) <{bit = 3 : i32}> : (f64) -> i1431 %0 = math.isnan %arg0 : f64432 func.return433}434 435// -----436 437// CHECK-LABEL: func @isnan_0dvector(438// CHECK-SAME: vector<f32>439func.func @isnan_0dvector(%arg0 : vector<f32>) {440 // CHECK: %[[CAST:.+]] = builtin.unrealized_conversion_cast %arg0 : vector<f32> to vector<1xf32>441 // CHECK: "llvm.intr.is.fpclass"(%[[CAST]]) <{bit = 3 : i32}> : (vector<1xf32>) -> vector<1xi1>442 %0 = math.isnan %arg0 : vector<f32>443 func.return444}445 446// -----447 448// CHECK-LABEL: func @isfinite_double(449// CHECK-SAME: f64450func.func @isfinite_double(%arg0 : f64) {451 // CHECK: "llvm.intr.is.fpclass"(%arg0) <{bit = 504 : i32}> : (f64) -> i1452 %0 = math.isfinite %arg0 : f64453 func.return454}455 456// -----457 458// CHECK-LABEL: func @isfinite_0dvector(459// CHECK-SAME: vector<f32>460func.func @isfinite_0dvector(%arg0 : vector<f32>) {461 // CHECK: %[[CAST:.+]] = builtin.unrealized_conversion_cast %arg0 : vector<f32> to vector<1xf32>462 // CHECK: "llvm.intr.is.fpclass"(%[[CAST]]) <{bit = 504 : i32}> : (vector<1xf32>) -> vector<1xi1>463 %0 = math.isfinite %arg0 : vector<f32>464 func.return465}466 467// -----468 469// CHECK-LABEL: func @rsqrt_double(470// CHECK-SAME: f64471func.func @rsqrt_double(%arg0 : f64) {472 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1.000000e+00 : f64) : f64473 // CHECK: %[[SQRT:.*]] = llvm.intr.sqrt(%arg0) : (f64) -> f64474 // CHECK: %[[DIV:.*]] = llvm.fdiv %[[ONE]], %[[SQRT]] : f64475 %0 = math.rsqrt %arg0 : f64476 func.return477}478 479// -----480 481// CHECK-LABEL: func @rsqrt_double_fmf(482// CHECK-SAME: f64483func.func @rsqrt_double_fmf(%arg0 : f64) {484 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1.000000e+00 : f64) : f64485 // CHECK: %[[SQRT:.*]] = llvm.intr.sqrt(%arg0) {fastmathFlags = #llvm.fastmath<fast>} : (f64) -> f64486 // CHECK: %[[DIV:.*]] = llvm.fdiv %[[ONE]], %[[SQRT]] {fastmathFlags = #llvm.fastmath<fast>} : f64487 %0 = math.rsqrt %arg0 fastmath<fast> : f64488 func.return489}490 491// -----492 493// CHECK-LABEL: func @rsqrt_vector(494// CHECK-SAME: vector<4xf32>495func.func @rsqrt_vector(%arg0 : vector<4xf32>) {496 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<4xf32>) : vector<4xf32>497 // CHECK: %[[SQRT:.*]] = llvm.intr.sqrt(%arg0) : (vector<4xf32>) -> vector<4xf32>498 // CHECK: %[[DIV:.*]] = llvm.fdiv %[[ONE]], %[[SQRT]] : vector<4xf32>499 %0 = math.rsqrt %arg0 : vector<4xf32>500 func.return501}502 503// -----504 505// CHECK-LABEL: func @rsqrt_scalable_vector(506// CHECK-SAME: %[[VEC:.*]]: vector<[4]xf32>507func.func @rsqrt_scalable_vector(%arg0 : vector<[4]xf32>) -> vector<[4]xf32>{508 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<[4]xf32>) : vector<[4]xf32>509 // CHECK: %[[SQRT:.*]] = llvm.intr.sqrt(%[[VEC]]) : (vector<[4]xf32>) -> vector<[4]xf32>510 // CHECK: %[[DIV:.*]] = llvm.fdiv %[[ONE]], %[[SQRT]] : vector<[4]xf32>511 %0 = math.rsqrt %arg0 : vector<[4]xf32>512 func.return %0 : vector<[4]xf32>513}514 515// -----516 517// CHECK-LABEL: func @rsqrt_vector_fmf(518// CHECK-SAME: vector<4xf32>519func.func @rsqrt_vector_fmf(%arg0 : vector<4xf32>) {520 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<4xf32>) : vector<4xf32>521 // CHECK: %[[SQRT:.*]] = llvm.intr.sqrt(%arg0) {fastmathFlags = #llvm.fastmath<fast>} : (vector<4xf32>) -> vector<4xf32>522 // CHECK: %[[DIV:.*]] = llvm.fdiv %[[ONE]], %[[SQRT]] {fastmathFlags = #llvm.fastmath<fast>} : vector<4xf32>523 %0 = math.rsqrt %arg0 fastmath<fast> : vector<4xf32>524 func.return525}526 527// -----528 529// CHECK-LABEL: func @rsqrt_scalable_vector_fmf(530// CHECK-SAME: %[[VEC:.*]]: vector<[4]xf32>531func.func @rsqrt_scalable_vector_fmf(%arg0 : vector<[4]xf32>) -> vector<[4]xf32> {532 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<[4]xf32>) : vector<[4]xf32>533 // CHECK: %[[SQRT:.*]] = llvm.intr.sqrt(%[[VEC]]) {fastmathFlags = #llvm.fastmath<fast>} : (vector<[4]xf32>) -> vector<[4]xf32>534 // CHECK: %[[DIV:.*]] = llvm.fdiv %[[ONE]], %[[SQRT]] {fastmathFlags = #llvm.fastmath<fast>} : vector<[4]xf32>535 %0 = math.rsqrt %arg0 fastmath<fast> : vector<[4]xf32>536 func.return %0 : vector<[4]xf32>537}538 539// -----540 541// CHECK-LABEL: func @rsqrt_multidim_vector(542func.func @rsqrt_multidim_vector(%arg0 : vector<4x3xf32>) {543 // CHECK: %[[EXTRACT:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.array<4 x vector<3xf32>>544 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<3xf32>) : vector<3xf32>545 // CHECK: %[[SQRT:.*]] = llvm.intr.sqrt(%[[EXTRACT]]) : (vector<3xf32>) -> vector<3xf32>546 // CHECK: %[[DIV:.*]] = llvm.fdiv %[[ONE]], %[[SQRT]] : vector<3xf32>547 // CHECK: %[[INSERT:.*]] = llvm.insertvalue %[[DIV]], %{{.*}}[0] : !llvm.array<4 x vector<3xf32>>548 %0 = math.rsqrt %arg0 : vector<4x3xf32>549 func.return550}551 552// -----553 554// CHECK-LABEL: func @rsqrt_multidim_scalable_vector(555func.func @rsqrt_multidim_scalable_vector(%arg0 : vector<4x[4]xf32>) -> vector<4x[4]xf32> {556 // CHECK: %[[EXTRACT:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.array<4 x vector<[4]xf32>>557 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<[4]xf32>) : vector<[4]xf32>558 // CHECK: %[[SQRT:.*]] = llvm.intr.sqrt(%[[EXTRACT]]) : (vector<[4]xf32>) -> vector<[4]xf32>559 // CHECK: %[[DIV:.*]] = llvm.fdiv %[[ONE]], %[[SQRT]] : vector<[4]xf32>560 // CHECK: %[[INSERT:.*]] = llvm.insertvalue %[[DIV]], %{{.*}}[0] : !llvm.array<4 x vector<[4]xf32>>561 %0 = math.rsqrt %arg0 : vector<4x[4]xf32>562 func.return %0 : vector<4x[4]xf32>563}564 565// -----566 567// CHECK-LABEL: func @fpowi(568// CHECK-SAME: f64569func.func @fpowi(%arg0 : f64, %arg1 : i32) {570 // CHECK: llvm.intr.powi(%arg0, %arg1) : (f64, i32) -> f64571 %0 = math.fpowi %arg0, %arg1 : f64, i32572 func.return573}574 575 576// -----577 578// CHECK-LABEL: func @powf(579// CHECK-SAME: f64580func.func @powf(%arg0 : f64) {581 // CHECK: %[[POWF:.*]] = llvm.intr.pow(%arg0, %arg0) : (f64, f64) -> f64582 %0 = math.powf %arg0, %arg0 : f64583 func.return584}585 586// -----587 588// CHECK-LABEL: func @round(589// CHECK-SAME: f32590func.func @round(%arg0 : f32) {591 // CHECK: llvm.intr.round(%arg0) : (f32) -> f32592 %0 = math.round %arg0 : f32593 func.return594}595 596// -----597 598// CHECK-LABEL: func @roundeven(599// CHECK-SAME: f32600func.func @roundeven(%arg0 : f32) {601 // CHECK: llvm.intr.roundeven(%arg0) : (f32) -> f32602 %0 = math.roundeven %arg0 : f32603 func.return604}605 606// -----607 608// CHECK-LABEL: func @trunc(609// CHECK-SAME: f32610func.func @trunc(%arg0 : f32) {611 // CHECK: llvm.intr.trunc(%arg0) : (f32) -> f32612 %0 = math.trunc %arg0 : f32613 func.return614}615 616// -----617 618// CHECK-LABEL: func @fastmath(619// CHECK-SAME: f32620func.func @fastmath(%arg0 : f32, %arg1 : vector<4xf32>) {621 // CHECK: llvm.intr.trunc(%arg0) {fastmathFlags = #llvm.fastmath<fast>} : (f32) -> f32622 %0 = math.trunc %arg0 fastmath<fast> : f32623 // CHECK: llvm.intr.pow(%arg0, %arg0) {fastmathFlags = #llvm.fastmath<afn>} : (f32, f32) -> f32624 %1 = math.powf %arg0, %arg0 fastmath<afn> : f32625 // CHECK: llvm.intr.sqrt(%arg0) : (f32) -> f32626 %2 = math.sqrt %arg0 fastmath<none> : f32627 // CHECK: llvm.intr.fma(%arg0, %arg0, %arg0) {fastmathFlags = #llvm.fastmath<fast>} : (f32, f32, f32) -> f32628 %3 = math.fma %arg0, %arg0, %arg0 fastmath<reassoc,nnan,ninf,nsz,arcp,contract,afn> : f32629 func.return630}631