941 lines · plain
1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py2; RUN: opt < %s -passes=instcombine -S | FileCheck %s3 4; testing-case "float fold(float a) { return 1.2f * a * 2.3f; }"5; 1.2f and 2.3f is supposed to be fold.6define float @fold(float %a) {7; CHECK-LABEL: @fold(8; CHECK-NEXT: [[MUL1:%.*]] = fmul fast float [[A:%.*]], 0x4006147AE00000009; CHECK-NEXT: ret float [[MUL1]]10;11 %mul = fmul fast float %a, 0x3FF333334000000012 %mul1 = fmul fast float %mul, 0x400266666000000013 ret float %mul114}15 16; Same testing-case as the one used in fold() except that the operators have17; fixed FP mode.18define float @notfold(float %a) {19; CHECK-LABEL: @notfold(20; CHECK-NEXT: [[MUL:%.*]] = fmul fast float [[A:%.*]], 0x3FF333334000000021; CHECK-NEXT: [[MUL1:%.*]] = fmul float [[MUL]], 0x400266666000000022; CHECK-NEXT: ret float [[MUL1]]23;24 %mul = fmul fast float %a, 0x3FF333334000000025 %mul1 = fmul float %mul, 0x400266666000000026 ret float %mul127}28 29define float @fold2(float %a) {30; CHECK-LABEL: @fold2(31; CHECK-NEXT: [[MUL1:%.*]] = fmul fast float [[A:%.*]], 0x4006147AE000000032; CHECK-NEXT: ret float [[MUL1]]33;34 %mul = fmul float %a, 0x3FF333334000000035 %mul1 = fmul fast float %mul, 0x400266666000000036 ret float %mul137}38 39; C * f1 + f1 = (C+1) * f140; TODO: The particular case where C is 2 (so the folded result is 3.0*f1) is41; always safe, and so doesn't need any FMF.42; That is, (x + x + x) and (3*x) each have only a single rounding.43define double @fold3(double %f1) {44; CHECK-LABEL: @fold3(45; CHECK-NEXT: [[T2:%.*]] = fmul fast double [[F1:%.*]], 6.000000e+0046; CHECK-NEXT: ret double [[T2]]47;48 %t1 = fmul fast double 5.000000e+00, %f149 %t2 = fadd fast double %f1, %t150 ret double %t251}52 53; Check again with 'reassoc' and 'nsz' ('nsz' not technically required).54define double @fold3_reassoc_nsz(double %f1) {55; CHECK-LABEL: @fold3_reassoc_nsz(56; CHECK-NEXT: [[T2:%.*]] = fmul reassoc nsz double [[F1:%.*]], 6.000000e+0057; CHECK-NEXT: ret double [[T2]]58;59 %t1 = fmul reassoc nsz double 5.000000e+00, %f160 %t2 = fadd reassoc nsz double %f1, %t161 ret double %t262}63 64; TODO: This doesn't require 'nsz'. It should fold to f1 * 6.0.65define double @fold3_reassoc(double %f1) {66; CHECK-LABEL: @fold3_reassoc(67; CHECK-NEXT: [[T1:%.*]] = fmul reassoc double [[F1:%.*]], 5.000000e+0068; CHECK-NEXT: [[T2:%.*]] = fadd reassoc double [[F1]], [[T1]]69; CHECK-NEXT: ret double [[T2]]70;71 %t1 = fmul reassoc double 5.000000e+00, %f172 %t2 = fadd reassoc double %f1, %t173 ret double %t274}75 76; (C1 - X) + (C2 - Y) => (C1+C2) - (X + Y)77define float @fold4(float %f1, float %f2) {78; CHECK-LABEL: @fold4(79; CHECK-NEXT: [[TMP1:%.*]] = fadd fast float [[F1:%.*]], [[F2:%.*]]80; CHECK-NEXT: [[ADD:%.*]] = fsub fast float 9.000000e+00, [[TMP1]]81; CHECK-NEXT: ret float [[ADD]]82;83 %sub = fsub float 4.000000e+00, %f184 %sub1 = fsub float 5.000000e+00, %f285 %add = fadd fast float %sub, %sub186 ret float %add87}88 89; Check again with 'reassoc' and 'nsz' ('nsz' not technically required).90define float @fold4_reassoc_nsz(float %f1, float %f2) {91; CHECK-LABEL: @fold4_reassoc_nsz(92; CHECK-NEXT: [[TMP1:%.*]] = fadd reassoc nsz float [[F1:%.*]], [[F2:%.*]]93; CHECK-NEXT: [[ADD:%.*]] = fsub reassoc nsz float 9.000000e+00, [[TMP1]]94; CHECK-NEXT: ret float [[ADD]]95;96 %sub = fsub float 4.000000e+00, %f197 %sub1 = fsub float 5.000000e+00, %f298 %add = fadd reassoc nsz float %sub, %sub199 ret float %add100}101 102; TODO: This doesn't require 'nsz'. It should fold to (9.0 - (f1 + f2)).103define float @fold4_reassoc(float %f1, float %f2) {104; CHECK-LABEL: @fold4_reassoc(105; CHECK-NEXT: [[SUB:%.*]] = fsub float 4.000000e+00, [[F1:%.*]]106; CHECK-NEXT: [[SUB1:%.*]] = fsub float 5.000000e+00, [[F2:%.*]]107; CHECK-NEXT: [[ADD:%.*]] = fadd reassoc float [[SUB]], [[SUB1]]108; CHECK-NEXT: ret float [[ADD]]109;110 %sub = fsub float 4.000000e+00, %f1111 %sub1 = fsub float 5.000000e+00, %f2112 %add = fadd reassoc float %sub, %sub1113 ret float %add114}115 116; (X + C1) + C2 => X + (C1 + C2)117define float @fold5(float %f1) {118; CHECK-LABEL: @fold5(119; CHECK-NEXT: [[ADD1:%.*]] = fadd fast float [[F1:%.*]], 9.000000e+00120; CHECK-NEXT: ret float [[ADD1]]121;122 %add = fadd float %f1, 4.000000e+00123 %add1 = fadd fast float %add, 5.000000e+00124 ret float %add1125}126 127; Check again with 'reassoc' and 'nsz' ('nsz' not technically required).128define float @fold5_reassoc_nsz(float %f1) {129; CHECK-LABEL: @fold5_reassoc_nsz(130; CHECK-NEXT: [[ADD1:%.*]] = fadd reassoc nsz float [[F1:%.*]], 9.000000e+00131; CHECK-NEXT: ret float [[ADD1]]132;133 %add = fadd float %f1, 4.000000e+00134 %add1 = fadd reassoc nsz float %add, 5.000000e+00135 ret float %add1136}137 138; TODO: This doesn't require 'nsz'. It should fold to f1 + 9.0139define float @fold5_reassoc(float %f1) {140; CHECK-LABEL: @fold5_reassoc(141; CHECK-NEXT: [[ADD:%.*]] = fadd float [[F1:%.*]], 4.000000e+00142; CHECK-NEXT: [[ADD1:%.*]] = fadd reassoc float [[ADD]], 5.000000e+00143; CHECK-NEXT: ret float [[ADD1]]144;145 %add = fadd float %f1, 4.000000e+00146 %add1 = fadd reassoc float %add, 5.000000e+00147 ret float %add1148}149 150; (X + X) + X + X => 4.0 * X151define float @fold6(float %f1) {152; CHECK-LABEL: @fold6(153; CHECK-NEXT: [[T3:%.*]] = fmul fast float [[F1:%.*]], 4.000000e+00154; CHECK-NEXT: ret float [[T3]]155;156 %t1 = fadd fast float %f1, %f1157 %t2 = fadd fast float %f1, %t1158 %t3 = fadd fast float %t2, %f1159 ret float %t3160}161 162; Check again with 'reassoc' and 'nsz' ('nsz' not technically required).163define float @fold6_reassoc_nsz(float %f1) {164; CHECK-LABEL: @fold6_reassoc_nsz(165; CHECK-NEXT: [[T3:%.*]] = fmul reassoc nsz float [[F1:%.*]], 4.000000e+00166; CHECK-NEXT: ret float [[T3]]167;168 %t1 = fadd reassoc nsz float %f1, %f1169 %t2 = fadd reassoc nsz float %f1, %t1170 %t3 = fadd reassoc nsz float %t2, %f1171 ret float %t3172}173 174; TODO: This doesn't require 'nsz'. It should fold to f1 * 4.0.175define float @fold6_reassoc(float %f1) {176; CHECK-LABEL: @fold6_reassoc(177; CHECK-NEXT: [[T1:%.*]] = fadd reassoc float [[F1:%.*]], [[F1]]178; CHECK-NEXT: [[T2:%.*]] = fadd reassoc float [[F1]], [[T1]]179; CHECK-NEXT: [[T3:%.*]] = fadd reassoc float [[T2]], [[F1]]180; CHECK-NEXT: ret float [[T3]]181;182 %t1 = fadd reassoc float %f1, %f1183 %t2 = fadd reassoc float %f1, %t1184 %t3 = fadd reassoc float %t2, %f1185 ret float %t3186}187 188; C1 * X + (X + X) = (C1 + 2) * X189define float @fold7(float %f1) {190; CHECK-LABEL: @fold7(191; CHECK-NEXT: [[T3:%.*]] = fmul fast float [[F1:%.*]], 7.000000e+00192; CHECK-NEXT: ret float [[T3]]193;194 %t1 = fmul fast float %f1, 5.000000e+00195 %t2 = fadd fast float %f1, %f1196 %t3 = fadd fast float %t1, %t2197 ret float %t3198}199 200; Check again with 'reassoc' and 'nsz' ('nsz' not technically required).201define float @fold7_reassoc_nsz(float %f1) {202; CHECK-LABEL: @fold7_reassoc_nsz(203; CHECK-NEXT: [[T3:%.*]] = fmul reassoc nsz float [[F1:%.*]], 7.000000e+00204; CHECK-NEXT: ret float [[T3]]205;206 %t1 = fmul reassoc nsz float %f1, 5.000000e+00207 %t2 = fadd reassoc nsz float %f1, %f1208 %t3 = fadd reassoc nsz float %t1, %t2209 ret float %t3210}211 212; TODO: This doesn't require 'nsz'. It should fold to f1 * 7.0.213define float @fold7_reassoc(float %f1) {214; CHECK-LABEL: @fold7_reassoc(215; CHECK-NEXT: [[T1:%.*]] = fmul reassoc float [[F1:%.*]], 5.000000e+00216; CHECK-NEXT: [[T2:%.*]] = fadd reassoc float [[F1]], [[F1]]217; CHECK-NEXT: [[T3:%.*]] = fadd reassoc float [[T1]], [[T2]]218; CHECK-NEXT: ret float [[T3]]219;220 %t1 = fmul reassoc float %f1, 5.000000e+00221 %t2 = fadd reassoc float %f1, %f1222 %t3 = fadd reassoc float %t1, %t2223 ret float %t3224}225 226; (X + X) + (X + X) + X => 5.0 * X227define float @fold8(float %f1) {228; CHECK-LABEL: @fold8(229; CHECK-NEXT: [[T4:%.*]] = fmul fast float [[F1:%.*]], 5.000000e+00230; CHECK-NEXT: ret float [[T4]]231;232 %t1 = fadd fast float %f1, %f1233 %t2 = fadd fast float %f1, %f1234 %t3 = fadd fast float %t1, %t2235 %t4 = fadd fast float %t3, %f1236 ret float %t4237}238 239; Check again with 'reassoc' and 'nsz' ('nsz' not technically required).240define float @fold8_reassoc_nsz(float %f1) {241; CHECK-LABEL: @fold8_reassoc_nsz(242; CHECK-NEXT: [[T4:%.*]] = fmul reassoc nsz float [[F1:%.*]], 5.000000e+00243; CHECK-NEXT: ret float [[T4]]244;245 %t1 = fadd reassoc nsz float %f1, %f1246 %t2 = fadd reassoc nsz float %f1, %f1247 %t3 = fadd reassoc nsz float %t1, %t2248 %t4 = fadd reassoc nsz float %t3, %f1249 ret float %t4250}251 252; TODO: This doesn't require 'nsz'. It should fold to f1 * 5.0.253define float @fold8_reassoc(float %f1) {254; CHECK-LABEL: @fold8_reassoc(255; CHECK-NEXT: [[T1:%.*]] = fadd reassoc float [[F1:%.*]], [[F1]]256; CHECK-NEXT: [[T2:%.*]] = fadd reassoc float [[F1]], [[F1]]257; CHECK-NEXT: [[T3:%.*]] = fadd reassoc float [[T1]], [[T2]]258; CHECK-NEXT: [[T4:%.*]] = fadd reassoc float [[T3]], [[F1]]259; CHECK-NEXT: ret float [[T4]]260;261 %t1 = fadd reassoc float %f1, %f1262 %t2 = fadd reassoc float %f1, %f1263 %t3 = fadd reassoc float %t1, %t2264 %t4 = fadd reassoc float %t3, %f1265 ret float %t4266}267 268; Y - (X + Y) --> -X269 270define float @fsub_fadd_common_op_fneg(float %x, float %y) {271; CHECK-LABEL: @fsub_fadd_common_op_fneg(272; CHECK-NEXT: [[R:%.*]] = fneg fast float [[X:%.*]]273; CHECK-NEXT: ret float [[R]]274;275 %a = fadd float %x, %y276 %r = fsub fast float %y, %a277 ret float %r278}279 280; Y - (X + Y) --> -X281; Check again with 'reassoc' and 'nsz'.282; nsz is required because: 0.0 - (0.0 + 0.0) -> 0.0, not -0.0283 284define float @fsub_fadd_common_op_fneg_reassoc_nsz(float %x, float %y) {285; CHECK-LABEL: @fsub_fadd_common_op_fneg_reassoc_nsz(286; CHECK-NEXT: [[R:%.*]] = fneg reassoc nsz float [[X:%.*]]287; CHECK-NEXT: ret float [[R]]288;289 %a = fadd float %x, %y290 %r = fsub reassoc nsz float %y, %a291 ret float %r292}293 294; Y - (X + Y) --> -X295 296define <2 x float> @fsub_fadd_common_op_fneg_vec(<2 x float> %x, <2 x float> %y) {297; CHECK-LABEL: @fsub_fadd_common_op_fneg_vec(298; CHECK-NEXT: [[R:%.*]] = fneg reassoc nsz <2 x float> [[X:%.*]]299; CHECK-NEXT: ret <2 x float> [[R]]300;301 %a = fadd <2 x float> %x, %y302 %r = fsub nsz reassoc <2 x float> %y, %a303 ret <2 x float> %r304}305 306; Y - (Y + X) --> -X307; Commute operands of the 'add'.308 309define float @fsub_fadd_common_op_fneg_commute(float %x, float %y) {310; CHECK-LABEL: @fsub_fadd_common_op_fneg_commute(311; CHECK-NEXT: [[R:%.*]] = fneg reassoc nsz float [[X:%.*]]312; CHECK-NEXT: ret float [[R]]313;314 %a = fadd float %y, %x315 %r = fsub reassoc nsz float %y, %a316 ret float %r317}318 319; Y - (Y + X) --> -X320 321define <2 x float> @fsub_fadd_common_op_fneg_commute_vec(<2 x float> %x, <2 x float> %y) {322; CHECK-LABEL: @fsub_fadd_common_op_fneg_commute_vec(323; CHECK-NEXT: [[R:%.*]] = fneg reassoc nsz <2 x float> [[X:%.*]]324; CHECK-NEXT: ret <2 x float> [[R]]325;326 %a = fadd <2 x float> %y, %x327 %r = fsub reassoc nsz <2 x float> %y, %a328 ret <2 x float> %r329}330 331; (Y - X) - Y --> -X332; nsz is required because: (0.0 - 0.0) - 0.0 -> 0.0, not -0.0333 334define float @fsub_fsub_common_op_fneg(float %x, float %y) {335; CHECK-LABEL: @fsub_fsub_common_op_fneg(336; CHECK-NEXT: [[R:%.*]] = fneg reassoc nsz float [[X:%.*]]337; CHECK-NEXT: ret float [[R]]338;339 %s = fsub float %y, %x340 %r = fsub reassoc nsz float %s, %y341 ret float %r342}343 344; (Y - X) - Y --> -X345 346define <2 x float> @fsub_fsub_common_op_fneg_vec(<2 x float> %x, <2 x float> %y) {347; CHECK-LABEL: @fsub_fsub_common_op_fneg_vec(348; CHECK-NEXT: [[R:%.*]] = fneg reassoc nsz <2 x float> [[X:%.*]]349; CHECK-NEXT: ret <2 x float> [[R]]350;351 %s = fsub <2 x float> %y, %x352 %r = fsub reassoc nsz <2 x float> %s, %y353 ret <2 x float> %r354}355 356; TODO: This doesn't require 'nsz'. It should fold to 0 - f2357define float @fold9_reassoc(float %f1, float %f2) {358; CHECK-LABEL: @fold9_reassoc(359; CHECK-NEXT: [[T1:%.*]] = fadd float [[F1:%.*]], [[F2:%.*]]360; CHECK-NEXT: [[T3:%.*]] = fsub reassoc float [[F1]], [[T1]]361; CHECK-NEXT: ret float [[T3]]362;363 %t1 = fadd float %f1, %f2364 %t3 = fsub reassoc float %f1, %t1365 ret float %t3366}367 368; Let C3 = C1 + C2. (f1 + C1) + (f2 + C2) => (f1 + f2) + C3 instead of369; "(f1 + C3) + f2" or "(f2 + C3) + f1". Placing constant-addend at the370; top of resulting simplified expression tree may potentially reveal some371; optimization opportunities in the super-expression trees.372;373define float @fold10(float %f1, float %f2) {374; CHECK-LABEL: @fold10(375; CHECK-NEXT: [[T2:%.*]] = fadd fast float [[F1:%.*]], [[F2:%.*]]376; CHECK-NEXT: [[T3:%.*]] = fadd fast float [[T2]], -1.000000e+00377; CHECK-NEXT: ret float [[T3]]378;379 %t1 = fadd fast float 2.000000e+00, %f1380 %t2 = fsub fast float %f2, 3.000000e+00381 %t3 = fadd fast float %t1, %t2382 ret float %t3383}384 385; Check again with 'reassoc' and 'nsz'.386; TODO: We may be able to remove the 'nsz' requirement.387define float @fold10_reassoc_nsz(float %f1, float %f2) {388; CHECK-LABEL: @fold10_reassoc_nsz(389; CHECK-NEXT: [[T2:%.*]] = fadd reassoc nsz float [[F1:%.*]], [[F2:%.*]]390; CHECK-NEXT: [[T3:%.*]] = fadd reassoc nsz float [[T2]], -1.000000e+00391; CHECK-NEXT: ret float [[T3]]392;393 %t1 = fadd reassoc nsz float 2.000000e+00, %f1394 %t2 = fsub reassoc nsz float %f2, 3.000000e+00395 %t3 = fadd reassoc nsz float %t1, %t2396 ret float %t3397}398 399; Observe that the fold is not done with only reassoc (the instructions are400; canonicalized, but not folded).401; TODO: As noted above, 'nsz' may not be required for this to be fully folded.402define float @fold10_reassoc(float %f1, float %f2) {403; CHECK-LABEL: @fold10_reassoc(404; CHECK-NEXT: [[T1:%.*]] = fadd reassoc float [[F1:%.*]], 2.000000e+00405; CHECK-NEXT: [[T2:%.*]] = fadd reassoc float [[F2:%.*]], -3.000000e+00406; CHECK-NEXT: [[T3:%.*]] = fadd reassoc float [[T1]], [[T2]]407; CHECK-NEXT: ret float [[T3]]408;409 %t1 = fadd reassoc float 2.000000e+00, %f1410 %t2 = fsub reassoc float %f2, 3.000000e+00411 %t3 = fadd reassoc float %t1, %t2412 ret float %t3413}414 415; This used to crash/miscompile.416 417define float @fail1(float %f1, float %f2) {418; CHECK-LABEL: @fail1(419; CHECK-NEXT: [[TMP1:%.*]] = fmul fast float [[F1:%.*]], 3.000000e+00420; CHECK-NEXT: [[ADD2:%.*]] = fadd fast float [[TMP1]], -3.000000e+00421; CHECK-NEXT: ret float [[ADD2]]422;423 %conv3 = fadd fast float %f1, -1.000000e+00424 %add = fadd fast float %conv3, %conv3425 %add2 = fadd fast float %add, %conv3426 ret float %add2427}428 429define double @fail2(double %f1, double %f2) {430; CHECK-LABEL: @fail2(431; CHECK-NEXT: [[TMP1:%.*]] = fadd fast double [[F2:%.*]], [[F2]]432; CHECK-NEXT: [[T3:%.*]] = fneg fast double [[TMP1]]433; CHECK-NEXT: ret double [[T3]]434;435 %t1 = fsub fast double %f1, %f2436 %t2 = fadd fast double %f1, %f2437 %t3 = fsub fast double %t1, %t2438 ret double %t3439}440 441; (X * C) - X --> X * (C - 1.0)442 443define float @fsub_op0_fmul_const(float %x) {444; CHECK-LABEL: @fsub_op0_fmul_const(445; CHECK-NEXT: [[SUB:%.*]] = fmul reassoc nsz float [[X:%.*]], 6.000000e+00446; CHECK-NEXT: ret float [[SUB]]447;448 %mul = fmul float %x, 7.0449 %sub = fsub reassoc nsz float %mul, %x450 ret float %sub451}452 453; (X * C) - X --> X * (C - 1.0)454 455define <2 x float> @fsub_op0_fmul_const_vec(<2 x float> %x) {456; CHECK-LABEL: @fsub_op0_fmul_const_vec(457; CHECK-NEXT: [[SUB:%.*]] = fmul reassoc nsz <2 x float> [[X:%.*]], <float 6.000000e+00, float -4.300000e+01>458; CHECK-NEXT: ret <2 x float> [[SUB]]459;460 %mul = fmul <2 x float> %x, <float 7.0, float -42.0>461 %sub = fsub reassoc nsz <2 x float> %mul, %x462 ret <2 x float> %sub463}464 465; X - (X * C) --> X * (1.0 - C)466 467define float @fsub_op1_fmul_const(float %x) {468; CHECK-LABEL: @fsub_op1_fmul_const(469; CHECK-NEXT: [[SUB:%.*]] = fmul reassoc nsz float [[X:%.*]], -6.000000e+00470; CHECK-NEXT: ret float [[SUB]]471;472 %mul = fmul float %x, 7.0473 %sub = fsub reassoc nsz float %x, %mul474 ret float %sub475}476 477; X - (X * C) --> X * (1.0 - C)478 479define <2 x float> @fsub_op1_fmul_const_vec(<2 x float> %x) {480; CHECK-LABEL: @fsub_op1_fmul_const_vec(481; CHECK-NEXT: [[SUB:%.*]] = fmul reassoc nsz <2 x float> [[X:%.*]], <float -6.000000e+00, float 1.000000e+00>482; CHECK-NEXT: ret <2 x float> [[SUB]]483;484 %mul = fmul <2 x float> %x, <float 7.0, float 0.0>485 %sub = fsub reassoc nsz <2 x float> %x, %mul486 ret <2 x float> %sub487}488 489; Verify the fold is not done with only 'reassoc' ('nsz' is required).490 491define float @fsub_op0_fmul_const_wrong_FMF(float %x) {492; CHECK-LABEL: @fsub_op0_fmul_const_wrong_FMF(493; CHECK-NEXT: [[MUL:%.*]] = fmul reassoc float [[X:%.*]], 7.000000e+00494; CHECK-NEXT: [[SUB:%.*]] = fsub reassoc float [[MUL]], [[X]]495; CHECK-NEXT: ret float [[SUB]]496;497 %mul = fmul reassoc float %x, 7.0498 %sub = fsub reassoc float %mul, %x499 ret float %sub500}501 502; (select X+Y, X-Y) => X + (select Y, -Y)503; This is always safe. No FMF required.504define float @fold16(float %x, float %y) {505; CHECK-LABEL: @fold16(506; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[X:%.*]], [[Y:%.*]]507; CHECK-NEXT: [[TMP1:%.*]] = fneg float [[Y]]508; CHECK-NEXT: [[R_P:%.*]] = select i1 [[CMP]], float [[Y]], float [[TMP1]]509; CHECK-NEXT: [[R:%.*]] = fadd float [[X]], [[R_P]]510; CHECK-NEXT: ret float [[R]]511;512 %cmp = fcmp ogt float %x, %y513 %plus = fadd float %x, %y514 %minus = fsub float %x, %y515 %r = select i1 %cmp, float %plus, float %minus516 ret float %r517}518 519; =========================================================================520;521; Testing-cases about negation522;523; =========================================================================524define float @fneg1(float %f1, float %f2) {525; CHECK-LABEL: @fneg1(526; CHECK-NEXT: [[MUL:%.*]] = fmul float [[F1:%.*]], [[F2:%.*]]527; CHECK-NEXT: ret float [[MUL]]528;529 %sub = fsub float -0.000000e+00, %f1530 %sub1 = fsub nsz float 0.000000e+00, %f2531 %mul = fmul float %sub, %sub1532 ret float %mul533}534 535define float @fneg2(float %x) {536; CHECK-LABEL: @fneg2(537; CHECK-NEXT: [[SUB:%.*]] = fneg nsz float [[X:%.*]]538; CHECK-NEXT: ret float [[SUB]]539;540 %sub = fsub nsz float 0.0, %x541 ret float %sub542}543 544define <2 x float> @fneg2_vec_poison(<2 x float> %x) {545; CHECK-LABEL: @fneg2_vec_poison(546; CHECK-NEXT: [[SUB:%.*]] = fneg nsz <2 x float> [[X:%.*]]547; CHECK-NEXT: ret <2 x float> [[SUB]]548;549 %sub = fsub nsz <2 x float> <float poison, float 0.0>, %x550 ret <2 x float> %sub551}552 553; =========================================================================554;555; Testing-cases about div556;557; =========================================================================558 559; X/C1 / C2 => X * (1/(C2*C1))560define float @fdiv1(float %x) {561; CHECK-LABEL: @fdiv1(562; CHECK-NEXT: [[DIV1:%.*]] = fmul fast float [[X:%.*]], 0x3FD7303B60000000563; CHECK-NEXT: ret float [[DIV1]]564;565 %div = fdiv fast float %x, 0x3FF3333340000000566 %div1 = fdiv fast float %div, 0x4002666660000000567 ret float %div1568; 0x3FF3333340000000 = 1.2f569; 0x4002666660000000 = 2.3f570; 0x3FD7303B60000000 = 0.36231884057971014492571}572 573; X*C1 / C2 => X * (C1/C2)574define float @fdiv2(float %x) {575; CHECK-LABEL: @fdiv2(576; CHECK-NEXT: [[DIV1:%.*]] = fmul fast float [[X:%.*]], 0x3FE0B21660000000577; CHECK-NEXT: ret float [[DIV1]]578;579 %mul = fmul float %x, 0x3FF3333340000000580 %div1 = fdiv fast float %mul, 0x4002666660000000581 ret float %div1582 583; 0x3FF3333340000000 = 1.2f584; 0x4002666660000000 = 2.3f585; 0x3FE0B21660000000 = 0.52173918485641479492586}587 588define <2 x float> @fdiv2_vec(<2 x float> %x) {589; CHECK-LABEL: @fdiv2_vec(590; CHECK-NEXT: [[DIV1:%.*]] = fmul fast <2 x float> [[X:%.*]], splat (float 3.000000e+00)591; CHECK-NEXT: ret <2 x float> [[DIV1]]592;593 %mul = fmul <2 x float> %x, <float 6.0, float 9.0>594 %div1 = fdiv fast <2 x float> %mul, <float 2.0, float 3.0>595 ret <2 x float> %div1596}597 598; "X/C1 / C2 => X * (1/(C2*C1))" is disabled (for now) is C2/C1 is a denormal599;600define float @fdiv3(float %x) {601; CHECK-LABEL: @fdiv3(602; CHECK-NEXT: [[TMP1:%.*]] = fmul fast float [[X:%.*]], 0x3FDBD37A80000000603; CHECK-NEXT: [[DIV1:%.*]] = fdiv fast float [[TMP1]], 0x47EFFFFFE0000000604; CHECK-NEXT: ret float [[DIV1]]605;606 %div = fdiv fast float %x, 0x47EFFFFFE0000000607 %div1 = fdiv fast float %div, 0x4002666660000000608 ret float %div1609}610 611; "X*C1 / C2 => X * (C1/C2)" is disabled if C1/C2 is a denormal612define float @fdiv4(float %x) {613; CHECK-LABEL: @fdiv4(614; CHECK-NEXT: [[MUL:%.*]] = fmul float [[X:%.*]], 0x47EFFFFFE0000000615; CHECK-NEXT: [[DIV:%.*]] = fdiv float [[MUL]], 0x3FC99999A0000000616; CHECK-NEXT: ret float [[DIV]]617;618 %mul = fmul float %x, 0x47EFFFFFE0000000619 %div = fdiv float %mul, 0x3FC99999A0000000620 ret float %div621}622 623; =========================================================================624;625; Test-cases for square root626;627; =========================================================================628 629; A squared factor fed into a square root intrinsic should be hoisted out630; as a fabs() value.631 632declare double @llvm.sqrt.f64(double)633 634define double @sqrt_intrinsic_arg_squared(double %x) {635; CHECK-LABEL: @sqrt_intrinsic_arg_squared(636; CHECK-NEXT: [[FABS:%.*]] = call fast double @llvm.fabs.f64(double [[X:%.*]])637; CHECK-NEXT: ret double [[FABS]]638;639 %mul = fmul fast double %x, %x640 %sqrt = call fast double @llvm.sqrt.f64(double %mul)641 ret double %sqrt642}643 644; Check all 6 combinations of a 3-way multiplication tree where645; one factor is repeated.646 647define double @sqrt_intrinsic_three_args1(double %x, double %y) {648; CHECK-LABEL: @sqrt_intrinsic_three_args1(649; CHECK-NEXT: [[FABS:%.*]] = call fast double @llvm.fabs.f64(double [[X:%.*]])650; CHECK-NEXT: [[SQRT1:%.*]] = call fast double @llvm.sqrt.f64(double [[Y:%.*]])651; CHECK-NEXT: [[SQRT:%.*]] = fmul fast double [[FABS]], [[SQRT1]]652; CHECK-NEXT: ret double [[SQRT]]653;654 %mul = fmul fast double %y, %x655 %mul2 = fmul fast double %mul, %x656 %sqrt = call fast double @llvm.sqrt.f64(double %mul2)657 ret double %sqrt658}659 660define double @sqrt_intrinsic_three_args2(double %x, double %y) {661; CHECK-LABEL: @sqrt_intrinsic_three_args2(662; CHECK-NEXT: [[FABS:%.*]] = call fast double @llvm.fabs.f64(double [[X:%.*]])663; CHECK-NEXT: [[SQRT1:%.*]] = call fast double @llvm.sqrt.f64(double [[Y:%.*]])664; CHECK-NEXT: [[SQRT:%.*]] = fmul fast double [[FABS]], [[SQRT1]]665; CHECK-NEXT: ret double [[SQRT]]666;667 %mul = fmul fast double %x, %y668 %mul2 = fmul fast double %mul, %x669 %sqrt = call fast double @llvm.sqrt.f64(double %mul2)670 ret double %sqrt671}672 673define double @sqrt_intrinsic_three_args3(double %x, double %y) {674; CHECK-LABEL: @sqrt_intrinsic_three_args3(675; CHECK-NEXT: [[FABS:%.*]] = call fast double @llvm.fabs.f64(double [[X:%.*]])676; CHECK-NEXT: [[SQRT1:%.*]] = call fast double @llvm.sqrt.f64(double [[Y:%.*]])677; CHECK-NEXT: [[SQRT:%.*]] = fmul fast double [[FABS]], [[SQRT1]]678; CHECK-NEXT: ret double [[SQRT]]679;680 %mul = fmul fast double %x, %x681 %mul2 = fmul fast double %mul, %y682 %sqrt = call fast double @llvm.sqrt.f64(double %mul2)683 ret double %sqrt684}685 686define double @sqrt_intrinsic_three_args4(double %x, double %y) {687; CHECK-LABEL: @sqrt_intrinsic_three_args4(688; CHECK-NEXT: [[FABS:%.*]] = call fast double @llvm.fabs.f64(double [[X:%.*]])689; CHECK-NEXT: [[SQRT1:%.*]] = call fast double @llvm.sqrt.f64(double [[Y:%.*]])690; CHECK-NEXT: [[SQRT:%.*]] = fmul fast double [[FABS]], [[SQRT1]]691; CHECK-NEXT: ret double [[SQRT]]692;693 %mul = fmul fast double %y, %x694 %mul2 = fmul fast double %x, %mul695 %sqrt = call fast double @llvm.sqrt.f64(double %mul2)696 ret double %sqrt697}698 699define double @sqrt_intrinsic_three_args5(double %x, double %y) {700; CHECK-LABEL: @sqrt_intrinsic_three_args5(701; CHECK-NEXT: [[FABS:%.*]] = call fast double @llvm.fabs.f64(double [[X:%.*]])702; CHECK-NEXT: [[SQRT1:%.*]] = call fast double @llvm.sqrt.f64(double [[Y:%.*]])703; CHECK-NEXT: [[SQRT:%.*]] = fmul fast double [[FABS]], [[SQRT1]]704; CHECK-NEXT: ret double [[SQRT]]705;706 %mul = fmul fast double %x, %y707 %mul2 = fmul fast double %x, %mul708 %sqrt = call fast double @llvm.sqrt.f64(double %mul2)709 ret double %sqrt710}711 712define double @sqrt_intrinsic_three_args6(double %x, ptr %yp) {713; CHECK-LABEL: @sqrt_intrinsic_three_args6(714; CHECK-NEXT: [[Y:%.*]] = load double, ptr [[YP:%.*]], align 8715; CHECK-NEXT: [[FABS:%.*]] = call fast double @llvm.fabs.f64(double [[X:%.*]])716; CHECK-NEXT: [[SQRT1:%.*]] = call fast double @llvm.sqrt.f64(double [[Y]])717; CHECK-NEXT: [[SQRT:%.*]] = fmul fast double [[FABS]], [[SQRT1]]718; CHECK-NEXT: ret double [[SQRT]]719;720 %y = load double, ptr %yp ; thwart complexity-based canonicalization721 %mul = fmul fast double %x, %x722 %mul2 = fmul fast double %y, %mul723 %sqrt = call fast double @llvm.sqrt.f64(double %mul2)724 ret double %sqrt725}726 727; If any operation is not 'fast', we can't simplify.728 729define double @sqrt_intrinsic_not_so_fast(double %x, double %y) {730; CHECK-LABEL: @sqrt_intrinsic_not_so_fast(731; CHECK-NEXT: [[MUL:%.*]] = fmul double [[X:%.*]], [[X]]732; CHECK-NEXT: [[MUL2:%.*]] = fmul fast double [[MUL]], [[Y:%.*]]733; CHECK-NEXT: [[SQRT:%.*]] = call fast double @llvm.sqrt.f64(double [[MUL2]])734; CHECK-NEXT: ret double [[SQRT]]735;736 %mul = fmul double %x, %x737 %mul2 = fmul fast double %mul, %y738 %sqrt = call fast double @llvm.sqrt.f64(double %mul2)739 ret double %sqrt740}741 742define double @sqrt_intrinsic_arg_4th(double %x) {743; CHECK-LABEL: @sqrt_intrinsic_arg_4th(744; CHECK-NEXT: [[MUL:%.*]] = fmul fast double [[X:%.*]], [[X]]745; CHECK-NEXT: ret double [[MUL]]746;747 %mul = fmul fast double %x, %x748 %mul2 = fmul fast double %mul, %mul749 %sqrt = call fast double @llvm.sqrt.f64(double %mul2)750 ret double %sqrt751}752 753define double @sqrt_intrinsic_arg_5th(double %x) {754; CHECK-LABEL: @sqrt_intrinsic_arg_5th(755; CHECK-NEXT: [[MUL:%.*]] = fmul fast double [[X:%.*]], [[X]]756; CHECK-NEXT: [[SQRT1:%.*]] = call fast double @llvm.sqrt.f64(double [[X]])757; CHECK-NEXT: [[SQRT:%.*]] = fmul fast double [[MUL]], [[SQRT1]]758; CHECK-NEXT: ret double [[SQRT]]759;760 %mul = fmul fast double %x, %x761 %mul2 = fmul fast double %mul, %x762 %mul3 = fmul fast double %mul2, %mul763 %sqrt = call fast double @llvm.sqrt.f64(double %mul3)764 ret double %sqrt765}766 767; Check that square root calls have the same behavior.768 769declare float @sqrtf(float)770declare double @sqrt(double)771declare fp128 @sqrtl(fp128)772 773define float @sqrt_call_squared_f32(float %x) {774; CHECK-LABEL: @sqrt_call_squared_f32(775; CHECK-NEXT: [[FABS:%.*]] = call fast float @llvm.fabs.f32(float [[X:%.*]])776; CHECK-NEXT: ret float [[FABS]]777;778 %mul = fmul fast float %x, %x779 %sqrt = call fast float @sqrtf(float %mul)780 ret float %sqrt781}782 783define double @sqrt_call_squared_f64(double %x) {784; CHECK-LABEL: @sqrt_call_squared_f64(785; CHECK-NEXT: [[FABS:%.*]] = call fast double @llvm.fabs.f64(double [[X:%.*]])786; CHECK-NEXT: ret double [[FABS]]787;788 %mul = fmul fast double %x, %x789 %sqrt = call fast double @sqrt(double %mul)790 ret double %sqrt791}792 793define fp128 @sqrt_call_squared_f128(fp128 %x) {794; CHECK-LABEL: @sqrt_call_squared_f128(795; CHECK-NEXT: [[FABS:%.*]] = call fast fp128 @llvm.fabs.f128(fp128 [[X:%.*]])796; CHECK-NEXT: ret fp128 [[FABS]]797;798 %mul = fmul fast fp128 %x, %x799 %sqrt = call fast fp128 @sqrtl(fp128 %mul)800 ret fp128 %sqrt801}802 803; =========================================================================804;805; Test-cases for fmin / fmax806;807; =========================================================================808 809declare double @fmax(double, double)810declare double @fmin(double, double)811declare float @fmaxf(float, float)812declare float @fminf(float, float)813declare fp128 @fmaxl(fp128, fp128)814declare fp128 @fminl(fp128, fp128)815 816; 'nsz' is implied by the definition of fmax or fmin itself.817 818; Shrink and replace the call.819define float @max1(float %a, float %b) {820; CHECK-LABEL: @max1(821; CHECK-NEXT: [[FMAXF:%.*]] = call fast float @llvm.maxnum.f32(float [[A:%.*]], float [[B:%.*]])822; CHECK-NEXT: ret float [[FMAXF]]823;824 %c = fpext float %a to double825 %d = fpext float %b to double826 %e = call fast double @fmax(double %c, double %d)827 %f = fptrunc double %e to float828 ret float %f829}830 831define float @fmax_no_fmf(float %a, float %b) {832; CHECK-LABEL: @fmax_no_fmf(833; CHECK-NEXT: [[C:%.*]] = call nsz float @llvm.maxnum.f32(float [[A:%.*]], float [[B:%.*]])834; CHECK-NEXT: ret float [[C]]835;836 %c = call float @fmaxf(float %a, float %b)837 ret float %c838}839 840define float @max2(float %a, float %b) {841; CHECK-LABEL: @max2(842; CHECK-NEXT: [[C:%.*]] = call nnan nsz float @llvm.maxnum.f32(float [[A:%.*]], float [[B:%.*]])843; CHECK-NEXT: ret float [[C]]844;845 %c = call nnan float @fmaxf(float %a, float %b)846 ret float %c847}848 849 850define double @max3(double %a, double %b) {851; CHECK-LABEL: @max3(852; CHECK-NEXT: [[C:%.*]] = call fast double @llvm.maxnum.f64(double [[A:%.*]], double [[B:%.*]])853; CHECK-NEXT: ret double [[C]]854;855 %c = call fast double @fmax(double %a, double %b)856 ret double %c857}858 859define fp128 @max4(fp128 %a, fp128 %b) {860; CHECK-LABEL: @max4(861; CHECK-NEXT: [[C:%.*]] = call nnan nsz fp128 @llvm.maxnum.f128(fp128 [[A:%.*]], fp128 [[B:%.*]])862; CHECK-NEXT: ret fp128 [[C]]863;864 %c = call nnan fp128 @fmaxl(fp128 %a, fp128 %b)865 ret fp128 %c866}867 868; Shrink and remove the call.869define float @min1(float %a, float %b) {870; CHECK-LABEL: @min1(871; CHECK-NEXT: [[FMINF:%.*]] = call nnan nsz float @llvm.minnum.f32(float [[A:%.*]], float [[B:%.*]])872; CHECK-NEXT: ret float [[FMINF]]873;874 %c = fpext float %a to double875 %d = fpext float %b to double876 %e = call nnan double @fmin(double %c, double %d)877 %f = fptrunc double %e to float878 ret float %f879}880 881define float @fmin_no_fmf(float %a, float %b) {882; CHECK-LABEL: @fmin_no_fmf(883; CHECK-NEXT: [[C:%.*]] = call nsz float @llvm.minnum.f32(float [[A:%.*]], float [[B:%.*]])884; CHECK-NEXT: ret float [[C]]885;886 %c = call float @fminf(float %a, float %b)887 ret float %c888}889 890define float @min2(float %a, float %b) {891; CHECK-LABEL: @min2(892; CHECK-NEXT: [[C:%.*]] = call fast float @llvm.minnum.f32(float [[A:%.*]], float [[B:%.*]])893; CHECK-NEXT: ret float [[C]]894;895 %c = call fast float @fminf(float %a, float %b)896 ret float %c897}898 899define double @min3(double %a, double %b) {900; CHECK-LABEL: @min3(901; CHECK-NEXT: [[C:%.*]] = call nnan nsz double @llvm.minnum.f64(double [[A:%.*]], double [[B:%.*]])902; CHECK-NEXT: ret double [[C]]903;904 %c = call nnan double @fmin(double %a, double %b)905 ret double %c906}907 908define fp128 @min4(fp128 %a, fp128 %b) {909; CHECK-LABEL: @min4(910; CHECK-NEXT: [[C:%.*]] = call fast fp128 @llvm.minnum.f128(fp128 [[A:%.*]], fp128 [[B:%.*]])911; CHECK-NEXT: ret fp128 [[C]]912;913 %c = call fast fp128 @fminl(fp128 %a, fp128 %b)914 ret fp128 %c915}916 917; ((which ? 2.0 : a) + 1.0) => (which ? 3.0 : (a + 1.0))918; This is always safe. No FMF required.919define float @test55(i1 %which, float %a) {920; CHECK-LABEL: @test55(921; CHECK-NEXT: entry:922; CHECK-NEXT: br i1 [[WHICH:%.*]], label [[FINAL:%.*]], label [[DELAY:%.*]]923; CHECK: delay:924; CHECK-NEXT: [[TMP0:%.*]] = fadd float [[A:%.*]], 1.000000e+00925; CHECK-NEXT: br label [[FINAL]]926; CHECK: final:927; CHECK-NEXT: [[PHI:%.*]] = phi float [ 3.000000e+00, [[ENTRY:%.*]] ], [ [[TMP0]], [[DELAY]] ]928; CHECK-NEXT: ret float [[PHI]]929;930entry:931 br i1 %which, label %final, label %delay932 933delay:934 br label %final935 936final:937 %phi = phi float [ 2.0, %entry ], [ %a, %delay ]938 %value = fadd float %phi, 1.0939 ret float %value940}941