991 lines · plain
1 2// RUN: mlir-opt %s -convert-math-to-libm -canonicalize | FileCheck %s3 4// CHECK-DAG: @acos(f64) -> f64 attributes {llvm.readnone}5// CHECK-DAG: @acosf(f32) -> f32 attributes {llvm.readnone}6// CHECK-DAG: @acosh(f64) -> f64 attributes {llvm.readnone}7// CHECK-DAG: @acoshf(f32) -> f32 attributes {llvm.readnone}8// CHECK-DAG: @asin(f64) -> f64 attributes {llvm.readnone}9// CHECK-DAG: @asinf(f32) -> f32 attributes {llvm.readnone}10// CHECK-DAG: @asinh(f64) -> f64 attributes {llvm.readnone}11// CHECK-DAG: @asinhf(f32) -> f32 attributes {llvm.readnone}12// CHECK-DAG: @atan(f64) -> f64 attributes {llvm.readnone}13// CHECK-DAG: @atanf(f32) -> f32 attributes {llvm.readnone}14// CHECK-DAG: @atanh(f64) -> f64 attributes {llvm.readnone}15// CHECK-DAG: @atanhf(f32) -> f32 attributes {llvm.readnone}16// CHECK-DAG: @erf(f64) -> f64 attributes {llvm.readnone}17// CHECK-DAG: @erff(f32) -> f32 attributes {llvm.readnone}18// CHECK-DAG: @exp(f64) -> f64 attributes {llvm.readnone}19// CHECK-DAG: @expf(f32) -> f32 attributes {llvm.readnone}20// CHECK-DAG: @exp2(f64) -> f64 attributes {llvm.readnone}21// CHECK-DAG: @exp2f(f32) -> f32 attributes {llvm.readnone}22// CHECK-DAG: @expm1(f64) -> f64 attributes {llvm.readnone}23// CHECK-DAG: @expm1f(f32) -> f32 attributes {llvm.readnone}24// CHECK-DAG: @log(f64) -> f64 attributes {llvm.readnone}25// CHECK-DAG: @logf(f32) -> f32 attributes {llvm.readnone}26// CHECK-DAG: @log2(f64) -> f64 attributes {llvm.readnone}27// CHECK-DAG: @log2f(f32) -> f32 attributes {llvm.readnone}28// CHECK-DAG: @log10(f64) -> f64 attributes {llvm.readnone}29// CHECK-DAG: @log10f(f32) -> f32 attributes {llvm.readnone}30// CHECK-DAG: @log1p(f64) -> f64 attributes {llvm.readnone}31// CHECK-DAG: @log1pf(f32) -> f32 attributes {llvm.readnone}32// CHECK-DAG: @fabs(f64) -> f64 attributes {llvm.readnone}33// CHECK-DAG: @fabsf(f32) -> f32 attributes {llvm.readnone}34// CHECK-DAG: @fma(f64, f64, f64) -> f64 attributes {llvm.readnone}35// CHECK-DAG: @fmaf(f32, f32, f32) -> f32 attributes {llvm.readnone}36// CHECK-DAG: @atan2(f64, f64) -> f64 attributes {llvm.readnone}37// CHECK-DAG: @atan2f(f32, f32) -> f32 attributes {llvm.readnone}38// CHECK-DAG: @cbrt(f64) -> f64 attributes {llvm.readnone}39// CHECK-DAG: @cbrtf(f32) -> f32 attributes {llvm.readnone}40// CHECK-DAG: @tan(f64) -> f64 attributes {llvm.readnone}41// CHECK-DAG: @tanf(f32) -> f32 attributes {llvm.readnone}42// CHECK-DAG: @tanh(f64) -> f64 attributes {llvm.readnone}43// CHECK-DAG: @tanhf(f32) -> f32 attributes {llvm.readnone}44// CHECK-DAG: @round(f64) -> f64 attributes {llvm.readnone}45// CHECK-DAG: @roundf(f32) -> f32 attributes {llvm.readnone}46// CHECK-DAG: @roundeven(f64) -> f64 attributes {llvm.readnone}47// CHECK-DAG: @roundevenf(f32) -> f32 attributes {llvm.readnone}48// CHECK-DAG: @trunc(f64) -> f64 attributes {llvm.readnone}49// CHECK-DAG: @truncf(f32) -> f32 attributes {llvm.readnone}50// CHECK-DAG: @cos(f64) -> f64 attributes {llvm.readnone}51// CHECK-DAG: @cosf(f32) -> f32 attributes {llvm.readnone}52// CHECK-DAG: @cosh(f64) -> f64 attributes {llvm.readnone}53// CHECK-DAG: @coshf(f32) -> f32 attributes {llvm.readnone}54// CHECK-DAG: @sin(f64) -> f64 attributes {llvm.readnone}55// CHECK-DAG: @sinf(f32) -> f32 attributes {llvm.readnone}56// CHECK-DAG: @floor(f64) -> f64 attributes {llvm.readnone}57// CHECK-DAG: @floorf(f32) -> f32 attributes {llvm.readnone}58// CHECK-DAG: @ceil(f64) -> f64 attributes {llvm.readnone}59// CHECK-DAG: @ceilf(f32) -> f32 attributes {llvm.readnone}60// CHECK-DAG: @sqrt(f64) -> f64 attributes {llvm.readnone}61// CHECK-DAG: @sqrtf(f32) -> f32 attributes {llvm.readnone}62// CHECK-DAG: @rsqrt(f64) -> f64 attributes {llvm.readnone}63// CHECK-DAG: @rsqrtf(f32) -> f32 attributes {llvm.readnone}64// CHECK-DAG: @pow(f64, f64) -> f64 attributes {llvm.readnone}65// CHECK-DAG: @powf(f32, f32) -> f32 attributes {llvm.readnone}66 67// CHECK-LABEL: func @absf_caller68// CHECK-SAME: %[[FLOAT:.*]]: f3269// CHECK-SAME: %[[DOUBLE:.*]]: f6470func.func @absf_caller(%float: f32, %double: f64) -> (f32, f64) {71 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @fabsf(%[[FLOAT]]) : (f32) -> f3272 %float_result = math.absf %float : f3273 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @fabs(%[[DOUBLE]]) : (f64) -> f6474 %double_result = math.absf %double : f6475 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]76 return %float_result, %double_result : f32, f6477}78 79// CHECK-LABEL: func @absf_vec_caller(80// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,81// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {82// CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>83// CHECK: %[[OUT0_F32:.*]] = call @fabsf(%[[IN0_F32]]) : (f32) -> f3284// CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>85// CHECK: %[[OUT1_F32:.*]] = call @fabsf(%[[IN1_F32]]) : (f32) -> f3286// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>87// CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>88// CHECK: %[[OUT0_F64:.*]] = call @fabs(%[[IN0_F64]]) : (f64) -> f6489// CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>90// CHECK: %[[OUT1_F64:.*]] = call @fabs(%[[IN1_F64]]) : (f64) -> f6491// CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>92// CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>93// CHECK: }94func.func @absf_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {95 %float_result = math.absf %float : vector<2xf32>96 %double_result = math.absf %double : vector<2xf64>97 return %float_result, %double_result : vector<2xf32>, vector<2xf64>98}99 100// CHECK-LABEL: func @acos_caller101// CHECK-SAME: %[[FLOAT:.*]]: f32102// CHECK-SAME: %[[DOUBLE:.*]]: f64103func.func @acos_caller(%float: f32, %double: f64) -> (f32, f64) {104 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @acosf(%[[FLOAT]]) : (f32) -> f32105 %float_result = math.acos %float : f32106 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @acos(%[[DOUBLE]]) : (f64) -> f64107 %double_result = math.acos %double : f64108 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]109 return %float_result, %double_result : f32, f64110}111 112// CHECK-LABEL: func @acos_vec_caller(113// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,114// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {115// CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>116// CHECK: %[[OUT0_F32:.*]] = call @acosf(%[[IN0_F32]]) : (f32) -> f32117// CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>118// CHECK: %[[OUT1_F32:.*]] = call @acosf(%[[IN1_F32]]) : (f32) -> f32119// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>120// CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>121// CHECK: %[[OUT0_F64:.*]] = call @acos(%[[IN0_F64]]) : (f64) -> f64122// CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>123// CHECK: %[[OUT1_F64:.*]] = call @acos(%[[IN1_F64]]) : (f64) -> f64124// CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>125// CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>126// CHECK: }127func.func @acos_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {128 %float_result = math.acos %float : vector<2xf32>129 %double_result = math.acos %double : vector<2xf64>130 return %float_result, %double_result : vector<2xf32>, vector<2xf64>131}132 133// CHECK-LABEL: func @acosh_caller134// CHECK-SAME: %[[FLOAT:.*]]: f32135// CHECK-SAME: %[[DOUBLE:.*]]: f64136func.func @acosh_caller(%float: f32, %double: f64) -> (f32, f64) {137 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @acoshf(%[[FLOAT]]) : (f32) -> f32138 %float_result = math.acosh %float : f32139 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @acosh(%[[DOUBLE]]) : (f64) -> f64140 %double_result = math.acosh %double : f64141 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]142 return %float_result, %double_result : f32, f64143}144 145// CHECK-LABEL: func @acosh_vec_caller(146// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,147// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {148// CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>149// CHECK: %[[OUT0_F32:.*]] = call @acoshf(%[[IN0_F32]]) : (f32) -> f32150// CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>151// CHECK: %[[OUT1_F32:.*]] = call @acoshf(%[[IN1_F32]]) : (f32) -> f32152// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>153// CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>154// CHECK: %[[OUT0_F64:.*]] = call @acosh(%[[IN0_F64]]) : (f64) -> f64155// CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>156// CHECK: %[[OUT1_F64:.*]] = call @acosh(%[[IN1_F64]]) : (f64) -> f64157// CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>158// CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>159// CHECK: }160func.func @acosh_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {161 %float_result = math.acosh %float : vector<2xf32>162 %double_result = math.acosh %double : vector<2xf64>163 return %float_result, %double_result : vector<2xf32>, vector<2xf64>164}165 166// CHECK-LABEL: func @asin_caller167// CHECK-SAME: %[[FLOAT:.*]]: f32168// CHECK-SAME: %[[DOUBLE:.*]]: f64169func.func @asin_caller(%float: f32, %double: f64) -> (f32, f64) {170 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @asinf(%[[FLOAT]]) : (f32) -> f32171 %float_result = math.asin %float : f32172 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @asin(%[[DOUBLE]]) : (f64) -> f64173 %double_result = math.asin %double : f64174 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]175 return %float_result, %double_result : f32, f64176}177 178// CHECK-LABEL: func @asin_vec_caller(179// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,180// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {181// CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>182// CHECK: %[[OUT0_F32:.*]] = call @asinf(%[[IN0_F32]]) : (f32) -> f32183// CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>184// CHECK: %[[OUT1_F32:.*]] = call @asinf(%[[IN1_F32]]) : (f32) -> f32185// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>186// CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>187// CHECK: %[[OUT0_F64:.*]] = call @asin(%[[IN0_F64]]) : (f64) -> f64188// CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>189// CHECK: %[[OUT1_F64:.*]] = call @asin(%[[IN1_F64]]) : (f64) -> f64190// CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>191// CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>192// CHECK: }193func.func @asin_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {194 %float_result = math.asin %float : vector<2xf32>195 %double_result = math.asin %double : vector<2xf64>196 return %float_result, %double_result : vector<2xf32>, vector<2xf64>197}198 199// CHECK-LABEL: func @asinh_caller200// CHECK-SAME: %[[FLOAT:.*]]: f32201// CHECK-SAME: %[[DOUBLE:.*]]: f64202func.func @asinh_caller(%float: f32, %double: f64) -> (f32, f64) {203 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @asinhf(%[[FLOAT]]) : (f32) -> f32204 %float_result = math.asinh %float : f32205 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @asinh(%[[DOUBLE]]) : (f64) -> f64206 %double_result = math.asinh %double : f64207 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]208 return %float_result, %double_result : f32, f64209}210 211// CHECK-LABEL: func @asinh_vec_caller(212// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,213// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {214// CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>215// CHECK: %[[OUT0_F32:.*]] = call @asinhf(%[[IN0_F32]]) : (f32) -> f32216// CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>217// CHECK: %[[OUT1_F32:.*]] = call @asinhf(%[[IN1_F32]]) : (f32) -> f32218// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>219// CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>220// CHECK: %[[OUT0_F64:.*]] = call @asinh(%[[IN0_F64]]) : (f64) -> f64221// CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>222// CHECK: %[[OUT1_F64:.*]] = call @asinh(%[[IN1_F64]]) : (f64) -> f64223// CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>224// CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>225// CHECK: }226func.func @asinh_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {227 %float_result = math.asinh %float : vector<2xf32>228 %double_result = math.asinh %double : vector<2xf64>229 return %float_result, %double_result : vector<2xf32>, vector<2xf64>230}231 232// CHECK-LABEL: func @atan_caller233// CHECK-SAME: %[[FLOAT:.*]]: f32234// CHECK-SAME: %[[DOUBLE:.*]]: f64235// CHECK-SAME: %[[HALF:.*]]: f16236// CHECK-SAME: %[[BFLOAT:.*]]: bf16237func.func @atan_caller(%float: f32, %double: f64, %half: f16, %bfloat: bf16) -> (f32, f64, f16, bf16) {238 // CHECK: %[[FLOAT_RESULT:.*]] = call @atanf(%[[FLOAT]]) : (f32) -> f32239 %float_result = math.atan %float : f32240 // CHECK: %[[DOUBLE_RESULT:.*]] = call @atan(%[[DOUBLE]]) : (f64) -> f64241 %double_result = math.atan %double : f64242 // CHECK: %[[HALF_PROMOTED:.*]] = arith.extf %[[HALF]] : f16 to f32243 // CHECK: %[[HALF_CALL:.*]] = call @atanf(%[[HALF_PROMOTED]]) : (f32) -> f32244 // CHECK: %[[HALF_RESULT:.*]] = arith.truncf %[[HALF_CALL]] : f32 to f16245 %half_result = math.atan %half : f16246 // CHECK: %[[BFLOAT_PROMOTED:.*]] = arith.extf %[[BFLOAT]] : bf16 to f32247 // CHECK: %[[BFLOAT_CALL:.*]] = call @atanf(%[[BFLOAT_PROMOTED]]) : (f32) -> f32248 // CHECK: %[[BFLOAT_RESULT:.*]] = arith.truncf %[[BFLOAT_CALL]] : f32 to bf16249 %bfloat_result = math.atan %bfloat : bf16250 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]], %[[HALF_RESULT]], %[[BFLOAT_RESULT]]251 return %float_result, %double_result, %half_result, %bfloat_result : f32, f64, f16, bf16252}253 254// CHECK-LABEL: func @atan_vec_caller(255// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,256// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {257// CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>258// CHECK: %[[OUT0_F32:.*]] = call @atanf(%[[IN0_F32]]) : (f32) -> f32259// CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>260// CHECK: %[[OUT1_F32:.*]] = call @atanf(%[[IN1_F32]]) : (f32) -> f32261// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>262// CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>263// CHECK: %[[OUT0_F64:.*]] = call @atan(%[[IN0_F64]]) : (f64) -> f64264// CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>265// CHECK: %[[OUT1_F64:.*]] = call @atan(%[[IN1_F64]]) : (f64) -> f64266// CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>267// CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>268// CHECK: }269func.func @atan_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {270 %float_result = math.atan %float : vector<2xf32>271 %double_result = math.atan %double : vector<2xf64>272 return %float_result, %double_result : vector<2xf32>, vector<2xf64>273}274 275// CHECK-LABEL: func @atanh_caller276// CHECK-SAME: %[[FLOAT:.*]]: f32277// CHECK-SAME: %[[DOUBLE:.*]]: f64278// CHECK-SAME: %[[HALF:.*]]: f16279// CHECK-SAME: %[[BFLOAT:.*]]: bf16280func.func @atanh_caller(%float: f32, %double: f64, %half: f16, %bfloat: bf16) -> (f32, f64, f16, bf16) {281 // CHECK: %[[FLOAT_RESULT:.*]] = call @atanhf(%[[FLOAT]]) : (f32) -> f32282 %float_result = math.atanh %float : f32283 // CHECK: %[[DOUBLE_RESULT:.*]] = call @atanh(%[[DOUBLE]]) : (f64) -> f64284 %double_result = math.atanh %double : f64285 // CHECK: %[[HALF_PROMOTED:.*]] = arith.extf %[[HALF]] : f16 to f32286 // CHECK: %[[HALF_CALL:.*]] = call @atanhf(%[[HALF_PROMOTED]]) : (f32) -> f32287 // CHECK: %[[HALF_RESULT:.*]] = arith.truncf %[[HALF_CALL]] : f32 to f16288 %half_result = math.atanh %half : f16289 // CHECK: %[[BFLOAT_PROMOTED:.*]] = arith.extf %[[BFLOAT]] : bf16 to f32290 // CHECK: %[[BFLOAT_CALL:.*]] = call @atanhf(%[[BFLOAT_PROMOTED]]) : (f32) -> f32291 // CHECK: %[[BFLOAT_RESULT:.*]] = arith.truncf %[[BFLOAT_CALL]] : f32 to bf16292 %bfloat_result = math.atanh %bfloat : bf16293 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]], %[[HALF_RESULT]], %[[BFLOAT_RESULT]]294 return %float_result, %double_result, %half_result, %bfloat_result : f32, f64, f16, bf16295}296 297// CHECK-LABEL: func @atanh_vec_caller(298// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,299// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {300// CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>301// CHECK: %[[OUT0_F32:.*]] = call @atanhf(%[[IN0_F32]]) : (f32) -> f32302// CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>303// CHECK: %[[OUT1_F32:.*]] = call @atanhf(%[[IN1_F32]]) : (f32) -> f32304// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>305// CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>306// CHECK: %[[OUT0_F64:.*]] = call @atanh(%[[IN0_F64]]) : (f64) -> f64307// CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>308// CHECK: %[[OUT1_F64:.*]] = call @atanh(%[[IN1_F64]]) : (f64) -> f64309// CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>310// CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>311// CHECK: }312func.func @atanh_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {313 %float_result = math.atanh %float : vector<2xf32>314 %double_result = math.atanh %double : vector<2xf64>315 return %float_result, %double_result : vector<2xf32>, vector<2xf64>316}317 318// CHECK-LABEL: func @tanh_caller319// CHECK-SAME: %[[FLOAT:.*]]: f32320// CHECK-SAME: %[[DOUBLE:.*]]: f64321func.func @tanh_caller(%float: f32, %double: f64) -> (f32, f64) {322 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @tanhf(%[[FLOAT]]) : (f32) -> f32323 %float_result = math.tanh %float : f32324 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @tanh(%[[DOUBLE]]) : (f64) -> f64325 %double_result = math.tanh %double : f64326 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]327 return %float_result, %double_result : f32, f64328}329 330// CHECK-LABEL: func @cosh_caller331// CHECK-SAME: %[[FLOAT:.*]]: f32332// CHECK-SAME: %[[DOUBLE:.*]]: f64333func.func @cosh_caller(%float: f32, %double: f64) -> (f32, f64) {334 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @coshf(%[[FLOAT]]) : (f32) -> f32335 %float_result = math.cosh %float : f32336 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @cosh(%[[DOUBLE]]) : (f64) -> f64337 %double_result = math.cosh %double : f64338 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]339 return %float_result, %double_result : f32, f64340}341 342// CHECK-LABEL: func @sinh_caller343// CHECK-SAME: %[[FLOAT:.*]]: f32344// CHECK-SAME: %[[DOUBLE:.*]]: f64345func.func @sinh_caller(%float: f32, %double: f64) -> (f32, f64) {346 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @sinhf(%[[FLOAT]]) : (f32) -> f32347 %float_result = math.sinh %float : f32348 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @sinh(%[[DOUBLE]]) : (f64) -> f64349 %double_result = math.sinh %double : f64350 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]351 return %float_result, %double_result : f32, f64352}353 354// CHECK-LABEL: func @atan2_caller355// CHECK-SAME: %[[FLOAT:.*]]: f32356// CHECK-SAME: %[[DOUBLE:.*]]: f64357// CHECK-SAME: %[[HALF:.*]]: f16358// CHECK-SAME: %[[BFLOAT:.*]]: bf16359func.func @atan2_caller(%float: f32, %double: f64, %half: f16, %bfloat: bf16) -> (f32, f64, f16, bf16) {360 // CHECK: %[[FLOAT_RESULT:.*]] = call @atan2f(%[[FLOAT]], %[[FLOAT]]) : (f32, f32) -> f32361 %float_result = math.atan2 %float, %float : f32362 // CHECK: %[[DOUBLE_RESULT:.*]] = call @atan2(%[[DOUBLE]], %[[DOUBLE]]) : (f64, f64) -> f64363 %double_result = math.atan2 %double, %double : f64364 // CHECK: %[[HALF_PROMOTED1:.*]] = arith.extf %[[HALF]] : f16 to f32365 // CHECK: %[[HALF_PROMOTED2:.*]] = arith.extf %[[HALF]] : f16 to f32366 // CHECK: %[[HALF_CALL:.*]] = call @atan2f(%[[HALF_PROMOTED1]], %[[HALF_PROMOTED2]]) : (f32, f32) -> f32367 // CHECK: %[[HALF_RESULT:.*]] = arith.truncf %[[HALF_CALL]] : f32 to f16368 %half_result = math.atan2 %half, %half : f16369 // CHECK: %[[BFLOAT_PROMOTED1:.*]] = arith.extf %[[BFLOAT]] : bf16 to f32370 // CHECK: %[[BFLOAT_PROMOTED2:.*]] = arith.extf %[[BFLOAT]] : bf16 to f32371 // CHECK: %[[BFLOAT_CALL:.*]] = call @atan2f(%[[BFLOAT_PROMOTED1]], %[[BFLOAT_PROMOTED2]]) : (f32, f32) -> f32372 // CHECK: %[[BFLOAT_RESULT:.*]] = arith.truncf %[[BFLOAT_CALL]] : f32 to bf16373 %bfloat_result = math.atan2 %bfloat, %bfloat : bf16374 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]], %[[HALF_RESULT]], %[[BFLOAT_RESULT]]375 return %float_result, %double_result, %half_result, %bfloat_result : f32, f64, f16, bf16376}377 378// CHECK-LABEL: func @erf_caller379// CHECK-SAME: %[[FLOAT:.*]]: f32380// CHECK-SAME: %[[DOUBLE:.*]]: f64381func.func @erf_caller(%float: f32, %double: f64) -> (f32, f64) {382 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @erff(%[[FLOAT]]) : (f32) -> f32383 %float_result = math.erf %float : f32384 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @erf(%[[DOUBLE]]) : (f64) -> f64385 %double_result = math.erf %double : f64386 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]387 return %float_result, %double_result : f32, f64388}389 390// CHECK-LABEL: func @erf_vec_caller(391// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,392// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {393func.func @erf_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {394 // CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>395 // CHECK: %[[OUT0_F32:.*]] = call @erff(%[[IN0_F32]]) : (f32) -> f32396 // CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>397 // CHECK: %[[OUT1_F32:.*]] = call @erff(%[[IN1_F32]]) : (f32) -> f32398 // CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>399 %float_result = math.erf %float : vector<2xf32>400 // CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>401 // CHECK: %[[OUT0_F64:.*]] = call @erf(%[[IN0_F64]]) : (f64) -> f64402 // CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>403 // CHECK: %[[OUT1_F64:.*]] = call @erf(%[[IN1_F64]]) : (f64) -> f64404 // CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>405 %double_result = math.erf %double : vector<2xf64>406 // CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>407 return %float_result, %double_result : vector<2xf32>, vector<2xf64>408}409 410// CHECK-LABEL: func @exp_caller411// CHECK-SAME: %[[FLOAT:.*]]: f32412// CHECK-SAME: %[[DOUBLE:.*]]: f64413func.func @exp_caller(%float: f32, %double: f64) -> (f32, f64) {414 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @expf(%[[FLOAT]]) : (f32) -> f32415 %float_result = math.exp %float : f32416 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @exp(%[[DOUBLE]]) : (f64) -> f64417 %double_result = math.exp %double : f64418 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]419 return %float_result, %double_result : f32, f64420}421 422func.func @exp_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {423 %float_result = math.exp %float : vector<2xf32>424 %double_result = math.exp %double : vector<2xf64>425 return %float_result, %double_result : vector<2xf32>, vector<2xf64>426}427// CHECK-LABEL: func @exp_vec_caller(428// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,429// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {430// CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>431// CHECK: %[[OUT0_F32:.*]] = call @expf(%[[IN0_F32]]) : (f32) -> f32432// CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>433// CHECK: %[[OUT1_F32:.*]] = call @expf(%[[IN1_F32]]) : (f32) -> f32434// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>435// CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>436// CHECK: %[[OUT0_F64:.*]] = call @exp(%[[IN0_F64]]) : (f64) -> f64437// CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>438// CHECK: %[[OUT1_F64:.*]] = call @exp(%[[IN1_F64]]) : (f64) -> f64439// CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>440// CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>441// CHECK: }442 443// CHECK-LABEL: func @exp2_caller444// CHECK-SAME: %[[FLOAT:.*]]: f32445// CHECK-SAME: %[[DOUBLE:.*]]: f64446func.func @exp2_caller(%float: f32, %double: f64) -> (f32, f64) {447 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @exp2f(%[[FLOAT]]) : (f32) -> f32448 %float_result = math.exp2 %float : f32449 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @exp2(%[[DOUBLE]]) : (f64) -> f64450 %double_result = math.exp2 %double : f64451 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]452 return %float_result, %double_result : f32, f64453}454 455func.func @exp2_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {456 %float_result = math.exp2 %float : vector<2xf32>457 %double_result = math.exp2 %double : vector<2xf64>458 return %float_result, %double_result : vector<2xf32>, vector<2xf64>459}460// CHECK-LABEL: func @exp2_vec_caller(461// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,462// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {463// CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>464// CHECK: %[[OUT0_F32:.*]] = call @exp2f(%[[IN0_F32]]) : (f32) -> f32465// CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>466// CHECK: %[[OUT1_F32:.*]] = call @exp2f(%[[IN1_F32]]) : (f32) -> f32467// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>468// CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>469// CHECK: %[[OUT0_F64:.*]] = call @exp2(%[[IN0_F64]]) : (f64) -> f64470// CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>471// CHECK: %[[OUT1_F64:.*]] = call @exp2(%[[IN1_F64]]) : (f64) -> f64472// CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>473// CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>474// CHECK: }475 476// CHECK-LABEL: func @log_caller477// CHECK-SAME: %[[FLOAT:.*]]: f32478// CHECK-SAME: %[[DOUBLE:.*]]: f64479func.func @log_caller(%float: f32, %double: f64) -> (f32, f64) {480 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @logf(%[[FLOAT]]) : (f32) -> f32481 %float_result = math.log %float : f32482 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @log(%[[DOUBLE]]) : (f64) -> f64483 %double_result = math.log %double : f64484 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]485 return %float_result, %double_result : f32, f64486}487 488func.func @log_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {489 %float_result = math.log %float : vector<2xf32>490 %double_result = math.log %double : vector<2xf64>491 return %float_result, %double_result : vector<2xf32>, vector<2xf64>492}493// CHECK-LABEL: func @log_vec_caller(494// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,495// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {496// CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>497// CHECK: %[[OUT0_F32:.*]] = call @logf(%[[IN0_F32]]) : (f32) -> f32498// CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>499// CHECK: %[[OUT1_F32:.*]] = call @logf(%[[IN1_F32]]) : (f32) -> f32500// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>501// CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>502// CHECK: %[[OUT0_F64:.*]] = call @log(%[[IN0_F64]]) : (f64) -> f64503// CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>504// CHECK: %[[OUT1_F64:.*]] = call @log(%[[IN1_F64]]) : (f64) -> f64505// CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>506// CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>507// CHECK: }508 509// CHECK-LABEL: func @log2_caller510// CHECK-SAME: %[[FLOAT:.*]]: f32511// CHECK-SAME: %[[DOUBLE:.*]]: f64512func.func @log2_caller(%float: f32, %double: f64) -> (f32, f64) {513 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @log2f(%[[FLOAT]]) : (f32) -> f32514 %float_result = math.log2 %float : f32515 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @log2(%[[DOUBLE]]) : (f64) -> f64516 %double_result = math.log2 %double : f64517 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]518 return %float_result, %double_result : f32, f64519}520 521func.func @log2_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {522 %float_result = math.log2 %float : vector<2xf32>523 %double_result = math.log2 %double : vector<2xf64>524 return %float_result, %double_result : vector<2xf32>, vector<2xf64>525}526// CHECK-LABEL: func @log2_vec_caller(527// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,528// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {529// CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>530// CHECK: %[[OUT0_F32:.*]] = call @log2f(%[[IN0_F32]]) : (f32) -> f32531// CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>532// CHECK: %[[OUT1_F32:.*]] = call @log2f(%[[IN1_F32]]) : (f32) -> f32533// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>534// CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>535// CHECK: %[[OUT0_F64:.*]] = call @log2(%[[IN0_F64]]) : (f64) -> f64536// CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>537// CHECK: %[[OUT1_F64:.*]] = call @log2(%[[IN1_F64]]) : (f64) -> f64538// CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>539// CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>540// CHECK: }541 542// CHECK-LABEL: func @log10_caller543// CHECK-SAME: %[[FLOAT:.*]]: f32544// CHECK-SAME: %[[DOUBLE:.*]]: f64545func.func @log10_caller(%float: f32, %double: f64) -> (f32, f64) {546 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @log10f(%[[FLOAT]]) : (f32) -> f32547 %float_result = math.log10 %float : f32548 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @log10(%[[DOUBLE]]) : (f64) -> f64549 %double_result = math.log10 %double : f64550 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]551 return %float_result, %double_result : f32, f64552}553 554func.func @log10_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {555 %float_result = math.log10 %float : vector<2xf32>556 %double_result = math.log10 %double : vector<2xf64>557 return %float_result, %double_result : vector<2xf32>, vector<2xf64>558}559// CHECK-LABEL: func @log10_vec_caller(560// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,561// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {562// CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>563// CHECK: %[[OUT0_F32:.*]] = call @log10f(%[[IN0_F32]]) : (f32) -> f32564// CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>565// CHECK: %[[OUT1_F32:.*]] = call @log10f(%[[IN1_F32]]) : (f32) -> f32566// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>567// CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>568// CHECK: %[[OUT0_F64:.*]] = call @log10(%[[IN0_F64]]) : (f64) -> f64569// CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>570// CHECK: %[[OUT1_F64:.*]] = call @log10(%[[IN1_F64]]) : (f64) -> f64571// CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>572// CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>573// CHECK: }574 575// CHECK-LABEL: func @expm1_caller576// CHECK-SAME: %[[FLOAT:.*]]: f32577// CHECK-SAME: %[[DOUBLE:.*]]: f64578func.func @expm1_caller(%float: f32, %double: f64) -> (f32, f64) {579 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @expm1f(%[[FLOAT]]) : (f32) -> f32580 %float_result = math.expm1 %float : f32581 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @expm1(%[[DOUBLE]]) : (f64) -> f64582 %double_result = math.expm1 %double : f64583 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]584 return %float_result, %double_result : f32, f64585}586 587func.func @expm1_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {588 %float_result = math.expm1 %float : vector<2xf32>589 %double_result = math.expm1 %double : vector<2xf64>590 return %float_result, %double_result : vector<2xf32>, vector<2xf64>591}592// CHECK-LABEL: func @expm1_vec_caller(593// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,594// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {595// CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>596// CHECK: %[[OUT0_F32:.*]] = call @expm1f(%[[IN0_F32]]) : (f32) -> f32597// CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>598// CHECK: %[[OUT1_F32:.*]] = call @expm1f(%[[IN1_F32]]) : (f32) -> f32599// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>600// CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>601// CHECK: %[[OUT0_F64:.*]] = call @expm1(%[[IN0_F64]]) : (f64) -> f64602// CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>603// CHECK: %[[OUT1_F64:.*]] = call @expm1(%[[IN1_F64]]) : (f64) -> f64604// CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>605// CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>606// CHECK: }607 608func.func @expm1_multidim_vec_caller(%float: vector<2x2xf32>) -> (vector<2x2xf32>) {609 %result = math.expm1 %float : vector<2x2xf32>610 return %result : vector<2x2xf32>611}612// CHECK-LABEL: func @expm1_multidim_vec_caller(613// CHECK-SAME: %[[VAL:.*]]: vector<2x2xf32>614// CHECK: %[[IN0_0_F32:.*]] = vector.extract %[[VAL]][0, 0] : f32 from vector<2x2xf32>615// CHECK: %[[OUT0_0_F32:.*]] = call @expm1f(%[[IN0_0_F32]]) : (f32) -> f32616// CHECK: %[[IN0_1_F32:.*]] = vector.extract %[[VAL]][0, 1] : f32 from vector<2x2xf32>617// CHECK: %[[OUT0_1_F32:.*]] = call @expm1f(%[[IN0_1_F32]]) : (f32) -> f32618// CHECK: %[[IN1_0_F32:.*]] = vector.extract %[[VAL]][1, 0] : f32 from vector<2x2xf32>619// CHECK: %[[OUT1_0_F32:.*]] = call @expm1f(%[[IN1_0_F32]]) : (f32) -> f32620// CHECK: %[[IN1_1_F32:.*]] = vector.extract %[[VAL]][1, 1] : f32 from vector<2x2xf32>621// CHECK: %[[OUT1_1_F32:.*]] = call @expm1f(%[[IN1_1_F32]]) : (f32) -> f32622// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_0_F32]], %[[OUT0_1_F32]], %[[OUT1_0_F32]], %[[OUT1_1_F32]] : vector<2x2xf32>623// CHECK: return %[[RES_F32]] : vector<2x2xf32>624// CHECK: }625 626// CHECK-LABEL: func @fma_caller(627// CHECK-SAME: %[[FLOATA:.*]]: f32, %[[FLOATB:.*]]: f32, %[[FLOATC:.*]]: f32628// CHECK-SAME: %[[DOUBLEA:.*]]: f64, %[[DOUBLEB:.*]]: f64, %[[DOUBLEC:.*]]: f64629func.func @fma_caller(%float_a: f32, %float_b: f32, %float_c: f32, %double_a: f64, %double_b: f64, %double_c: f64) -> (f32, f64) {630 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @fmaf(%[[FLOATA]], %[[FLOATB]], %[[FLOATC]]) : (f32, f32, f32) -> f32631 %float_result = math.fma %float_a, %float_b, %float_c : f32632 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @fma(%[[DOUBLEA]], %[[DOUBLEB]], %[[DOUBLEC]]) : (f64, f64, f64) -> f64633 %double_result = math.fma %double_a, %double_b, %double_c : f64634 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]635 return %float_result, %double_result : f32, f64636}637 638func.func @fma_vec_caller(%float_a: vector<2xf32>, %float_b: vector<2xf32>, %float_c: vector<2xf32>, %double_a: vector<2xf64>, %double_b: vector<2xf64>, %double_c: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {639 %float_result = math.fma %float_a, %float_b, %float_c : vector<2xf32>640 %double_result = math.fma %double_a, %double_b, %double_c : vector<2xf64>641 return %float_result, %double_result : vector<2xf32>, vector<2xf64>642}643// CHECK-LABEL: func @fma_vec_caller(644// CHECK-SAME: %[[VAL_0A:.*]]: vector<2xf32>, %[[VAL_0B:.*]]: vector<2xf32>, %[[VAL_0C:.*]]: vector<2xf32>,645// CHECK-SAME: %[[VAL_1A:.*]]: vector<2xf64>, %[[VAL_1B:.*]]: vector<2xf64>, %[[VAL_1C:.*]]: vector<2xf64>646// CHECK-SAME: ) -> (vector<2xf32>, vector<2xf64>) {647// CHECK: %[[IN0_F32A:.*]] = vector.extract %[[VAL_0A]][0] : f32 from vector<2xf32>648// CHECK: %[[IN0_F32B:.*]] = vector.extract %[[VAL_0B]][0] : f32 from vector<2xf32>649// CHECK: %[[IN0_F32C:.*]] = vector.extract %[[VAL_0C]][0] : f32 from vector<2xf32>650// CHECK: %[[OUT0_F32:.*]] = call @fmaf(%[[IN0_F32A]], %[[IN0_F32B]], %[[IN0_F32C]]) : (f32, f32, f32) -> f32651// CHECK: %[[IN1_F32A:.*]] = vector.extract %[[VAL_0A]][1] : f32 from vector<2xf32>652// CHECK: %[[IN1_F32B:.*]] = vector.extract %[[VAL_0B]][1] : f32 from vector<2xf32>653// CHECK: %[[IN1_F32C:.*]] = vector.extract %[[VAL_0C]][1] : f32 from vector<2xf32>654// CHECK: %[[OUT1_F32:.*]] = call @fmaf(%[[IN1_F32A]], %[[IN1_F32B]], %[[IN1_F32C]]) : (f32, f32, f32) -> f32655// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>656// CHECK: %[[IN0_F64A:.*]] = vector.extract %[[VAL_1A]][0] : f64 from vector<2xf64>657// CHECK: %[[IN0_F64B:.*]] = vector.extract %[[VAL_1B]][0] : f64 from vector<2xf64>658// CHECK: %[[IN0_F64C:.*]] = vector.extract %[[VAL_1C]][0] : f64 from vector<2xf64>659// CHECK: %[[OUT0_F64:.*]] = call @fma(%[[IN0_F64A]], %[[IN0_F64B]], %[[IN0_F64C]]) : (f64, f64, f64) -> f64660// CHECK: %[[IN1_F64A:.*]] = vector.extract %[[VAL_1A]][1] : f64 from vector<2xf64>661// CHECK: %[[IN1_F64B:.*]] = vector.extract %[[VAL_1B]][1] : f64 from vector<2xf64>662// CHECK: %[[IN1_F64C:.*]] = vector.extract %[[VAL_1C]][1] : f64 from vector<2xf64>663// CHECK: %[[OUT1_F64:.*]] = call @fma(%[[IN1_F64A]], %[[IN1_F64B]], %[[IN1_F64C]]) : (f64, f64, f64) -> f64664// CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>665// CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>666// CHECK: }667 668// CHECK-LABEL: func @round_caller669// CHECK-SAME: %[[FLOAT:.*]]: f32670// CHECK-SAME: %[[DOUBLE:.*]]: f64671func.func @round_caller(%float: f32, %double: f64) -> (f32, f64) {672 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @roundf(%[[FLOAT]]) : (f32) -> f32673 %float_result = math.round %float : f32674 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @round(%[[DOUBLE]]) : (f64) -> f64675 %double_result = math.round %double : f64676 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]677 return %float_result, %double_result : f32, f64678}679 680// CHECK-LABEL: func @roundeven_caller681// CHECK-SAME: %[[FLOAT:.*]]: f32682// CHECK-SAME: %[[DOUBLE:.*]]: f64683func.func @roundeven_caller(%float: f32, %double: f64) -> (f32, f64) {684 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @roundevenf(%[[FLOAT]]) : (f32) -> f32685 %float_result = math.roundeven %float : f32686 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @roundeven(%[[DOUBLE]]) : (f64) -> f64687 %double_result = math.roundeven %double : f64688 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]689 return %float_result, %double_result : f32, f64690}691 692// CHECK-LABEL: func @trunc_caller693// CHECK-SAME: %[[FLOAT:.*]]: f32694// CHECK-SAME: %[[DOUBLE:.*]]: f64695func.func @trunc_caller(%float: f32, %double: f64) -> (f32, f64) {696 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @truncf(%[[FLOAT]]) : (f32) -> f32697 %float_result = math.trunc %float : f32698 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @trunc(%[[DOUBLE]]) : (f64) -> f64699 %double_result = math.trunc %double : f64700 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]701 return %float_result, %double_result : f32, f64702}703 704// CHECK-LABEL: func @cbrt_caller705// CHECK-SAME: %[[FLOAT:.*]]: f32706// CHECK-SAME: %[[DOUBLE:.*]]: f64707func.func @cbrt_caller(%float: f32, %double: f64, %half: f16, %bfloat: bf16,708 %float_vec: vector<2xf32>) -> (f32, f64, f16, bf16, vector<2xf32>) {709 // CHECK: %[[FLOAT_RESULT:.*]] = call @cbrtf(%[[FLOAT]]) : (f32) -> f32710 %float_result = math.cbrt %float : f32711 // CHECK: %[[DOUBLE_RESULT:.*]] = call @cbrt(%[[DOUBLE]]) : (f64) -> f64712 %double_result = math.cbrt %double : f64713 // Just check that these lower successfully:714 // CHECK: call @cbrtf715 %half_result = math.cbrt %half : f16716 // CHECK: call @cbrtf717 %bfloat_result = math.cbrt %bfloat : bf16718 // CHECK: call @cbrtf719 %vec_result = math.cbrt %float_vec : vector<2xf32>720 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]721 return %float_result, %double_result, %half_result, %bfloat_result, %vec_result722 : f32, f64, f16, bf16, vector<2xf32>723}724 725// CHECK-LABEL: func @cos_caller726// CHECK-SAME: %[[FLOAT:.*]]: f32727// CHECK-SAME: %[[DOUBLE:.*]]: f64728func.func @cos_caller(%float: f32, %double: f64) -> (f32, f64) {729 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @cosf(%[[FLOAT]]) : (f32) -> f32730 %float_result = math.cos %float : f32731 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @cos(%[[DOUBLE]]) : (f64) -> f64732 %double_result = math.cos %double : f64733 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]734 return %float_result, %double_result : f32, f64735}736 737// CHECK-LABEL: func @sin_caller738// CHECK-SAME: %[[FLOAT:.*]]: f32739// CHECK-SAME: %[[DOUBLE:.*]]: f64740func.func @sin_caller(%float: f32, %double: f64) -> (f32, f64) {741 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @sinf(%[[FLOAT]]) : (f32) -> f32742 %float_result = math.sin %float : f32743 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @sin(%[[DOUBLE]]) : (f64) -> f64744 %double_result = math.sin %double : f64745 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]746 return %float_result, %double_result : f32, f64747}748 749// CHECK-LABEL: func @round_vec_caller(750// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,751// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {752func.func @round_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {753 // CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>754 // CHECK: %[[OUT0_F32:.*]] = call @roundf(%[[IN0_F32]]) : (f32) -> f32755 // CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>756 // CHECK: %[[OUT1_F32:.*]] = call @roundf(%[[IN1_F32]]) : (f32) -> f32757 // CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>758 %float_result = math.round %float : vector<2xf32>759 // CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>760 // CHECK: %[[OUT0_F64:.*]] = call @round(%[[IN0_F64]]) : (f64) -> f64761 // CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>762 // CHECK: %[[OUT1_F64:.*]] = call @round(%[[IN1_F64]]) : (f64) -> f64763 // CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>764 %double_result = math.round %double : vector<2xf64>765 // CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>766 return %float_result, %double_result : vector<2xf32>, vector<2xf64>767}768 769// CHECK-LABEL: func @roundeven_vec_caller(770// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,771// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {772func.func @roundeven_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {773 // CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>774 // CHECK: %[[OUT0_F32:.*]] = call @roundevenf(%[[IN0_F32]]) : (f32) -> f32775 // CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>776 // CHECK: %[[OUT1_F32:.*]] = call @roundevenf(%[[IN1_F32]]) : (f32) -> f32777 // CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>778 %float_result = math.roundeven %float : vector<2xf32>779 // CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>780 // CHECK: %[[OUT0_F64:.*]] = call @roundeven(%[[IN0_F64]]) : (f64) -> f64781 // CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>782 // CHECK: %[[OUT1_F64:.*]] = call @roundeven(%[[IN1_F64]]) : (f64) -> f64783 // CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>784 %double_result = math.roundeven %double : vector<2xf64>785 // CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>786 return %float_result, %double_result : vector<2xf32>, vector<2xf64>787}788 789// CHECK-LABEL: func @trunc_vec_caller(790// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,791// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {792func.func @trunc_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {793 // CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>794 // CHECK: %[[OUT0_F32:.*]] = call @truncf(%[[IN0_F32]]) : (f32) -> f32795 // CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>796 // CHECK: %[[OUT1_F32:.*]] = call @truncf(%[[IN1_F32]]) : (f32) -> f32797 // CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>798 %float_result = math.trunc %float : vector<2xf32>799 // CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>800 // CHECK: %[[OUT0_F64:.*]] = call @trunc(%[[IN0_F64]]) : (f64) -> f64801 // CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>802 // CHECK: %[[OUT1_F64:.*]] = call @trunc(%[[IN1_F64]]) : (f64) -> f64803 // CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>804 %double_result = math.trunc %double : vector<2xf64>805 // CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>806 return %float_result, %double_result : vector<2xf32>, vector<2xf64>807}808 809// CHECK-LABEL: func @tan_caller810// CHECK-SAME: %[[FLOAT:.*]]: f32811// CHECK-SAME: %[[DOUBLE:.*]]: f64812// CHECK-SAME: %[[HALF:.*]]: f16813// CHECK-SAME: %[[BFLOAT:.*]]: bf16814func.func @tan_caller(%float: f32, %double: f64, %half: f16, %bfloat: bf16) -> (f32, f64, f16, bf16) {815 // CHECK: %[[FLOAT_RESULT:.*]] = call @tanf(%[[FLOAT]]) : (f32) -> f32816 %float_result = math.tan %float : f32817 // CHECK: %[[DOUBLE_RESULT:.*]] = call @tan(%[[DOUBLE]]) : (f64) -> f64818 %double_result = math.tan %double : f64819 // CHECK: %[[HALF_PROMOTED:.*]] = arith.extf %[[HALF]] : f16 to f32820 // CHECK: %[[HALF_CALL:.*]] = call @tanf(%[[HALF_PROMOTED]]) : (f32) -> f32821 // CHECK: %[[HALF_RESULT:.*]] = arith.truncf %[[HALF_CALL]] : f32 to f16822 %half_result = math.tan %half : f16823 // CHECK: %[[BFLOAT_PROMOTED:.*]] = arith.extf %[[BFLOAT]] : bf16 to f32824 // CHECK: %[[BFLOAT_CALL:.*]] = call @tanf(%[[BFLOAT_PROMOTED]]) : (f32) -> f32825 // CHECK: %[[BFLOAT_RESULT:.*]] = arith.truncf %[[BFLOAT_CALL]] : f32 to bf16826 %bfloat_result = math.tan %bfloat : bf16827 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]], %[[HALF_RESULT]], %[[BFLOAT_RESULT]]828 return %float_result, %double_result, %half_result, %bfloat_result : f32, f64, f16, bf16829}830 831// CHECK-LABEL: func @tan_vec_caller(832// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,833// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {834// CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>835// CHECK: %[[OUT0_F32:.*]] = call @tanf(%[[IN0_F32]]) : (f32) -> f32836// CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>837// CHECK: %[[OUT1_F32:.*]] = call @tanf(%[[IN1_F32]]) : (f32) -> f32838// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>839// CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>840// CHECK: %[[OUT0_F64:.*]] = call @tan(%[[IN0_F64]]) : (f64) -> f64841// CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>842// CHECK: %[[OUT1_F64:.*]] = call @tan(%[[IN1_F64]]) : (f64) -> f64843// CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>844// CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>845// CHECK: }846func.func @tan_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {847 %float_result = math.tan %float : vector<2xf32>848 %double_result = math.tan %double : vector<2xf64>849 return %float_result, %double_result : vector<2xf32>, vector<2xf64>850}851 852// CHECK-LABEL: func @log1p_caller853// CHECK-SAME: %[[FLOAT:.*]]: f32854// CHECK-SAME: %[[DOUBLE:.*]]: f64855func.func @log1p_caller(%float: f32, %double: f64) -> (f32, f64) {856 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @log1pf(%[[FLOAT]]) : (f32) -> f32857 %float_result = math.log1p %float : f32858 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @log1p(%[[DOUBLE]]) : (f64) -> f64859 %double_result = math.log1p %double : f64860 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]861 return %float_result, %double_result : f32, f64862}863 864// CHECK-LABEL: func @floor_caller865// CHECK-SAME: %[[FLOAT:.*]]: f32866// CHECK-SAME: %[[DOUBLE:.*]]: f64867func.func @floor_caller(%float: f32, %double: f64) -> (f32, f64) {868 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @floorf(%[[FLOAT]]) : (f32) -> f32869 %float_result = math.floor %float : f32870 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @floor(%[[DOUBLE]]) : (f64) -> f64871 %double_result = math.floor %double : f64872 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]873 return %float_result, %double_result : f32, f64874}875 876// CHECK-LABEL: func @ceil_caller877// CHECK-SAME: %[[FLOAT:.*]]: f32878// CHECK-SAME: %[[DOUBLE:.*]]: f64879func.func @ceil_caller(%float: f32, %double: f64) -> (f32, f64) {880 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @ceilf(%[[FLOAT]]) : (f32) -> f32881 %float_result = math.ceil %float : f32882 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @ceil(%[[DOUBLE]]) : (f64) -> f64883 %double_result = math.ceil %double : f64884 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]885 return %float_result, %double_result : f32, f64886}887 888// CHECK-LABEL: func @sqrt_caller889// CHECK-SAME: %[[FLOAT:.*]]: f32890// CHECK-SAME: %[[DOUBLE:.*]]: f64891func.func @sqrt_caller(%float: f32, %double: f64) -> (f32, f64) {892 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @sqrtf(%[[FLOAT]]) : (f32) -> f32893 %float_result = math.sqrt %float : f32894 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @sqrt(%[[DOUBLE]]) : (f64) -> f64895 %double_result = math.sqrt %double : f64896 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]897 return %float_result, %double_result : f32, f64898}899 900func.func @sqrt_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {901 %float_result = math.sqrt %float : vector<2xf32>902 %double_result = math.sqrt %double : vector<2xf64>903 return %float_result, %double_result : vector<2xf32>, vector<2xf64>904}905// CHECK-LABEL: func @sqrt_vec_caller(906// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,907// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {908// CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>909// CHECK: %[[OUT0_F32:.*]] = call @sqrtf(%[[IN0_F32]]) : (f32) -> f32910// CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>911// CHECK: %[[OUT1_F32:.*]] = call @sqrtf(%[[IN1_F32]]) : (f32) -> f32912// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>913// CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>914// CHECK: %[[OUT0_F64:.*]] = call @sqrt(%[[IN0_F64]]) : (f64) -> f64915// CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>916// CHECK: %[[OUT1_F64:.*]] = call @sqrt(%[[IN1_F64]]) : (f64) -> f64917// CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>918// CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>919// CHECK: }920 921// CHECK-LABEL: func @rsqrt_caller922// CHECK-SAME: %[[FLOAT:.*]]: f32923// CHECK-SAME: %[[DOUBLE:.*]]: f64924func.func @rsqrt_caller(%float: f32, %double: f64) -> (f32, f64) {925 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @rsqrtf(%[[FLOAT]]) : (f32) -> f32926 %float_result = math.rsqrt %float : f32927 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @rsqrt(%[[DOUBLE]]) : (f64) -> f64928 %double_result = math.rsqrt %double : f64929 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]930 return %float_result, %double_result : f32, f64931}932 933func.func @rsqrt_vec_caller(%float: vector<2xf32>, %double: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {934 %float_result = math.rsqrt %float : vector<2xf32>935 %double_result = math.rsqrt %double : vector<2xf64>936 return %float_result, %double_result : vector<2xf32>, vector<2xf64>937}938// CHECK-LABEL: func @rsqrt_vec_caller(939// CHECK-SAME: %[[VAL_0:.*]]: vector<2xf32>,940// CHECK-SAME: %[[VAL_1:.*]]: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {941// CHECK: %[[IN0_F32:.*]] = vector.extract %[[VAL_0]][0] : f32 from vector<2xf32>942// CHECK: %[[OUT0_F32:.*]] = call @rsqrtf(%[[IN0_F32]]) : (f32) -> f32943// CHECK: %[[IN1_F32:.*]] = vector.extract %[[VAL_0]][1] : f32 from vector<2xf32>944// CHECK: %[[OUT1_F32:.*]] = call @rsqrtf(%[[IN1_F32]]) : (f32) -> f32945// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>946// CHECK: %[[IN0_F64:.*]] = vector.extract %[[VAL_1]][0] : f64 from vector<2xf64>947// CHECK: %[[OUT0_F64:.*]] = call @rsqrt(%[[IN0_F64]]) : (f64) -> f64948// CHECK: %[[IN1_F64:.*]] = vector.extract %[[VAL_1]][1] : f64 from vector<2xf64>949// CHECK: %[[OUT1_F64:.*]] = call @rsqrt(%[[IN1_F64]]) : (f64) -> f64950// CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>951// CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>952// CHECK: }953 954// CHECK-LABEL: func @powf_caller(955// CHECK-SAME: %[[FLOATA:.*]]: f32, %[[FLOATB:.*]]: f32956// CHECK-SAME: %[[DOUBLEA:.*]]: f64, %[[DOUBLEB:.*]]: f64957func.func @powf_caller(%float_a: f32, %float_b: f32, %double_a: f64, %double_b: f64) -> (f32, f64) {958 // CHECK-DAG: %[[FLOAT_RESULT:.*]] = call @powf(%[[FLOATA]], %[[FLOATB]]) : (f32, f32) -> f32959 %float_result = math.powf %float_a, %float_b : f32960 // CHECK-DAG: %[[DOUBLE_RESULT:.*]] = call @pow(%[[DOUBLEA]], %[[DOUBLEB]]) : (f64, f64) -> f64961 %double_result = math.powf %double_a, %double_b : f64962 // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]963 return %float_result, %double_result : f32, f64964}965 966func.func @powf_vec_caller(%float_a: vector<2xf32>, %float_b: vector<2xf32>, %double_a: vector<2xf64>, %double_b: vector<2xf64>) -> (vector<2xf32>, vector<2xf64>) {967 %float_result = math.powf %float_a, %float_b : vector<2xf32>968 %double_result = math.powf %double_a, %double_b : vector<2xf64>969 return %float_result, %double_result : vector<2xf32>, vector<2xf64>970}971// CHECK-LABEL: func @powf_vec_caller(972// CHECK-SAME: %[[VAL_0A:.*]]: vector<2xf32>, %[[VAL_0B:.*]]: vector<2xf32>,973// CHECK-SAME: %[[VAL_1A:.*]]: vector<2xf64>, %[[VAL_1B:.*]]: vector<2xf64>974// CHECK-SAME: ) -> (vector<2xf32>, vector<2xf64>) {975// CHECK: %[[IN0_F32A:.*]] = vector.extract %[[VAL_0A]][0] : f32 from vector<2xf32>976// CHECK: %[[IN0_F32B:.*]] = vector.extract %[[VAL_0B]][0] : f32 from vector<2xf32>977// CHECK: %[[OUT0_F32:.*]] = call @powf(%[[IN0_F32A]], %[[IN0_F32B]]) : (f32, f32) -> f32978// CHECK: %[[IN1_F32A:.*]] = vector.extract %[[VAL_0A]][1] : f32 from vector<2xf32>979// CHECK: %[[IN1_F32B:.*]] = vector.extract %[[VAL_0B]][1] : f32 from vector<2xf32>980// CHECK: %[[OUT1_F32:.*]] = call @powf(%[[IN1_F32A]], %[[IN1_F32B]]) : (f32, f32) -> f32981// CHECK: %[[RES_F32:.*]] = vector.from_elements %[[OUT0_F32]], %[[OUT1_F32]] : vector<2xf32>982// CHECK: %[[IN0_F64A:.*]] = vector.extract %[[VAL_1A]][0] : f64 from vector<2xf64>983// CHECK: %[[IN0_F64B:.*]] = vector.extract %[[VAL_1B]][0] : f64 from vector<2xf64>984// CHECK: %[[OUT0_F64:.*]] = call @pow(%[[IN0_F64A]], %[[IN0_F64B]]) : (f64, f64) -> f64985// CHECK: %[[IN1_F64A:.*]] = vector.extract %[[VAL_1A]][1] : f64 from vector<2xf64>986// CHECK: %[[IN1_F64B:.*]] = vector.extract %[[VAL_1B]][1] : f64 from vector<2xf64>987// CHECK: %[[OUT1_F64:.*]] = call @pow(%[[IN1_F64A]], %[[IN1_F64B]]) : (f64, f64) -> f64988// CHECK: %[[RES_F64:.*]] = vector.from_elements %[[OUT0_F64]], %[[OUT1_F64]] : vector<2xf64>989// CHECK: return %[[RES_F32]], %[[RES_F64]] : vector<2xf32>, vector<2xf64>990// CHECK: }991