579 lines · plain
1; RUN: opt < %s -passes=instcombine -S -mtriple x86_64-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK,LINUX,ISC992; RUN: opt < %s -passes=instcombine -S -mtriple x86_64-pc-win32 | FileCheck %s --check-prefixes=CHECK,ISC993; RUN: opt < %s -passes=instcombine -S -mtriple x86_64-pc-windows-msvc16 | FileCheck %s --check-prefixes=CHECK,MS64,ISC894; RUN: opt < %s -passes=instcombine -S -mtriple i386-pc-windows-msvc | FileCheck %s --check-prefixes=CHECK,ISC995; RUN: opt < %s -passes=instcombine -S -mtriple i686-pc-windows-msvc17 | FileCheck %s --check-prefixes=CHECK,MS32,ISC896 7; Check for and against shrinkage when using the8; unsafe-fp-math function attribute on a math lib9; function. This optimization may be overridden by10; the -enable-double-float-shrink option.11; PR17850: http://llvm.org/bugs/show_bug.cgi?id=1785012 13define float @acos_test1(float %f) {14; CHECK-LABEL: @acos_test1(15; LINUX-NEXT: [[ACOSF:%.*]] = call fast float @acosf(float [[F:%.*]])16; LINUX-NEXT: ret float [[ACOSF]]17; MS32: [[ACOSF:%.*]] = call fast double @acos(double [[F:%.*]])18; MS64-NEXT: [[ACOSF:%.*]] = call fast float @acosf(float [[F:%.*]])19;20 %conv = fpext float %f to double21 %call = call fast double @acos(double %conv)22 %conv1 = fptrunc double %call to float23 ret float %conv124}25 26define double @acos_test2(float %f) {27; CHECK-LABEL: @acos_test2(28; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double29; CHECK-NEXT: [[CALL:%.*]] = call fast double @acos(double [[CONV]])30; CHECK-NEXT: ret double [[CALL]]31;32 %conv = fpext float %f to double33 %call = call fast double @acos(double %conv)34 ret double %call35}36 37define float @acosh_test1(float %f) {38; CHECK-LABEL: @acosh_test1(39; ISC99-NEXT: [[ACOSHF:%.*]] = call fast float @acoshf(float [[F:%.*]])40; ISC99-NEXT: ret float [[ACOSHF]]41; ISC89: [[ACOSHF:%.*]] = call fast double @acosh(double [[F:%.*]])42;43 %conv = fpext float %f to double44 %call = call fast double @acosh(double %conv)45 %conv1 = fptrunc double %call to float46 ret float %conv147}48 49define double @acosh_test2(float %f) {50; CHECK-LABEL: @acosh_test2(51; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double52; CHECK-NEXT: [[CALL:%.*]] = call fast double @acosh(double [[CONV]])53; CHECK-NEXT: ret double [[CALL]]54;55 %conv = fpext float %f to double56 %call = call fast double @acosh(double %conv)57 ret double %call58}59 60define float @asin_test1(float %f) {61; CHECK-LABEL: @asin_test1(62; LINUX-NEXT: [[ASINF:%.*]] = call fast float @asinf(float [[F:%.*]])63; LINUX-NEXT: ret float [[ASINF]]64; MS32: [[ASINF:%.*]] = call fast double @asin(double [[F:%.*]])65; MS64-NEXT: [[ASINF:%.*]] = call fast float @asinf(float [[F:%.*]])66;67 %conv = fpext float %f to double68 %call = call fast double @asin(double %conv)69 %conv1 = fptrunc double %call to float70 ret float %conv171}72 73define double @asin_test2(float %f) {74; CHECK-LABEL: @asin_test2(75; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double76; CHECK-NEXT: [[CALL:%.*]] = call fast double @asin(double [[CONV]])77; CHECK-NEXT: ret double [[CALL]]78;79 %conv = fpext float %f to double80 %call = call fast double @asin(double %conv)81 ret double %call82}83 84define float @asinh_test1(float %f) {85; CHECK-LABEL: @asinh_test1(86; ISC99-NEXT: [[ASINHF:%.*]] = call fast float @asinhf(float [[F:%.*]])87; ISC99-NEXT: ret float [[ASINHF]]88; ISC89: [[ASINHF:%.*]] = call fast double @asinh(double [[F:%.*]])89;90 %conv = fpext float %f to double91 %call = call fast double @asinh(double %conv)92 %conv1 = fptrunc double %call to float93 ret float %conv194}95 96define double @asinh_test2(float %f) {97; CHECK-LABEL: @asinh_test2(98; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double99; CHECK-NEXT: [[CALL:%.*]] = call fast double @asinh(double [[CONV]])100; CHECK-NEXT: ret double [[CALL]]101;102 %conv = fpext float %f to double103 %call = call fast double @asinh(double %conv)104 ret double %call105}106 107define float @atan_test1(float %f) {108; CHECK-LABEL: @atan_test1(109; LINUX-NEXT: [[ATANF:%.*]] = call fast float @atanf(float [[F:%.*]])110; LINUX-NEXT: ret float [[ATANF]]111; MS32: [[ATANF:%.*]] = call fast double @atan(double [[F:%.*]])112; MS64-NEXT: [[ATANF:%.*]] = call fast float @atanf(float [[F:%.*]])113;114 %conv = fpext float %f to double115 %call = call fast double @atan(double %conv)116 %conv1 = fptrunc double %call to float117 ret float %conv1118}119 120define double @atan_test2(float %f) {121; CHECK-LABEL: @atan_test2(122; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double123; CHECK-NEXT: [[CALL:%.*]] = call fast double @atan(double [[CONV]])124; CHECK-NEXT: ret double [[CALL]]125;126 %conv = fpext float %f to double127 %call = call fast double @atan(double %conv)128 ret double %call129}130 131define float @atanh_test1(float %f) {132; CHECK-LABEL: @atanh_test1(133; ISC99-NEXT: [[ATANHF:%.*]] = call fast float @atanhf(float [[F:%.*]])134; ISC99-NEXT: ret float [[ATANHF]]135; ISC89: [[ATANHF:%.*]] = call fast double @atanh(double [[F:%.*]])136;137 %conv = fpext float %f to double138 %call = call fast double @atanh(double %conv)139 %conv1 = fptrunc double %call to float140 ret float %conv1141}142 143define double @atanh_test2(float %f) {144; CHECK-LABEL: @atanh_test2(145; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double146; CHECK-NEXT: [[CALL:%.*]] = call fast double @atanh(double [[CONV]])147; CHECK-NEXT: ret double [[CALL]]148;149 %conv = fpext float %f to double150 %call = call fast double @atanh(double %conv)151 ret double %call152}153 154define float @cbrt_test1(float %f) {155; CHECK-LABEL: @cbrt_test1(156; ISC99-NEXT: [[CBRTF:%.*]] = call fast float @cbrtf(float [[F:%.*]])157; ISC99-NEXT: ret float [[CBRTF]]158; ISC89: [[CBRTF:%.*]] = call fast double @cbrt(double [[F:%.*]])159;160 %conv = fpext float %f to double161 %call = call fast double @cbrt(double %conv)162 %conv1 = fptrunc double %call to float163 ret float %conv1164}165 166define double @cbrt_test2(float %f) {167; CHECK-LABEL: @cbrt_test2(168; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double169; CHECK-NEXT: [[CALL:%.*]] = call fast double @cbrt(double [[CONV]])170; CHECK-NEXT: ret double [[CALL]]171;172 %conv = fpext float %f to double173 %call = call fast double @cbrt(double %conv)174 ret double %call175}176 177define float @exp_test1(float %f) {178; CHECK-LABEL: @exp_test1(179; LINUX-NEXT: [[EXPF:%.*]] = call fast float @expf(float [[F:%.*]])180; LINUX-NEXT: ret float [[EXPF]]181; MS32: [[EXPF:%.*]] = call fast double @exp(double [[F:%.*]])182; MS64-NEXT: [[EXPF:%.*]] = call fast float @expf(float [[F:%.*]])183;184 %conv = fpext float %f to double185 %call = call fast double @exp(double %conv)186 %conv1 = fptrunc double %call to float187 ret float %conv1188}189 190define double @exp_test2(float %f) {191; CHECK-LABEL: @exp_test2(192; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double193; CHECK-NEXT: [[CALL:%.*]] = call fast double @exp(double [[CONV]])194; CHECK-NEXT: ret double [[CALL]]195;196 %conv = fpext float %f to double197 %call = call fast double @exp(double %conv)198 ret double %call199}200 201define float @expm1_test1(float %f) {202; CHECK-LABEL: @expm1_test1(203; ISC99-NEXT: [[EXPM1F:%.*]] = call fast float @expm1f(float [[F:%.*]])204; ISC99-NEXT: ret float [[EXPM1F]]205; ISC89: [[EXPM1F:%.*]] = call fast double @expm1(double [[F:%.*]])206;207 %conv = fpext float %f to double208 %call = call fast double @expm1(double %conv)209 %conv1 = fptrunc double %call to float210 ret float %conv1211}212 213define double @expm1_test2(float %f) {214; CHECK-LABEL: @expm1_test2(215; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double216; CHECK-NEXT: [[CALL:%.*]] = call fast double @expm1(double [[CONV]])217; CHECK-NEXT: ret double [[CALL]]218;219 %conv = fpext float %f to double220 %call = call fast double @expm1(double %conv)221 ret double %call222}223 224; exp10f() doesn't exist for this triple, so it doesn't shrink.225 226define float @exp10_test1(float %f) {227; CHECK-LABEL: @exp10_test1(228; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double229; CHECK-NEXT: [[CALL:%.*]] = call fast double @exp10(double [[CONV]])230; CHECK-NEXT: [[CONV1:%.*]] = fptrunc double [[CALL]] to float231; CHECK-NEXT: ret float [[CONV1]]232;233 %conv = fpext float %f to double234 %call = call fast double @exp10(double %conv)235 %conv1 = fptrunc double %call to float236 ret float %conv1237}238 239define double @exp10_test2(float %f) {240; CHECK-LABEL: @exp10_test2(241; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double242; CHECK-NEXT: [[CALL:%.*]] = call fast double @exp10(double [[CONV]])243; CHECK-NEXT: ret double [[CALL]]244;245 %conv = fpext float %f to double246 %call = call fast double @exp10(double %conv)247 ret double %call248}249 250define float @log_test1(float %f) {251; CHECK-LABEL: @log_test1(252; LINUX-NEXT: [[LOGF:%.*]] = call fast float @llvm.log.f32(float [[F:%.*]])253; LINUX-NEXT: ret float [[LOGF]]254; MS32: [[LOGF:%.*]] = call fast double @llvm.log.f64(double [[F:%.*]])255; MS64-NEXT: [[LOGF:%.*]] = call fast float @llvm.log.f32(float [[F:%.*]])256;257 %conv = fpext float %f to double258 %call = call fast double @log(double %conv)259 %conv1 = fptrunc double %call to float260 ret float %conv1261}262 263define double @log_test2(float %f) {264; CHECK-LABEL: @log_test2(265; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double266; CHECK-NEXT: [[CALL:%.*]] = call fast double @llvm.log.f64(double [[CONV]])267; CHECK-NEXT: ret double [[CALL]]268;269 %conv = fpext float %f to double270 %call = call fast double @log(double %conv)271 ret double %call272}273 274define float @log10_test1(float %f) {275; CHECK-LABEL: @log10_test1(276; LINUX-NEXT: [[LOG10F:%.*]] = call fast float @llvm.log10.f32(float [[F:%.*]])277; LINUX-NEXT: ret float [[LOG10F]]278; MS32: [[LOG10F:%.*]] = call fast double @llvm.log10.f64(double [[F:%.*]])279; MS64-NEXT: [[LOG10F:%.*]] = call fast float @llvm.log10.f32(float [[F:%.*]])280;281 %conv = fpext float %f to double282 %call = call fast double @log10(double %conv)283 %conv1 = fptrunc double %call to float284 ret float %conv1285}286 287define double @log10_test2(float %f) {288; CHECK-LABEL: @log10_test2(289; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double290; CHECK-NEXT: [[CALL:%.*]] = call fast double @llvm.log10.f64(double [[CONV]])291; CHECK-NEXT: ret double [[CALL]]292;293 %conv = fpext float %f to double294 %call = call fast double @log10(double %conv)295 ret double %call296}297 298define float @log1p_test1(float %f) {299; CHECK-LABEL: @log1p_test1(300; ISC99-NEXT: [[LOG1PF:%.*]] = call fast float @log1pf(float [[F:%.*]])301; ISC99-NEXT: ret float [[LOG1PF]]302; ISC89: [[LOG1PF:%.*]] = call fast double @log1p(double [[F:%.*]])303;304 %conv = fpext float %f to double305 %call = call fast double @log1p(double %conv)306 %conv1 = fptrunc double %call to float307 ret float %conv1308}309 310define double @log1p_test2(float %f) {311; CHECK-LABEL: @log1p_test2(312; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double313; CHECK-NEXT: [[CALL:%.*]] = call fast double @log1p(double [[CONV]])314; CHECK-NEXT: ret double [[CALL]]315;316 %conv = fpext float %f to double317 %call = call fast double @log1p(double %conv)318 ret double %call319}320 321define float @log2_test1(float %f) {322; CHECK-LABEL: @log2_test1(323; ISC99-NEXT: [[LOG2F:%.*]] = call fast float @llvm.log2.f32(float [[F:%.*]])324; ISC99-NEXT: ret float [[LOG2F]]325; ISC89: [[LOG2F:%.*]] = call fast double @log2(double [[F:%.*]])326;327 %conv = fpext float %f to double328 %call = call fast double @log2(double %conv)329 %conv1 = fptrunc double %call to float330 ret float %conv1331}332 333define double @log2_test2(float %f) {334; CHECK-LABEL: @log2_test2(335; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double336; ISC99-NEXT: [[CALL:%.*]] = call fast double @llvm.log2.f64(double [[CONV]])337; ISC89-NEXT: [[LOG2F:%.*]] = call fast double @log2(double [[F:%.*]])338; CHECK-NEXT: ret double [[CALL]]339;340 %conv = fpext float %f to double341 %call = call fast double @log2(double %conv)342 ret double %call343}344 345define float @logb_test1(float %f) {346; CHECK-LABEL: @logb_test1(347; LINUX-NEXT: [[LOGBF:%.*]] = call fast float @logbf(float [[F:%.*]])348; LINUX-NEXT: ret float [[LOGBF]]349; MS32: [[POWF:%.*]] = call fast double @logb(double [[F:%.*]])350; MS64-NEXT: [[LOGBF:%.*]] = call fast float @_logbf(float [[F:%.*]])351;352 %conv = fpext float %f to double353 %call = call fast double @logb(double %conv)354 %conv1 = fptrunc double %call to float355 ret float %conv1356}357 358define double @logb_test2(float %f) {359; CHECK-LABEL: @logb_test2(360; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double361; CHECK-NEXT: [[CALL:%.*]] = call fast double @logb(double [[CONV]])362; CHECK-NEXT: ret double [[CALL]]363;364 %conv = fpext float %f to double365 %call = call fast double @logb(double %conv)366 ret double %call367}368 369define float @pow_test1(float %f, float %g) {370; CHECK-LABEL: @pow_test1(371; LINUX-NEXT: [[POWF:%.*]] = call fast float @powf(float %f, float %g)372; LINUX-NEXT: ret float [[POWF]]373; MS32: [[POWF:%.*]] = call fast double @pow(double %df, double %dg)374; MS64-NEXT: [[POWF:%.*]] = call fast float @powf(float %f, float %g)375;376 %df = fpext float %f to double377 %dg = fpext float %g to double378 %call = call fast double @pow(double %df, double %dg)379 %fr = fptrunc double %call to float380 ret float %fr381}382 383define double @pow_test2(float %f, float %g) {384; CHECK-LABEL: @pow_test2(385; CHECK: [[POW:%.*]] = call fast double @pow(double %df, double %dg)386; CHECK-NEXT: ret double [[POW]]387;388 %df = fpext float %f to double389 %dg = fpext float %g to double390 %call = call fast double @pow(double %df, double %dg)391 ret double %call392}393 394define float @sin_test1(float %f) {395; CHECK-LABEL: @sin_test1(396; LINUX-NEXT: [[SINF:%.*]] = call fast float @sinf(float [[F:%.*]])397; LINUX-NEXT: ret float [[SINF]]398; MS32: [[SINF:%.*]] = call fast double @sin(double [[F:%.*]])399; MS64-NEXT: [[SINF:%.*]] = call fast float @sinf(float [[F:%.*]])400;401 %conv = fpext float %f to double402 %call = call fast double @sin(double %conv)403 %conv1 = fptrunc double %call to float404 ret float %conv1405}406 407define double @sin_test2(float %f) {408; CHECK-LABEL: @sin_test2(409; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double410; CHECK-NEXT: [[CALL:%.*]] = call fast double @sin(double [[CONV]])411; CHECK-NEXT: ret double [[CALL]]412;413 %conv = fpext float %f to double414 %call = call fast double @sin(double %conv)415 ret double %call416}417 418define float @sqrt_test1(float %f) {419; CHECK-LABEL: @sqrt_test1(420; LINUX-NEXT: [[SQRTF:%.*]] = call float @sqrtf(float [[F:%.*]])421; LINUX-NEXT: ret float [[SQRTF]]422; MS32: [[SQRTF:%.*]] = call double @sqrt(double [[F:%.*]])423; MS64-NEXT: [[SQRTF:%.*]] = call float @sqrtf(float [[F:%.*]])424;425 %conv = fpext float %f to double426 %call = call double @sqrt(double %conv)427 %conv1 = fptrunc double %call to float428 ret float %conv1429}430 431define double @sqrt_test2(float %f) {432; CHECK-LABEL: @sqrt_test2(433; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double434; CHECK-NEXT: [[CALL:%.*]] = call double @sqrt(double [[CONV]])435; CHECK-NEXT: ret double [[CALL]]436;437 %conv = fpext float %f to double438 %call = call double @sqrt(double %conv)439 ret double %call440}441 442define float @sqrt_int_test1(float %f) {443; CHECK-LABEL: @sqrt_int_test1(444; LINUX-NEXT: [[TMP1:%.*]] = call float @llvm.sqrt.f32(float [[F:%.*]])445; LINUX-NEXT: ret float [[TMP1]]446; MS32: [[TMP1:%.*]] = call double @llvm.sqrt.f64(double [[F:%.*]])447; MS64-NEXT: [[TMP1:%.*]] = call float @llvm.sqrt.f32(float [[F:%.*]])448;449 %conv = fpext float %f to double450 %call = call double @llvm.sqrt.f64(double %conv)451 %conv1 = fptrunc double %call to float452 ret float %conv1453}454 455define double @sqrt_int_test2(float %f) {456; CHECK-LABEL: @sqrt_int_test2(457; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double458; CHECK-NEXT: [[CALL:%.*]] = call double @llvm.sqrt.f64(double [[CONV]])459; CHECK-NEXT: ret double [[CALL]]460;461 %conv = fpext float %f to double462 %call = call double @llvm.sqrt.f64(double %conv)463 ret double %call464}465 466define float @tan_test1(float %f) {467; CHECK-LABEL: @tan_test1(468; LINUX-NEXT: [[TANF:%.*]] = call fast float @tanf(float [[F:%.*]])469; LINUX-NEXT: ret float [[TANF]]470; MS32: [[TANF:%.*]] = call fast double @tan(double [[F:%.*]])471; MS64-NEXT: [[TANF:%.*]] = call fast float @tanf(float [[F:%.*]])472;473 %conv = fpext float %f to double474 %call = call fast double @tan(double %conv)475 %conv1 = fptrunc double %call to float476 ret float %conv1477}478 479define double @tan_test2(float %f) {480; CHECK-LABEL: @tan_test2(481; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double482; CHECK-NEXT: [[CALL:%.*]] = call fast double @tan(double [[CONV]])483; CHECK-NEXT: ret double [[CALL]]484;485 %conv = fpext float %f to double486 %call = call fast double @tan(double %conv)487 ret double %call488}489define float @tanh_test1(float %f) {490; CHECK-LABEL: @tanh_test1(491; LINUX-NEXT: [[TANHF:%.*]] = call fast float @tanhf(float [[F:%.*]])492; LINUX-NEXT: ret float [[TANHF]]493; MS32: [[TANHF:%.*]] = call fast double @tanh(double [[F:%.*]])494; MS64-NEXT: [[TANHF:%.*]] = call fast float @tanhf(float [[F:%.*]])495;496 %conv = fpext float %f to double497 %call = call fast double @tanh(double %conv)498 %conv1 = fptrunc double %call to float499 ret float %conv1500}501 502define double @tanh_test2(float %f) {503; CHECK-LABEL: @tanh_test2(504; CHECK-NEXT: [[CONV:%.*]] = fpext float [[F:%.*]] to double505; CHECK-NEXT: [[CALL:%.*]] = call fast double @tanh(double [[CONV]])506; CHECK-NEXT: ret double [[CALL]]507;508 %conv = fpext float %f to double509 %call = call fast double @tanh(double %conv)510 ret double %call511}512 513; 'arcp' on an fmax() is meaningless. This test just proves that514; flags are propagated for shrunken *binary* double FP calls.515define float @max1(float %a, float %b) {516; CHECK-LABEL: @max1(517; ISC99-NEXT: [[FMAXF:%.*]] = call nsz arcp float @llvm.maxnum.f32(float [[A:%.*]], float [[B:%.*]])518; ISC99-NEXT: ret float [[FMAXF]]519; ISC89: [[FMAXF:%.*]] = call arcp double @fmax(double [[A:%.*]], double [[B:%.*]])520;521 %c = fpext float %a to double522 %d = fpext float %b to double523 %e = call arcp double @fmax(double %c, double %d)524 %f = fptrunc double %e to float525 ret float %f526}527 528; This is treated as libm 'fmin' - LLVM types do not necessarily529; correspond to 'C' types, so this is not required to be "fminl".530 531define float @fake_fmin(float %a, float %b) {532; CHECK-LABEL: @fake_fmin(533; ISC99-NEXT: [[MIN:%.*]] = call nsz float @llvm.minnum.f32(float %a, float %b)534; ISC99-NEXT: ret float [[MIN]]535 536; ISC89-NEXT: [[C:%.*]] = fpext float [[A:%.*]] to fp128537; ISC89-NEXT: [[D:%.*]] = fpext float [[B:%.*]] to fp128538; ISC89-NEXT: [[E:%.*]] = call fp128 @fmin(fp128 [[C]], fp128 [[D]])539; ISC89-NEXT: [[F:%.*]] = fptrunc fp128 [[E]] to float540; ISC89-NEXT: ret float [[F]]541;542 %c = fpext float %a to fp128543 %d = fpext float %b to fp128544 %e = call fp128 @fmin(fp128 %c, fp128 %d)545 %f = fptrunc fp128 %e to float546 ret float %f547}548 549declare fp128 @fmin(fp128, fp128)550 551declare double @fmax(double, double)552 553declare double @tanh(double)554declare double @tan(double)555 556; sqrt is a special case: the shrinking optimization557; is valid even without unsafe-fp-math.558declare double @sqrt(double)559declare double @llvm.sqrt.f64(double)560 561declare double @sin(double)562declare double @pow(double, double)563declare double @log2(double)564declare double @log1p(double)565declare double @log10(double)566declare double @log(double)567declare double @logb(double)568declare double @exp10(double)569declare double @expm1(double)570declare double @exp(double)571declare double @cbrt(double)572declare double @atanh(double)573declare double @atan(double)574declare double @acos(double)575declare double @acosh(double)576declare double @asin(double)577declare double @asinh(double)578 579