849 lines · plain
1// RUN: mlir-opt %s --split-input-file -math-expand-ops | FileCheck %s2// RUN: mlir-opt %s --split-input-file -math-expand-ops=ops=tanh,tan | FileCheck %s --check-prefix=CHECK-FILTER3 4// CHECK-LABEL: func @tanh5func.func @tanh(%arg: f32) -> f32 {6 // CHECK-FILTER-NOT: math.tanh7 %res = math.tanh %arg : f328 return %res : f329}10// CHECK-DAG: %[[ZERO:.+]] = arith.constant 0.000000e+00 : f3211// CHECK-DAG: %[[ONE:.+]] = arith.constant 1.000000e+00 : f3212// CHECK-DAG: %[[TWO:.+]] = arith.constant -2.000000e+00 : f3213// CHECK: %[[VAL0:.+]] = arith.cmpf olt, %arg0, %[[ZERO]] : f3214// CHECK: %[[VAL1:.+]] = arith.uitofp %[[VAL0]] : i1 to f3215// CHECK: %[[VAL2:.+]] = arith.mulf %[[VAL1]], %[[TWO]] : f3216// CHECK: %[[SIGN:.+]] = arith.addf %[[VAL2]], %[[ONE]] : f3217// CHECK: %[[POSX:.+]] = arith.mulf %[[SIGN]], %arg0 : f3218// CHECK: %[[NEGDOUBLEDX:.+]] = arith.mulf %[[POSX]], %[[TWO]] : f3219// CHECK: %[[EXP1:.+]] = math.exp %[[NEGDOUBLEDX]] : f3220// CHECK: %[[DIVIDEND1:.+]] = arith.subf %[[ONE]], %[[EXP1]] : f3221// CHECK: %[[DIVISOR1:.+]] = arith.addf %[[EXP1]], %[[ONE]] : f3222// CHECK: %[[POSRES:.+]] = arith.divf %[[DIVIDEND1]], %[[DIVISOR1]] : f3223// CHECK: %[[RESULT:.+]] = arith.mulf %[[SIGN]], %[[POSRES]] : f3224// CHECK: return %[[RESULT]]25 26// -----27 28 29// CHECK-LABEL: func @vector_tanh30func.func @vector_tanh(%arg: vector<4xf32>) -> vector<4xf32> {31 // CHECK-NOT: math.tanh32 // CHECK-FILTER-NOT: math.tanh33 %res = math.tanh %arg : vector<4xf32>34 return %res : vector<4xf32>35}36 37// -----38 39// CHECK-LABEL: func @tan40func.func @tan(%arg: f32) -> f32 {41 // CHECK-FILTER-NOT: math.tan42 %res = math.tan %arg : f3243 return %res : f3244}45 46// CHECK-SAME: %[[ARG0:.+]]: f3247// CHECK: %[[SIN:.+]] = math.sin %[[ARG0]]48// CHECK: %[[COS:.+]] = math.cos %[[ARG0]]49// CHECK: %[[DIV:.+]] = arith.divf %[[SIN]], %[[COS]]50 51 52// -----53 54// CHECK-LABEL: func @vector_tan55func.func @vector_tan(%arg: vector<4xf32>) -> vector<4xf32> {56 // CHECK-FILTER-NOT: math.tan57 %res = math.tan %arg : vector<4xf32>58 return %res : vector<4xf32>59}60 61// CHECK-NOT: math.tan62 63// -----64 65func.func @ctlz(%arg: i32) -> i32 {66 // CHECK-FILTER: math.ctlz67 %res = math.ctlz %arg : i3268 return %res : i3269}70 71// CHECK-LABEL: @ctlz72// CHECK-SAME: %[[ARG0:.+]]: i3273// CHECK-DAG: %[[C0:.+]] = arith.constant 0 : i3274// CHECK-DAG: %[[C16:.+]] = arith.constant 16 : i3275// CHECK-DAG: %[[C65535:.+]] = arith.constant 65535 : i3276// CHECK-DAG: %[[C8:.+]] = arith.constant 8 : i3277// CHECK-DAG: %[[C16777215:.+]] = arith.constant 16777215 : i3278// CHECK-DAG: %[[C4:.+]] = arith.constant 4 : i3279// CHECK-DAG: %[[C268435455:.+]] = arith.constant 268435455 : i3280// CHECK-DAG: %[[C2:.+]] = arith.constant 2 : i3281// CHECK-DAG: %[[C1073741823:.+]] = arith.constant 1073741823 : i3282// CHECK-DAG: %[[C1:.+]] = arith.constant 1 : i3283// CHECK-DAG: %[[C2147483647:.+]] = arith.constant 2147483647 : i3284// CHECK-DAG: %[[C32:.+]] = arith.constant 32 : i3285 86// CHECK: %[[PRED:.+]] = arith.cmpi ule, %[[ARG0]], %[[C65535]]87// CHECK: %[[SHL:.+]] = arith.shli %[[ARG0]], %[[C16]]88// CHECK: %[[SELX0:.+]] = arith.select %[[PRED]], %[[SHL]], %[[ARG0]]89// CHECK: %[[SELY0:.+]] = arith.select %[[PRED]], %[[C16]], %[[C0]]90 91// CHECK: %[[PRED:.+]] = arith.cmpi ule, %[[SELX0]], %[[C16777215]]92// CHECK: %[[ADD:.+]] = arith.addi %[[SELY0]], %[[C8]]93// CHECK: %[[SHL:.+]] = arith.shli %[[SELX0]], %[[C8]]94// CHECK: %[[SELX1:.+]] = arith.select %[[PRED]], %[[SHL]], %[[SELX0]]95// CHECK: %[[SELY1:.+]] = arith.select %[[PRED]], %[[ADD]], %[[SELY0]]96 97// CHECK: %[[PRED:.+]] = arith.cmpi ule, %[[SELX1]], %[[C268435455]] : i3298// CHECK: %[[ADD:.+]] = arith.addi %[[SELY1]], %[[C4]]99// CHECK: %[[SHL:.+]] = arith.shli %[[SELX1]], %[[C4]]100// CHECK: %[[SELX2:.+]] = arith.select %[[PRED]], %[[SHL]], %[[SELX1]]101// CHECK: %[[SELY2:.+]] = arith.select %[[PRED]], %[[ADD]], %[[SELY1]]102 103 104// CHECK: %[[PRED:.+]] = arith.cmpi ule, %[[SELX2]], %[[C1073741823]] : i32105// CHECK: %[[ADD:.+]] = arith.addi %[[SELY2]], %[[C2]]106// CHECK: %[[SHL:.+]] = arith.shli %[[SELX2]], %[[C2]]107// CHECK: %[[SELX3:.+]] = arith.select %[[PRED]], %[[SHL]], %[[SELX2]]108// CHECK: %[[SELY3:.+]] = arith.select %[[PRED]], %[[ADD]], %[[SELY2]]109 110// CHECK: %[[PRED:.+]] = arith.cmpi ule, %[[SELX3]], %[[C2147483647]] : i32111// CHECK: %[[ADD:.+]] = arith.addi %[[SELY3]], %[[C1]]112// CHECK: %[[SELY4:.+]] = arith.select %[[PRED]], %[[ADD]], %[[SELY3]]113 114// CHECK: %[[PRED:.+]] = arith.cmpi eq, %[[ARG0]], %[[C0]] : i32115// CHECK: %[[SEL:.+]] = arith.select %[[PRED]], %[[C32]], %[[SELY4]] : i32116// CHECK: return %[[SEL]]117 118// -----119 120func.func @ctlz_vector(%arg: vector<4xi32>) -> vector<4xi32> {121 // CHECK-FILTER: math.ctlz122 %res = math.ctlz %arg : vector<4xi32>123 return %res : vector<4xi32>124}125 126// CHECK-LABEL: @ctlz_vector127// CHECK-NOT: math.ctlz128 129// -----130 131// CHECK-LABEL: func @fmaf_func132// CHECK-SAME: ([[ARG0:%.+]]: f64, [[ARG1:%.+]]: f64, [[ARG2:%.+]]: f64) -> f64133func.func @fmaf_func(%a: f64, %b: f64, %c: f64) -> f64 {134 // CHECK-NEXT: [[MULF:%.+]] = arith.mulf [[ARG0]], [[ARG1]]135 // CHECK-NEXT: [[ADDF:%.+]] = arith.addf [[MULF]], [[ARG2]]136 // CHECK-NEXT: return [[ADDF]]137 %ret = math.fma %a, %b, %c : f64138 return %ret : f64139}140 141// -----142 143// CHECK-LABEL: func @ceilf_func144// CHECK-SAME: ([[ARG0:%.+]]: f64) -> f64145func.func @ceilf_func(%a: f64) -> f64 {146 // CHECK-DAG: [[CST:%.+]] = arith.constant 0.000147 // CHECK-DAG: [[CST_0:%.+]] = arith.constant 1.000148 // CHECK-NEXT: [[CVTI:%.+]] = arith.fptosi [[ARG0]]149 // CHECK-NEXT: [[CVTF:%.+]] = arith.sitofp [[CVTI]]150 // CHECK-NEXT: [[COPYSIGN:%.+]] = math.copysign [[CVTF]], [[ARG0]]151 // CHECK-NEXT: [[COMP:%.+]] = arith.cmpf ogt, [[ARG0]], [[COPYSIGN]]152 // CHECK-NEXT: [[INCR:%.+]] = arith.select [[COMP]], [[CST_0]], [[CST]]153 // CHECK-NEXT: [[ADDF:%.+]] = arith.addf [[COPYSIGN]], [[INCR]]154 // CHECK-NEXT: return [[ADDF]]155 // CHECK-FILTER: math.ceil156 %ret = math.ceil %a : f64157 return %ret : f64158}159 160// -----161 162// CHECK-LABEL: func @exp2f_func163// CHECK-SAME: ([[ARG0:%.+]]: f64) -> f64164func.func @exp2f_func(%a: f64) -> f64 {165 // CHECK-DAG: [[CST:%.+]] = arith.constant 0.69314718055994529166 // CHECK: [[MULF:%.+]] = arith.mulf [[ARG0]], [[CST]]167 // CHECK: [[EXP:%.+]] = math.exp [[MULF]]168 // CHECK: return [[EXP]]169 // CHECK-FILTER: math.exp2170 %ret = math.exp2 %a : f64171 return %ret : f64172}173 174// CHECK-LABEL: func @exp2f_func_tensor175// CHECK-SAME: ([[ARG0:%.+]]: tensor<1xf32>) -> tensor<1xf32>176func.func @exp2f_func_tensor(%a: tensor<1xf32>) -> tensor<1xf32> {177 // CHECK-DAG: [[CST:%.+]] = arith.constant dense<0.693147182>178 // CHECK: [[MULF:%.+]] = arith.mulf [[ARG0]], [[CST]]179 // CHECK: [[EXP:%.+]] = math.exp [[MULF]]180 // CHECK: return [[EXP]]181 %ret = math.exp2 %a : tensor<1xf32>182 return %ret : tensor<1xf32>183}184 185// -----186 187// CHECK-LABEL: func @roundf_func188// CHECK-SAME: (%[[ARG0:.*]]: f32) -> f32189func.func @roundf_func(%a: f32) -> f32 {190 // CHECK-DAG: %[[HALF:.*]] = arith.constant 5.000000e-01191 // CHECK-DAG: %[[C23:.*]] = arith.constant 23192 // CHECK-DAG: %[[C127:.*]] = arith.constant 127193 // CHECK-DAG: %[[EXP_MASK:.*]] = arith.constant 255194 // CHECK-DAG: %[[SHIFT:.*]] = math.copysign %[[HALF]], %[[ARG0]]195 // CHECK-DAG: %[[ARG_SHIFTED:.*]] = arith.addf %[[ARG0]], %[[SHIFT]]196 // CHECK-DAG: %[[FIXED_CONVERT:.*]] = arith.fptosi %[[ARG_SHIFTED]]197 // CHECK-DAG: %[[FP_FIXED_CONVERT_0:.*]] = arith.sitofp %[[FIXED_CONVERT]]198 // CHECK-DAG: %[[FP_FIXED_CONVERT_1:.*]] = math.copysign %[[FP_FIXED_CONVERT_0]], %[[ARG_SHIFTED]]199 // CHECK-DAG: %[[ARG_BITCAST:.*]] = arith.bitcast %[[ARG0]] : f32 to i32200 // CHECK-DAG: %[[ARG_BITCAST_SHIFTED:.*]] = arith.shrui %[[ARG_BITCAST]], %[[C23]]201 // CHECK-DAG: %[[ARG_EXP:.*]] = arith.andi %[[ARG_BITCAST_SHIFTED]], %[[EXP_MASK]]202 // CHECK-DAG: %[[ARG_BIASED_EXP:.*]] = arith.subi %[[ARG_EXP]], %[[C127]]203 // CHECK-DAG: %[[IS_SPECIAL_VAL:.*]] = arith.cmpi sge, %[[ARG_BIASED_EXP]], %[[C23]]204 // CHECK-DAG: %[[RESULT:.*]] = arith.select %[[IS_SPECIAL_VAL]], %[[ARG0]], %[[FP_FIXED_CONVERT_1]]205 // CHECK: return %[[RESULT]]206 %ret = math.round %a : f32207 return %ret : f32208}209 210// -----211 212// CHECK-LABEL: func @powf_func213// CHECK-SAME: (%[[ARG0:.+]]: f64, %[[ARG1:.+]]: f64) -> f64214func.func @powf_func(%a: f64, %b: f64) -> f64 {215 // CHECK: %[[LOGA:.+]] = math.log %[[ARG0]] : f64216 // CHECK: %[[MUL:.+]] = arith.mulf %[[ARG1]], %[[LOGA]] : f64217 // CHECK: %[[EXP:.+]] = math.exp %[[MUL]] : f64218 // CHECK: return %[[EXP]] : f64219 %ret = math.powf %a, %b : f64220 return %ret : f64221}222 223// CHECK-LABEL: func @powf_func_zero224// CHECK-SAME: (%[[ARG0:.+]]: f64) -> f64225func.func @powf_func_zero(%a: f64) -> f64{226 // CHECK: %[[ONE:.+]] = arith.constant 1.000000e+00 : f64227 // CHECK: return %[[ONE]] : f64228 %b = arith.constant 0.0 : f64229 %ret = math.powf %a, %b : f64230 return %ret : f64231}232 233// CHECK-LABEL: func @powf_func_one234// CHECK-SAME: (%[[ARG0:.+]]: f64) -> f64235func.func @powf_func_one(%a: f64) -> f64{236 // CHECK: return %[[ARG0]] : f64237 %b = arith.constant 1.0 : f64238 %ret = math.powf %a, %b : f64239 return %ret : f64240}241 242// CHECK-LABEL: func @powf_func_negone243// CHECK-SAME: (%[[ARG0:.+]]: f64) -> f64244func.func @powf_func_negone(%a: f64) -> f64{245 // CHECK: %[[CSTONE:.+]] = arith.constant 1.000000e+00 : f64246 // CHECK: %[[DIV:.+]] = arith.divf %[[CSTONE]], %[[ARG0]] : f64247 // CHECK: return %[[DIV]] : f64248 %b = arith.constant -1.0 : f64249 %ret = math.powf %a, %b : f64250 return %ret : f64251}252 253// CHECK-LABEL: func @powf_func_half254// CHECK-SAME: (%[[ARG0:.+]]: f64) -> f64255func.func @powf_func_half(%a: f64) -> f64{256 // CHECK: %[[SQRT:.+]] = math.sqrt %[[ARG0]] : f64257 // CHECK: return %[[SQRT]] : f64258 %b = arith.constant 0.5 : f64259 %ret = math.powf %a, %b : f64260 return %ret : f64261}262 263// CHECK-LABEL: func @powf_func_neghalf264// CHECK-SAME: (%[[ARG0:.+]]: f64) -> f64265func.func @powf_func_neghalf(%a: f64) -> f64{266 // CHECK: %[[CSTONE:.+]] = arith.constant 1.000000e+00 : f64267 // CHECK: %[[SQRT:.+]] = math.sqrt %[[ARG0]] : f64268 // CHECK: %[[DIV:.+]] = arith.divf %[[CSTONE]], %[[SQRT]] : f64269 // CHECK: return %[[DIV]] : f64270 %b = arith.constant -0.5 : f64271 %ret = math.powf %a, %b : f64272 return %ret : f64273}274 275// CHECK-LABEL: func @powf_func_two276// CHECK-SAME: (%[[ARG0:.+]]: f64) -> f64277func.func @powf_func_two(%a: f64) -> f64{278 // CHECK: %[[MUL:.+]] = arith.mulf %[[ARG0]], %[[ARG0]] : f64279 // CHECK: return %[[MUL]] : f64280 %b = arith.constant 2.0 : f64281 %ret = math.powf %a, %b : f64282 return %ret : f64283}284 285// CHECK-LABEL: func @powf_func_negtwo286// CHECK-SAME: (%[[ARG0:.+]]: f64) -> f64287func.func @powf_func_negtwo(%a: f64) -> f64{288 // CHECK-DAG: %[[MUL:.+]] = arith.mulf %[[ARG0]], %[[ARG0]] : f64289 // CHECK-DAG: %[[CSTONE:.+]] = arith.constant 1.000000e+00 : f64290 // CHECK: %[[DIV:.+]] = arith.divf %[[CSTONE]], %[[MUL]] : f64291 // CHECK: return %[[DIV]] : f64292 %b = arith.constant -2.0 : f64293 %ret = math.powf %a, %b : f64294 return %ret : f64295}296 297// CHECK-LABEL: func @powf_func_three298// CHECK-SAME: (%[[ARG0:.+]]: f64) -> f64299func.func @powf_func_three(%a: f64) -> f64{300 // CHECK: %[[MUL:.+]] = arith.mulf %[[ARG0]], %[[ARG0]] : f64301 // CHECK: %[[MUL2:.+]] = arith.mulf %[[MUL]], %[[ARG0]] : f64302 // CHECK: return %[[MUL2]] : f64303 %b = arith.constant 3.0 : f64304 %ret = math.powf %a, %b : f64305 return %ret : f64306}307 308// -----309 310// CHECK-LABEL: func.func @roundeven64311func.func @roundeven64(%arg: f64) -> f64 {312 %res = math.roundeven %arg : f64313 return %res : f64314}315 316// CHECK-SAME: %[[VAL_0:.*]]: f64) -> f64 {317// CHECK-DAG: %[[C_0:.*]] = arith.constant 0 : i64318// CHECK-DAG: %[[C_1:.*]] = arith.constant 1 : i64319// CHECK-DAG: %[[C_NEG_1:.*]] = arith.constant -1 : i64320// CHECK-DAG: %[[C_1_FLOAT:.*]] = arith.constant 1.000000e+00 : f64321// CHECK-DAG: %[[C_52:.*]] = arith.constant 52 : i64322// CHECK-DAG: %[[C_63:.*]] = arith.constant 63 : i64323// CHECK-DAG: %[[C_1023:.*]] = arith.constant 1023 : i64324// CHECK-DAG: %[[C_2251799813685248:.*]] = arith.constant 2251799813685248 : i64325// CHECK-DAG: %[[C_4503599627370495:.*]] = arith.constant 4503599627370495 : i64326// CHECK-DAG: %[[EXP_MASK:.*]] = arith.constant 2047 : i64327// CHECK: %[[OPERAND_BITCAST:.*]] = arith.bitcast %[[VAL_0]] : f64 to i64328// CHECK: %[[ROUND:.*]] = math.round %[[VAL_0]] : f64329// CHECK: %[[ROUND_BITCAST:.*]] = arith.bitcast %[[ROUND]] : f64 to i64330 331// Get biased exponents of `round` and `operand`332// CHECK: %[[SHIFTED_OPERAND_BITCAST:.*]] = arith.shrui %[[OPERAND_BITCAST]], %[[C_52]] : i64333// CHECK: %[[OPERAND_EXP:.*]] = arith.andi %[[SHIFTED_OPERAND_BITCAST]], %[[EXP_MASK]] : i64334// CHECK: %[[OPERAND_BIASED_EXP:.*]] = arith.subi %[[OPERAND_EXP]], %[[C_1023]] : i64335// CHECK: %[[SHIFTED_ROUND_BITCAST:.*]] = arith.shrui %[[ROUND_BITCAST]], %[[C_52]] : i64336// CHECK: %[[ROUND_EXP:.*]] = arith.andi %[[SHIFTED_ROUND_BITCAST]], %[[EXP_MASK]] : i64337// CHECK: %[[ROUND_BIASED_EXP:.*]] = arith.subi %[[ROUND_EXP]], %[[C_1023]] : i64338 339// Determine if `ROUND_BITCAST` is an even whole number or a special value340// +-inf, +-nan.341// Mask mantissa of `ROUND_BITCAST` with a mask shifted to the right by342// `ROUND_BIASED_EXP - 1`343// CHECK-DAG: %[[ROUND_BIASED_EXP_MINUS_1:.*]] = arith.subi %[[ROUND_BIASED_EXP]], %[[C_1]] : i64344// CHECK-DAG: %[[CLAMPED_SHIFT_0:.*]] = arith.maxsi %[[ROUND_BIASED_EXP_MINUS_1]], %[[C_0]] : i64345// CHECK-DAG: %[[CLAMPED_SHIFT_1:.*]] = arith.minsi %[[CLAMPED_SHIFT_0]], %[[C_63]] : i64346// CHECK-DAG: %[[SHIFTED_MANTISSA_MASK_0:.*]] = arith.shrui %[[C_4503599627370495]], %[[CLAMPED_SHIFT_1]] : i64347// CHECK-DAG: %[[ROUND_MASKED_MANTISSA:.*]] = arith.andi %[[ROUND_BITCAST]], %[[SHIFTED_MANTISSA_MASK_0]] : i64348 349// `ROUND_BITCAST` is not even whole number or special value if masked350// mantissa is != 0 or `ROUND_BIASED_EXP == 0`351// CHECK-DAG: %[[ROUND_IS_NOT_EVEN_OR_SPECIAL_0:.*]] = arith.cmpi ne, %[[ROUND_MASKED_MANTISSA]], %[[C_0]] : i64352// CHECK-DAG: %[[ROUND_BIASED_EXP_EQ_0:.*]] = arith.cmpi eq, %[[ROUND_BIASED_EXP]], %[[C_0]] : i64353// CHECK-DAG: %[[ROUND_IS_NOT_EVEN_OR_SPECIAL_1:.*]] = arith.ori %[[ROUND_IS_NOT_EVEN_OR_SPECIAL_0]], %[[ROUND_BIASED_EXP_EQ_0]] : i1354 355// Determine if operand is halfway between two integer values356// CHECK: %[[OPERAND_BIASED_EXP_EQ_NEG_1:.*]] = arith.cmpi eq, %[[OPERAND_BIASED_EXP]], %[[C_NEG_1]] : i64357// CHECK: %[[CLAMPED_SHIFT_2:.*]] = arith.maxsi %[[OPERAND_BIASED_EXP]], %[[C_0]] : i64358// CHECK: %[[CLAMPED_SHIFT_3:.*]] = arith.minsi %[[CLAMPED_SHIFT_2]], %[[C_63]] : i64359// CHECK: %[[SHIFTED_2_TO_9:.*]] = arith.shrui %[[C_2251799813685248]], %[[CLAMPED_SHIFT_3]] : i64360 361// CHECK: %[[EXPECTED_OPERAND_MASKED_MANTISSA:.*]] = arith.select %[[OPERAND_BIASED_EXP_EQ_NEG_1]], %[[C_0]], %[[SHIFTED_2_TO_9]] : i64362 363// Mask mantissa of `OPERAND_BITCAST` with a mask shifted to the right by364// `OPERAND_BIASED_EXP`365// CHECK: %[[CLAMPED_SHIFT_4:.*]] = arith.maxsi %[[OPERAND_BIASED_EXP]], %[[C_0]] : i64366// CHECK: %[[CLAMPED_SHIFT_5:.*]] = arith.minsi %[[CLAMPED_SHIFT_4]], %[[C_63]] : i64367// CHECK: %[[SHIFTED_MANTISSA_MASK_1:.*]] = arith.shrui %[[C_4503599627370495]], %[[CLAMPED_SHIFT_5]] : i64368// CHECK: %[[OPERAND_MASKED_MANTISSA:.*]] = arith.andi %[[OPERAND_BITCAST]], %[[SHIFTED_MANTISSA_MASK_1]] : i64369 370// The operand is halfway between two integers if the masked mantissa is equal371// to the expected mantissa and the biased exponent is in the range372// [-1, 52).373// CHECK-DAG: %[[OPERAND_BIASED_EXP_GE_NEG_1:.*]] = arith.cmpi sge, %[[OPERAND_BIASED_EXP]], %[[C_NEG_1]] : i64374// CHECK-DAG: %[[OPERAND_BIASED_EXP_LT_10:.*]] = arith.cmpi slt, %[[OPERAND_BIASED_EXP]], %[[C_52]] : i64375// CHECK-DAG: %[[OPERAND_IS_HALFWAY_0:.*]] = arith.cmpi eq, %[[OPERAND_MASKED_MANTISSA]], %[[EXPECTED_OPERAND_MASKED_MANTISSA]] : i64376// CHECK-DAG: %[[OPERAND_IS_HALFWAY_1:.*]] = arith.andi %[[OPERAND_IS_HALFWAY_0]], %[[OPERAND_BIASED_EXP_LT_10]] : i1377// CHECK-DAG: %[[OPERAND_IS_HALFWAY_2:.*]] = arith.andi %[[OPERAND_IS_HALFWAY_1]], %[[OPERAND_BIASED_EXP_GE_NEG_1]] : i1378 379// Adjust rounded operand with `round(operand) - sign(operand)` to correct the380// case where `round` rounded in the oppositve direction of `roundeven`.381// CHECK: %[[SIGN:.*]] = math.copysign %[[C_1_FLOAT]], %[[VAL_0]] : f64382// CHECK: %[[ROUND_SHIFTED:.*]] = arith.subf %[[ROUND]], %[[SIGN]] : f64383// CHECK: %[[NEEDS_SHIFT:.*]] = arith.andi %[[ROUND_IS_NOT_EVEN_OR_SPECIAL_1]], %[[OPERAND_IS_HALFWAY_2]] : i1384// CHECK: %[[RESULT:.*]] = arith.select %[[NEEDS_SHIFT]], %[[ROUND_SHIFTED]], %[[ROUND]] : f64385 386// The `x - sign` adjustment does not preserve the sign when we are adjusting the value -1 to -0.387// CHECK: %[[COPYSIGN:.*]] = math.copysign %[[RESULT]], %[[VAL_0]] : f64388 389// CHECK: return %[[COPYSIGN]] : f64390 391// -----392 393// CHECK-LABEL: func.func @roundeven32394func.func @roundeven32(%arg: f32) -> f32 {395 %res = math.roundeven %arg : f32396 return %res : f32397}398 399// CHECK-SAME: %[[VAL_0:.*]]: f32) -> f32 {400// CHECK-DAG: %[[C_0:.*]] = arith.constant 0 : i32401// CHECK-DAG: %[[C_1:.*]] = arith.constant 1 : i32402// CHECK-DAG: %[[C_NEG_1:.*]] = arith.constant -1 : i32403// CHECK-DAG: %[[C_1_FLOAT:.*]] = arith.constant 1.000000e+00 : f32404// CHECK-DAG: %[[C_23:.*]] = arith.constant 23 : i32405// CHECK-DAG: %[[C_31:.*]] = arith.constant 31 : i32406// CHECK-DAG: %[[C_127:.*]] = arith.constant 127 : i32407// CHECK-DAG: %[[C_4194304:.*]] = arith.constant 4194304 : i32408// CHECK-DAG: %[[C_8388607:.*]] = arith.constant 8388607 : i32409// CHECK-DAG: %[[EXP_MASK:.*]] = arith.constant 255 : i32410// CHECK-DAG: %[[HALF:.*]] = arith.constant 5.000000e-01411 412// CHECK: %[[OPERAND_BITCAST:.*]] = arith.bitcast %[[VAL_0]] : f32 to i32413 414// Calculate `math.round(operand)` using expansion pattern for `round` and415// bitcast result to i32416// CHECK: %[[SHIFT:.*]] = math.copysign %[[HALF]], %[[VAL_0]]417// CHECK: %[[ARG_SHIFTED:.*]] = arith.addf %[[VAL_0]], %[[SHIFT]]418// CHECK: %[[FIXED_CONVERT:.*]] = arith.fptosi %[[ARG_SHIFTED]]419// CHECK: %[[FP_FIXED_CONVERT_0:.*]] = arith.sitofp %[[FIXED_CONVERT]]420// CHECK: %[[FP_FIXED_CONVERT_1:.*]] = math.copysign %[[FP_FIXED_CONVERT_0]], %[[ARG_SHIFTED]]421// CHECK: %[[ARG_BITCAST:.*]] = arith.bitcast %[[VAL_0]] : f32 to i32422// CHECK: %[[ARG_BITCAST_SHIFTED:.*]] = arith.shrui %[[ARG_BITCAST]], %[[C_23]]423// CHECK: %[[ARG_EXP:.*]] = arith.andi %[[ARG_BITCAST_SHIFTED]], %[[EXP_MASK]]424// CHECK: %[[ARG_BIASED_EXP:.*]] = arith.subi %[[ARG_EXP]], %[[C_127]]425// CHECK: %[[IS_SPECIAL_VAL:.*]] = arith.cmpi sge, %[[ARG_BIASED_EXP]], %[[C_23]]426// CHECK: %[[ROUND:.*]] = arith.select %[[IS_SPECIAL_VAL]], %[[VAL_0]], %[[FP_FIXED_CONVERT_1]]427// CHECK: %[[ROUND_BITCAST:.*]] = arith.bitcast %[[ROUND]] : f32 to i32428 429// Get biased exponents of `round` and `operand`430// CHECK: %[[SHIFTED_OPERAND_BITCAST:.*]] = arith.shrui %[[OPERAND_BITCAST]], %[[C_23]] : i32431// CHECK: %[[OPERAND_EXP:.*]] = arith.andi %[[SHIFTED_OPERAND_BITCAST]], %[[EXP_MASK]] : i32432// CHECK: %[[OPERAND_BIASED_EXP:.*]] = arith.subi %[[OPERAND_EXP]], %[[C_127]] : i32433// CHECK: %[[SHIFTED_ROUND_BITCAST:.*]] = arith.shrui %[[ROUND_BITCAST]], %[[C_23]] : i32434// CHECK: %[[ROUND_EXP:.*]] = arith.andi %[[SHIFTED_ROUND_BITCAST]], %[[EXP_MASK]] : i32435// CHECK: %[[ROUND_BIASED_EXP:.*]] = arith.subi %[[ROUND_EXP]], %[[C_127]] : i32436 437// Determine if `ROUND_BITCAST` is an even whole number or a special value438// +-inf, +-nan.439// Mask mantissa of `ROUND_BITCAST` with a mask shifted to the right by440// `ROUND_BIASED_EXP - 1`441// CHECK-DAG: %[[ROUND_BIASED_EXP_MINUS_1:.*]] = arith.subi %[[ROUND_BIASED_EXP]], %[[C_1]] : i32442// CHECK-DAG: %[[CLAMPED_SHIFT_0:.*]] = arith.maxsi %[[ROUND_BIASED_EXP_MINUS_1]], %[[C_0]] : i32443// CHECK-DAG: %[[CLAMPED_SHIFT_1:.*]] = arith.minsi %[[CLAMPED_SHIFT_0]], %[[C_31]] : i32444// CHECK-DAG: %[[SHIFTED_MANTISSA_MASK_0:.*]] = arith.shrui %[[C_8388607]], %[[CLAMPED_SHIFT_1]] : i32445// CHECK-DAG: %[[ROUND_MASKED_MANTISSA:.*]] = arith.andi %[[ROUND_BITCAST]], %[[SHIFTED_MANTISSA_MASK_0]] : i32446 447// `ROUND_BITCAST` is not even whole number or special value if masked448// mantissa is != 0 or `ROUND_BIASED_EXP == 0`449// CHECK-DAG: %[[ROUND_IS_NOT_EVEN_OR_SPECIAL_0:.*]] = arith.cmpi ne, %[[ROUND_MASKED_MANTISSA]], %[[C_0]] : i32450// CHECK-DAG: %[[ROUND_BIASED_EXP_EQ_0:.*]] = arith.cmpi eq, %[[ROUND_BIASED_EXP]], %[[C_0]] : i32451// CHECK-DAG: %[[ROUND_IS_NOT_EVEN_OR_SPECIAL_1:.*]] = arith.ori %[[ROUND_IS_NOT_EVEN_OR_SPECIAL_0]], %[[ROUND_BIASED_EXP_EQ_0]] : i1452 453// Determine if operand is halfway between two integer values454// CHECK: %[[OPERAND_BIASED_EXP_EQ_NEG_1:.*]] = arith.cmpi eq, %[[OPERAND_BIASED_EXP]], %[[C_NEG_1]] : i32455// CHECK: %[[CLAMPED_SHIFT_2:.*]] = arith.maxsi %[[OPERAND_BIASED_EXP]], %[[C_0]] : i32456// CHECK: %[[CLAMPED_SHIFT_3:.*]] = arith.minsi %[[CLAMPED_SHIFT_2]], %[[C_31]] : i32457// CHECK: %[[SHIFTED_2_TO_22:.*]] = arith.shrui %[[C_4194304]], %[[CLAMPED_SHIFT_3]] : i32458 459// A value with `0 <= BIASED_EXP < 23` is halfway between two consecutive460// integers if the bit at index `BIASED_EXP` starting from the left in the461// mantissa is 1 and all the bits to the right are zero. For the case where462// `BIASED_EXP == -1, the expected mantissa is all zeros.463// CHECK: %[[EXPECTED_OPERAND_MASKED_MANTISSA:.*]] = arith.select %[[OPERAND_BIASED_EXP_EQ_NEG_1]], %[[C_0]], %[[SHIFTED_2_TO_22]] : i32464 465// Mask mantissa of `OPERAND_BITCAST` with a mask shifted to the right by466// `OPERAND_BIASED_EXP`467// CHECK: %[[CLAMPED_SHIFT_4:.*]] = arith.maxsi %[[OPERAND_BIASED_EXP]], %[[C_0]] : i32468// CHECK: %[[CLAMPED_SHIFT_5:.*]] = arith.minsi %[[CLAMPED_SHIFT_4]], %[[C_31]] : i32469// CHECK: %[[SHIFTED_MANTISSA_MASK_1:.*]] = arith.shrui %[[C_8388607]], %[[CLAMPED_SHIFT_5]] : i32470// CHECK: %[[OPERAND_MASKED_MANTISSA:.*]] = arith.andi %[[OPERAND_BITCAST]], %[[SHIFTED_MANTISSA_MASK_1]] : i32471 472// The operand is halfway between two integers if the masked mantissa is equal473// to the expected mantissa and the biased exponent is in the range474// [-1, 23).475// CHECK-DAG: %[[OPERAND_BIASED_EXP_GE_NEG_1:.*]] = arith.cmpi sge, %[[OPERAND_BIASED_EXP]], %[[C_NEG_1]] : i32476// CHECK-DAG: %[[OPERAND_BIASED_EXP_LT_23:.*]] = arith.cmpi slt, %[[OPERAND_BIASED_EXP]], %[[C_23]] : i32477// CHECK-DAG: %[[OPERAND_IS_HALFWAY_0:.*]] = arith.cmpi eq, %[[OPERAND_MASKED_MANTISSA]], %[[EXPECTED_OPERAND_MASKED_MANTISSA]] : i32478// CHECK-DAG: %[[OPERAND_IS_HALFWAY_1:.*]] = arith.andi %[[OPERAND_IS_HALFWAY_0]], %[[OPERAND_BIASED_EXP_LT_23]] : i1479// CHECK-DAG: %[[OPERAND_IS_HALFWAY_2:.*]] = arith.andi %[[OPERAND_IS_HALFWAY_1]], %[[OPERAND_BIASED_EXP_GE_NEG_1]] : i1480 481// Adjust rounded operand with `round(operand) - sign(operand)` to correct the482// case where `round` rounded in the oppositve direction of `roundeven`.483// CHECK: %[[SIGN:.*]] = math.copysign %[[C_1_FLOAT]], %[[VAL_0]] : f32484// CHECK: %[[ROUND_SHIFTED:.*]] = arith.subf %[[ROUND]], %[[SIGN]] : f32485// CHECK: %[[NEEDS_SHIFT:.*]] = arith.andi %[[ROUND_IS_NOT_EVEN_OR_SPECIAL_1]], %[[OPERAND_IS_HALFWAY_2]] : i1486// CHECK: %[[RESULT:.*]] = arith.select %[[NEEDS_SHIFT]], %[[ROUND_SHIFTED]], %[[ROUND]] : f32487 488// The `x - sign` adjustment does not preserve the sign when we are adjusting the value -1 to -0.489// CHECK: %[[COPYSIGN:.*]] = math.copysign %[[RESULT]], %[[VAL_0]] : f32490 491// CHECK: return %[[COPYSIGN]] : f32492 493// -----494 495// CHECK-LABEL: func.func @roundeven16496func.func @roundeven16(%arg: f16) -> f16 {497 %res = math.roundeven %arg : f16498 return %res : f16499}500 501// CHECK-SAME: %[[VAL_0:.*]]: f16) -> f16 {502// CHECK-DAG: %[[C_0:.*]] = arith.constant 0 : i16503// CHECK-DAG: %[[C_1:.*]] = arith.constant 1 : i16504// CHECK-DAG: %[[C_NEG_1:.*]] = arith.constant -1 : i16505// CHECK-DAG: %[[C_1_FLOAT:.*]] = arith.constant 1.000000e+00 : f16506// CHECK-DAG: %[[C_10:.*]] = arith.constant 10 : i16507// CHECK-DAG: %[[C_15:.*]] = arith.constant 15 : i16508// CHECK-DAG: %[[C_512:.*]] = arith.constant 512 : i16509// CHECK-DAG: %[[C_1023:.*]] = arith.constant 1023 : i16510// CHECK-DAG: %[[EXP_MASK:.*]] = arith.constant 31 : i16511 512// CHECK: %[[OPERAND_BITCAST:.*]] = arith.bitcast %[[VAL_0]] : f16 to i16513// CHECK: %[[ROUND:.*]] = math.round %[[VAL_0]] : f16514// CHECK: %[[ROUND_BITCAST:.*]] = arith.bitcast %[[ROUND]] : f16 to i16515 516// Get biased exponents of `round` and `operand`517// CHECK: %[[SHIFTED_OPERAND_BITCAST:.*]] = arith.shrui %[[OPERAND_BITCAST]], %[[C_10]] : i16518// CHECK: %[[OPERAND_EXP:.*]] = arith.andi %[[SHIFTED_OPERAND_BITCAST]], %[[EXP_MASK]] : i16519// CHECK: %[[OPERAND_BIASED_EXP:.*]] = arith.subi %[[OPERAND_EXP]], %[[C_15]] : i16520// CHECK: %[[SHIFTED_ROUND_BITCAST:.*]] = arith.shrui %[[ROUND_BITCAST]], %[[C_10]] : i16521// CHECK: %[[ROUND_EXP:.*]] = arith.andi %[[SHIFTED_ROUND_BITCAST]], %[[EXP_MASK]] : i16522// CHECK: %[[ROUND_BIASED_EXP:.*]] = arith.subi %[[ROUND_EXP]], %[[C_15]] : i16523 524// Determine if `ROUND_BITCAST` is an even whole number or a special value525// +-inf, +-nan.526// Mask mantissa of `ROUND_BITCAST` with a mask shifted to the right by527// `ROUND_BIASED_EXP - 1`528// CHECK-DAG: %[[ROUND_BIASED_EXP_MINUS_1:.*]] = arith.subi %[[ROUND_BIASED_EXP]], %[[C_1]] : i16529// CHECK-DAG: %[[CLAMPED_SHIFT_0:.*]] = arith.maxsi %[[ROUND_BIASED_EXP_MINUS_1]], %[[C_0]] : i16530// CHECK-DAG: %[[CLAMPED_SHIFT_1:.*]] = arith.minsi %[[CLAMPED_SHIFT_0]], %[[C_15]] : i16531// CHECK-DAG: %[[SHIFTED_MANTISSA_MASK_0:.*]] = arith.shrui %[[C_1023]], %[[CLAMPED_SHIFT_1]] : i16532// CHECK-DAG: %[[ROUND_MASKED_MANTISSA:.*]] = arith.andi %[[ROUND_BITCAST]], %[[SHIFTED_MANTISSA_MASK_0]] : i16533 534// `ROUND_BITCAST` is not even whole number or special value if masked535// mantissa is != 0 or `ROUND_BIASED_EXP == 0`536// CHECK-DAG: %[[ROUND_IS_NOT_EVEN_OR_SPECIAL_0:.*]] = arith.cmpi ne, %[[ROUND_MASKED_MANTISSA]], %[[C_0]] : i16537// CHECK-DAG: %[[ROUND_BIASED_EXP_EQ_0:.*]] = arith.cmpi eq, %[[ROUND_BIASED_EXP]], %[[C_0]] : i16538// CHECK-DAG: %[[ROUND_IS_NOT_EVEN_OR_SPECIAL_1:.*]] = arith.ori %[[ROUND_IS_NOT_EVEN_OR_SPECIAL_0]], %[[ROUND_BIASED_EXP_EQ_0]] : i1539 540// Determine if operand is halfway between two integer values541// CHECK: %[[OPERAND_BIASED_EXP_EQ_NEG_1:.*]] = arith.cmpi eq, %[[OPERAND_BIASED_EXP]], %[[C_NEG_1]] : i16542// CHECK: %[[CLAMPED_SHIFT_2:.*]] = arith.maxsi %[[OPERAND_BIASED_EXP]], %[[C_0]] : i16543// CHECK: %[[CLAMPED_SHIFT_3:.*]] = arith.minsi %[[CLAMPED_SHIFT_2]], %[[C_15]] : i16544// CHECK: %[[SHIFTED_2_TO_9:.*]] = arith.shrui %[[C_512]], %[[CLAMPED_SHIFT_3]] : i16545 546// A value with `0 <= BIASED_EXP < 10` is halfway between two consecutive547// integers if the bit at index `BIASED_EXP` starting from the left in the548// mantissa is 1 and all the bits to the right are zero. For the case where549// `BIASED_EXP == -1, the expected mantissa is all zeros.550// CHECK: %[[EXPECTED_OPERAND_MASKED_MANTISSA:.*]] = arith.select %[[OPERAND_BIASED_EXP_EQ_NEG_1]], %[[C_0]], %[[SHIFTED_2_TO_9]] : i16551 552// Mask mantissa of `OPERAND_BITCAST` with a mask shifted to the right by553// `OPERAND_BIASED_EXP`554// CHECK: %[[CLAMPED_SHIFT_4:.*]] = arith.maxsi %[[OPERAND_BIASED_EXP]], %[[C_0]] : i16555// CHECK: %[[CLAMPED_SHIFT_5:.*]] = arith.minsi %[[CLAMPED_SHIFT_4]], %[[C_15]] : i16556// CHECK: %[[SHIFTED_MANTISSA_MASK_1:.*]] = arith.shrui %[[C_1023]], %[[CLAMPED_SHIFT_5]] : i16557// CHECK: %[[OPERAND_MASKED_MANTISSA:.*]] = arith.andi %[[OPERAND_BITCAST]], %[[SHIFTED_MANTISSA_MASK_1]] : i16558 559// The operand is halfway between two integers if the masked mantissa is equal560// to the expected mantissa and the biased exponent is in the range561// [-1, 23).562// CHECK-DAG: %[[OPERAND_BIASED_EXP_GE_NEG_1:.*]] = arith.cmpi sge, %[[OPERAND_BIASED_EXP]], %[[C_NEG_1]] : i16563// CHECK-DAG: %[[OPERAND_BIASED_EXP_LT_10:.*]] = arith.cmpi slt, %[[OPERAND_BIASED_EXP]], %[[C_10]] : i16564// CHECK-DAG: %[[OPERAND_IS_HALFWAY_0:.*]] = arith.cmpi eq, %[[OPERAND_MASKED_MANTISSA]], %[[EXPECTED_OPERAND_MASKED_MANTISSA]] : i16565// CHECK-DAG: %[[OPERAND_IS_HALFWAY_1:.*]] = arith.andi %[[OPERAND_IS_HALFWAY_0]], %[[OPERAND_BIASED_EXP_LT_10]] : i1566// CHECK-DAG: %[[OPERAND_IS_HALFWAY_2:.*]] = arith.andi %[[OPERAND_IS_HALFWAY_1]], %[[OPERAND_BIASED_EXP_GE_NEG_1]] : i1567 568// Adjust rounded operand with `round(operand) - sign(operand)` to correct the569// case where `round` rounded in the oppositve direction of `roundeven`.570// CHECK: %[[SIGN:.*]] = math.copysign %[[C_1_FLOAT]], %[[VAL_0]] : f16571// CHECK: %[[ROUND_SHIFTED:.*]] = arith.subf %[[ROUND]], %[[SIGN]] : f16572// CHECK: %[[NEEDS_SHIFT:.*]] = arith.andi %[[ROUND_IS_NOT_EVEN_OR_SPECIAL_1]], %[[OPERAND_IS_HALFWAY_2]] : i1573// CHECK: %[[RESULT:.*]] = arith.select %[[NEEDS_SHIFT]], %[[ROUND_SHIFTED]], %[[ROUND]] : f16574 575// The `x - sign` adjustment does not preserve the sign when we are adjusting the value -1 to -0.576// CHECK: %[[COPYSIGN:.*]] = math.copysign %[[RESULT]], %[[VAL_0]] : f16577 578// CHECK: return %[[COPYSIGN]] : f16579 580// -----581 582// CHECK-LABEL: func.func @math_fpowi_neg_odd_power583func.func @math_fpowi_neg_odd_power(%0 : tensor<8xf32>) -> tensor<8xf32> {584 %1 = arith.constant dense<-3> : tensor<8xi64>585 %2 = math.fpowi %0, %1 : tensor<8xf32>, tensor<8xi64>586 return %2 : tensor<8xf32>587}588// CHECK-SAME: (%[[ARG0:.*]]: tensor<8xf32>) -> tensor<8xf32> {589// CHECK-DAG: %[[CST1:.*]] = arith.constant dense<1.000000e+00> : tensor<8xf32>590// CHECK-DAG: %[[CST0:.*]] = arith.constant dense<0.000000e+00> : tensor<8xf32>591// CHECK-DAG: %[[CSTNEG0:.*]] = arith.constant dense<-0.000000e+00> : tensor<8xf32>592// CHECK-DAG: %[[CSTINF:.*]] = arith.constant dense<0x7F800000> : tensor<8xf32>593// CHECK-DAG: %[[CSTNEGINF:.*]] = arith.constant dense<0xFF800000> : tensor<8xf32>594// CHECK: %[[SQ:.*]] = arith.mulf %[[ARG0]], %[[ARG0]] : tensor<8xf32>595// CHECK: %[[CUBE:.*]] = arith.mulf %[[SQ]], %[[ARG0]] : tensor<8xf32>596// CHECK: %[[CMP0:.*]] = arith.cmpf oeq, %[[CUBE]], %[[CST0]] : tensor<8xf32>597// CHECK: %[[CMPNEG0:.*]] = arith.cmpf oeq, %[[CUBE]], %[[CSTNEG0]] : tensor<8xf32>598// CHECK: %[[INV:.*]] = arith.divf %[[CST1]], %[[CUBE]] : tensor<8xf32>599// CHECK: %[[UB1:.*]] = arith.select %[[CMP0]], %[[CSTINF]], %[[INV]] : tensor<8xi1>, tensor<8xf32>600// CHECK: %[[UB2:.*]] = arith.select %[[CMPNEG0]], %[[CSTNEGINF]], %[[UB1]] : tensor<8xi1>, tensor<8xf32>601// CHECK: return %[[UB2]] : tensor<8xf32>602 603// -----604 605// CHECK-LABEL: func.func @math_fpowi_neg_even_power606func.func @math_fpowi_neg_even_power(%0 : tensor<8xf32>) -> tensor<8xf32> {607 %1 = arith.constant dense<-4> : tensor<8xi64>608 %2 = math.fpowi %0, %1 : tensor<8xf32>, tensor<8xi64>609 return %2 : tensor<8xf32>610}611// CHECK-SAME: (%[[ARG0:.*]]: tensor<8xf32>) -> tensor<8xf32> {612// CHECK-DAG: %[[CST1:.*]] = arith.constant dense<1.000000e+00> : tensor<8xf32>613// CHECK-DAG: %[[CST0:.*]] = arith.constant dense<0.000000e+00> : tensor<8xf32>614// CHECK-DAG: %[[CSTNEG0:.*]] = arith.constant dense<-0.000000e+00> : tensor<8xf32>615// CHECK-DAG: %[[CSTINF:.*]] = arith.constant dense<0x7F800000> : tensor<8xf32>616// CHECK-DAG: %[[CSTNEGINF:.*]] = arith.constant dense<0xFF800000> : tensor<8xf32>617// CHECK: %[[SQ:.*]] = arith.mulf %[[ARG0]], %[[ARG0]] : tensor<8xf32>618// CHECK: %[[PW4:.*]] = arith.mulf %[[SQ]], %[[SQ]] : tensor<8xf32>619// CHECK: %[[CMP0:.*]] = arith.cmpf oeq, %[[PW4]], %[[CST0]] : tensor<8xf32>620// CHECK: %[[CMPNEG0:.*]] = arith.cmpf oeq, %[[PW4]], %[[CSTNEG0]] : tensor<8xf32>621// CHECK: %[[INV:.*]] = arith.divf %[[CST1]], %[[PW4]] : tensor<8xf32>622// CHECK: %[[UB1:.*]] = arith.select %[[CMP0]], %[[CSTINF]], %[[INV]] : tensor<8xi1>, tensor<8xf32>623// CHECK: %[[UB2:.*]] = arith.select %[[CMPNEG0]], %[[CSTNEGINF]], %[[UB1]] : tensor<8xi1>, tensor<8xf32>624// CHECK: return %[[UB2]] : tensor<8xf32>625 626// -----627 628// CHECK-LABEL: func.func @math_fpowi_pos_odd_power629func.func @math_fpowi_pos_odd_power(%0 : tensor<8xf32>) -> tensor<8xf32> {630 %1 = arith.constant dense<5> : tensor<8xi64>631 %2 = math.fpowi %0, %1 : tensor<8xf32>, tensor<8xi64>632 return %2 : tensor<8xf32>633}634// CHECK-SAME: (%[[ARG0:.*]]: tensor<8xf32>) -> tensor<8xf32> {635// CHECK: %[[SQ:.*]] = arith.mulf %[[ARG0]], %[[ARG0]] : tensor<8xf32>636// CHECK: %[[PW4:.*]] = arith.mulf %[[SQ]], %[[SQ]] : tensor<8xf32>637// CHECK: %[[PW5:.*]] = arith.mulf %[[PW4]], %[[ARG0]] : tensor<8xf32>638// CHECK: return %[[PW5]] : tensor<8xf32>639 640// -----641 642// CHECK-LABEL: func.func @math_fpowi_pos_even_power643func.func @math_fpowi_pos_even_power(%0 : tensor<8xf32>) -> tensor<8xf32> {644 %1 = arith.constant dense<4> : tensor<8xi64>645 %2 = math.fpowi %0, %1 : tensor<8xf32>, tensor<8xi64>646 return %2 : tensor<8xf32>647}648// CHECK-SAME: (%[[ARG0:.*]]: tensor<8xf32>) -> tensor<8xf32> {649// CHECK: %[[SQ:.*]] = arith.mulf %[[ARG0]], %[[ARG0]] : tensor<8xf32>650// CHECK: %[[PW4:.*]] = arith.mulf %[[SQ]], %[[SQ]] : tensor<8xf32>651// CHECK: return %[[PW4]] : tensor<8xf32>652 653// -----654 655// CHECK-LABEL: func.func @math_fpowi_even_scalar656func.func @math_fpowi_even_scalar(%0 : f32) -> f32 {657 %pow = arith.constant 2 : i64658 %2 = math.fpowi %0, %pow : f32, i64659 return %2 : f32660}661// CHECK-SAME: (%[[ARG0:.*]]: f32) -> f32 {662// CHECK: %[[SQ:.*]] = arith.mulf %[[ARG0]], %[[ARG0]] : f32663// CHECK: return %[[SQ]] : f32664 665// -----666 667// CHECK-LABEL: func.func @math_fpowi_scalar_zero668func.func @math_fpowi_scalar_zero(%0 : f32) -> f32 {669 %pow = arith.constant 0 : i64670 %2 = math.fpowi %0, %pow : f32, i64671 return %2 : f32672}673// CHECK-SAME: (%[[ARG0:.*]]: f32) -> f32 {674// CHECK: %[[RET:.*]] = arith.constant 1.000000e+00 : f32675// CHECK: return %[[RET]] : f32676 677// -----678 679// CHECK-LABEL: func.func @math_fpowi_to_powf_tensor680func.func @math_fpowi_to_powf_tensor(%0 : tensor<8xf32>, %1: tensor<8xi32>) -> tensor<8xf32> {681 %2 = math.fpowi %0, %1 : tensor<8xf32>, tensor<8xi32>682 return %2 : tensor<8xf32>683}684// CHECK-SAME: (%[[ARG0:.*]]: tensor<8xf32>, %[[ARG1:.*]]: tensor<8xi32>) -> tensor<8xf32> {685// CHECK: %[[TOFP:.*]] = arith.sitofp %[[ARG1]] : tensor<8xi32> to tensor<8xf32>686// CHECK: %[[LOGA:.*]] = math.log %[[ARG0]] : tensor<8xf32>687// CHECK: %[[MUL:.*]] = arith.mulf %[[TOFP]], %[[LOGA]] : tensor<8xf32>688// CHECK: %[[EXP:.*]] = math.exp %[[MUL]] : tensor<8xf32>689// CHECK: return %[[EXP]]690// -----691 692// CHECK-LABEL: func.func @math_fpowi_to_powf_scalar693func.func @math_fpowi_to_powf_scalar(%0 : f32, %1: i64) -> f32 {694 %2 = math.fpowi %0, %1 : f32, i64695 return %2 : f32696}697// CHECK-SAME: (%[[ARG0:.*]]: f32, %[[ARG1:.*]]: i64) -> f32 {698// CHECK: %[[TOFP:.*]] = arith.sitofp %[[ARG1]] : i64 to f32699// CHECK: %[[LOGA:.*]] = math.log %[[ARG0]] : f32700// CHECK: %[[MUL:.*]] = arith.mulf %[[TOFP]], %[[LOGA]] : f32701// CHECK: %[[EXP:.*]] = math.exp %[[MUL]] : f32702// CHECK: return %[[EXP]] : f32703 704// -----705 706// CHECK-LABEL: func.func @rsqrt707// CHECK-SAME: (%[[ARG:.*]]: f16)708// CHECK-SAME: -> f16709// CHECK-DAG: %[[CST:.*]] = arith.constant 1.000000e+00 : f16710// CHECK-DAG: %[[SQRT:.*]] = math.sqrt %[[ARG]] : f16711// CHECK-DAG: %[[DIV:.*]] = arith.divf %[[CST]], %[[SQRT]] : f16712// CHECK: return %[[DIV]] : f16713func.func @rsqrt16(%float: f16) -> (f16) {714 %float_result = math.rsqrt %float : f16715 return %float_result : f16716}717 718// -----719 720// CHECK-LABEL: func.func @rsqrt721// CHECK-SAME: (%[[ARG:.*]]: f32)722// CHECK-SAME: -> f32723// CHECK-DAG: %[[CST:.*]] = arith.constant 1.000000e+00 : f32724// CHECK-DAG: %[[SQRT:.*]] = math.sqrt %[[ARG]] : f32725// CHECK-DAG: %[[DIV:.*]] = arith.divf %[[CST]], %[[SQRT]] : f32726// CHECK: return %[[DIV]] : f32727func.func @rsqrt32(%float: f32) -> (f32) {728 %float_result = math.rsqrt %float : f32729 return %float_result : f32730}731 732// -----733 734// CHECK-LABEL: func.func @rsqrt735// CHECK-SAME: (%[[ARG:.*]]: f64)736// CHECK-SAME: -> f64737// CHECK-DAG: %[[CST:.*]] = arith.constant 1.000000e+00 : f64738// CHECK-DAG: %[[SQRT:.*]] = math.sqrt %[[ARG]] : f64739// CHECK-DAG: %[[DIV:.*]] = arith.divf %[[CST]], %[[SQRT]] : f64740// CHECK: return %[[DIV]] : f64741func.func @rsqrt64(%float: f64) -> (f64) {742 %float_result = math.rsqrt %float : f64743 return %float_result : f64744}745 746// -----747 748// CHECK-LABEL: func.func @rsqrt_vec749// CHECK-SAME: (%[[ARG:.*]]: vector<5xf32>)750// CHECK-SAME: -> vector<5xf32>751// CHECK-DAG: %[[CST:.*]] = arith.constant dense<1.000000e+00> : vector<5xf32>752// CHECK-DAG: %[[SQRT:.*]] = math.sqrt %[[ARG]] : vector<5xf32>753// CHECK-DAG: %[[DIV:.*]] = arith.divf %[[CST]], %[[SQRT]] : vector<5xf32>754// CHECK: return %[[DIV]] : vector<5xf32>755func.func @rsqrt_vec(%float: vector<5xf32>) -> (vector<5xf32>) {756 %float_result = math.rsqrt %float : vector<5xf32>757 return %float_result : vector<5xf32>758}759 760// -----761 762// CHECK-LABEL: func.func @rsqrt_tns763// CHECK-SAME: (%[[ARG:.*]]: tensor<5x8xf32>)764// CHECK-SAME: -> tensor<5x8xf32>765// CHECK-DAG: %[[CST:.*]] = arith.constant dense<1.000000e+00> : tensor<5x8xf32>766// CHECK-DAG: %[[SQRT:.*]] = math.sqrt %[[ARG]] : tensor<5x8xf32>767// CHECK-DAG: %[[DIV:.*]] = arith.divf %[[CST]], %[[SQRT]] : tensor<5x8xf32>768// CHECK: return %[[DIV]] : tensor<5x8xf32>769func.func @rsqrt_tns(%float: tensor<5x8xf32>) -> (tensor<5x8xf32>) {770 %float_result = math.rsqrt %float : tensor<5x8xf32>771 return %float_result : tensor<5x8xf32>772}773 774// -----775 776// CHECK-LABEL: func.func @non_static_shape_ceil_op777// CHECK-SAME: (%[[ARG:.*]]: tensor<?xf32>)778// CHECK-SAME: -> tensor<?xf32>779// CHECK: %[[CEIL:.*]] = math.ceil %[[ARG]] : tensor<?xf32>780// CHECK: return %[[CEIL]] : tensor<?xf32>781 782func.func @non_static_shape_ceil_op(%arg: tensor<?xf32>) -> tensor<?xf32>{783 %a = math.ceil %arg : tensor<?xf32>784 return %a: tensor<?xf32>785}786 787// -----788 789// CHECK-LABEL: func.func @unranked_ceil_op790// CHECK-SAME: (%[[ARG:.*]]: tensor<*xf32>)791// CHECK-SAME: -> tensor<*xf32>792// CHECK: %[[CEIL:.*]] = math.ceil %[[ARG]] : tensor<*xf32>793// CHECK: return %[[CEIL]] : tensor<*xf32>794 795func.func @unranked_ceil_op(%arg: tensor<*xf32>) -> tensor<*xf32>{796 %a = math.ceil %arg : tensor<*xf32>797 return %a: tensor<*xf32>798}799 800// -----801 802// CHECK-LABEL: func.func @non_static_shape_rsqrt_op803// CHECK-SAME: (%[[ARG:.*]]: tensor<?xf32>)804// CHECK-SAME: -> tensor<?xf32>805// CHECK: %[[RSQRT:.*]] = math.rsqrt %[[ARG]] : tensor<?xf32>806// CHECK: return %[[RSQRT]] : tensor<?xf32>807 808func.func @non_static_shape_rsqrt_op(%arg: tensor<?xf32>) -> tensor<?xf32>{809 %a = math.rsqrt %arg : tensor<?xf32>810 return %a: tensor<?xf32>811}812 813// -----814 815// CHECK-LABEL: func.func @unranked_rsqrt_op816// CHECK-SAME: (%[[ARG:.*]]: tensor<*xf32>)817// CHECK-SAME: -> tensor<*xf32>818// CHECK: %[[RSQRT:.*]] = math.rsqrt %[[ARG]] : tensor<*xf32>819// CHECK: return %[[RSQRT]] : tensor<*xf32>820 821func.func @unranked_rsqrt_op(%arg: tensor<*xf32>) -> tensor<*xf32>{822 %a = math.rsqrt %arg : tensor<*xf32>823 return %a: tensor<*xf32>824}825 826// -----827 828// CHECK-LABEL: func.func @clampf_scalar_op829// CHECK-SAME: (%[[ARG:.*]]: f16, %[[MIN:.*]]: f16, %[[MAX:.*]]: f16)830// CHECK: %[[V0:.*]] = arith.minimumf %[[ARG]], %[[MIN]] : f16831// CHECK: %[[V1:.*]] = arith.maximumf %[[V0]], %[[MAX]] : f16832// CHECK: return %[[V1]] : f16833 834func.func @clampf_scalar_op(%arg: f16, %min: f16, %max: f16) -> f16 {835 %a = math.clampf %arg to [%min, %max] : f16836 return %a: f16837}838 839// CHECK-LABEL: func.func @clampf_vector_op840// CHECK-SAME: (%[[ARG:.*]]: vector<3x4xf32>, %[[MIN:.*]]: vector<3x4xf32>, %[[MAX:.*]]: vector<3x4xf32>)841// CHECK: %[[V0:.*]] = arith.minimumf %[[ARG]], %[[MIN]] fastmath<fast> : vector<3x4xf32>842// CHECK: %[[V1:.*]] = arith.maximumf %[[V0]], %[[MAX]] fastmath<fast> : vector<3x4xf32>843// CHECK: return %[[V1]] : vector<3x4xf32>844 845func.func @clampf_vector_op(%arg: vector<3x4xf32>, %min: vector<3x4xf32>, %max: vector<3x4xf32>) -> vector<3x4xf32>{846 %a = math.clampf %arg to [%min, %max] fastmath<fast> : vector<3x4xf32>847 return %a: vector<3x4xf32>848}849