1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py 2; 3; Test numbering remains continuous across: 4; - InstCombine/fast-basictest.ll 5; - PhaseOrdering/fast-basictest.ll 6; - PhaseOrdering/fast-reassociate-gvn.ll 7; - Reassociate/fast-basictest.ll 8; 9; RUN: opt < %s -reassociate -S | FileCheck %s 10 11; ((a + (-3)) + b) + 3 -> a + b 12; That only works with both instcombine and reassociate passes enabled. 13; Check that reassociate is not enough. 14 15; TODO: check if we can eliminate zero add. 16define float @test2(float %reg109, float %reg1111) { 17; CHECK-LABEL: @test2( 18; CHECK-NEXT: [[REG116:%.*]] = fadd fast float [[REG109:%.*]], 0.000000e+00 19; CHECK-NEXT: [[REG117:%.*]] = fadd fast float [[REG116]], [[REG1111:%.*]] 20; CHECK-NEXT: ret float [[REG117]] 21; 22 %reg115 = fadd fast float %reg109, -3.000000e+01 23 %reg116 = fadd fast float %reg115, %reg1111 24 %reg117 = fadd fast float %reg116, 3.000000e+01 25 ret float %reg117 26} 27 28define float @test2_no_FMF(float %reg109, float %reg1111) { 29; CHECK-LABEL: @test2_no_FMF( 30; CHECK-NEXT: [[REG115:%.*]] = fadd float [[REG109:%.*]], -3.000000e+01 31; CHECK-NEXT: [[REG116:%.*]] = fadd float [[REG115]], [[REG1111:%.*]] 32; CHECK-NEXT: [[REG117:%.*]] = fadd float [[REG116]], 3.000000e+01 33; CHECK-NEXT: ret float [[REG117]] 34; 35 %reg115 = fadd float %reg109, -3.000000e+01 36 %reg116 = fadd float %reg115, %reg1111 37 %reg117 = fadd float %reg116, 3.000000e+01 38 ret float %reg117 39} 40 41define float @test2_reassoc(float %reg109, float %reg1111) { 42; CHECK-LABEL: @test2_reassoc( 43; CHECK-NEXT: [[REG115:%.*]] = fadd reassoc float [[REG109:%.*]], -3.000000e+01 44; CHECK-NEXT: [[REG116:%.*]] = fadd reassoc float [[REG115]], [[REG1111:%.*]] 45; CHECK-NEXT: [[REG117:%.*]] = fadd reassoc float [[REG116]], 3.000000e+01 46; CHECK-NEXT: ret float [[REG117]] 47; 48 %reg115 = fadd reassoc float %reg109, -3.000000e+01 49 %reg116 = fadd reassoc float %reg115, %reg1111 50 %reg117 = fadd reassoc float %reg116, 3.000000e+01 51 ret float %reg117 52} 53 54@fe = external global float 55@fa = external global float 56@fb = external global float 57@fc = external global float 58@ff = external global float 59 60; If two sums of the same operands in different order are counted with 'fast' 61; flag and then stored to global variables, we can reuse the same value twice. 62; Sums: 63; - test3: (a+b)+c and (a+c)+b 64; - test4: c+(a+b) and (c+a)+b 65; - test5: c+(b+a) and (c+a)+b 66; 67; That only works with both gvn and reassociate passes enabled. 68; Check that reassociate is not enough. 69 70define void @test3() { 71; CHECK-LABEL: @test3( 72; CHECK-NEXT: [[A:%.*]] = load float, float* @fa, align 4 73; CHECK-NEXT: [[B:%.*]] = load float, float* @fb, align 4 74; CHECK-NEXT: [[C:%.*]] = load float, float* @fc, align 4 75; CHECK-NEXT: [[T1:%.*]] = fadd fast float [[B]], [[A]] 76; CHECK-NEXT: [[T2:%.*]] = fadd fast float [[T1]], [[C]] 77; CHECK-NEXT: [[T3:%.*]] = fadd fast float [[B]], [[A]] 78; CHECK-NEXT: [[T4:%.*]] = fadd fast float [[T3]], [[C]] 79; CHECK-NEXT: store float [[T2]], float* @fe, align 4 80; CHECK-NEXT: store float [[T4]], float* @ff, align 4 81; CHECK-NEXT: ret void 82; 83 %A = load float, float* @fa 84 %B = load float, float* @fb 85 %C = load float, float* @fc 86 %t1 = fadd fast float %A, %B 87 %t2 = fadd fast float %t1, %C 88 %t3 = fadd fast float %A, %C 89 %t4 = fadd fast float %t3, %B 90 ; e = (a+b)+c; 91 store float %t2, float* @fe 92 ; f = (a+c)+b 93 store float %t4, float* @ff 94 ret void 95} 96 97define void @test4() { 98; CHECK-LABEL: @test4( 99; CHECK-NEXT: [[A:%.*]] = load float, float* @fa, align 4 100; CHECK-NEXT: [[B:%.*]] = load float, float* @fb, align 4 101; CHECK-NEXT: [[C:%.*]] = load float, float* @fc, align 4 102; CHECK-NEXT: [[T1:%.*]] = fadd fast float [[B]], [[A]] 103; CHECK-NEXT: [[T2:%.*]] = fadd fast float [[T1]], [[C]] 104; CHECK-NEXT: [[T3:%.*]] = fadd fast float [[B]], [[A]] 105; CHECK-NEXT: [[T4:%.*]] = fadd fast float [[T3]], [[C]] 106; CHECK-NEXT: store float [[T2]], float* @fe, align 4 107; CHECK-NEXT: store float [[T4]], float* @ff, align 4 108; CHECK-NEXT: ret void 109; 110 %A = load float, float* @fa 111 %B = load float, float* @fb 112 %C = load float, float* @fc 113 %t1 = fadd fast float %A, %B 114 %t2 = fadd fast float %C, %t1 115 %t3 = fadd fast float %C, %A 116 %t4 = fadd fast float %t3, %B 117 ; e = c+(a+b) 118 store float %t2, float* @fe 119 ; f = (c+a)+b 120 store float %t4, float* @ff 121 ret void 122} 123 124define void @test5() { 125; CHECK-LABEL: @test5( 126; CHECK-NEXT: [[A:%.*]] = load float, float* @fa, align 4 127; CHECK-NEXT: [[B:%.*]] = load float, float* @fb, align 4 128; CHECK-NEXT: [[C:%.*]] = load float, float* @fc, align 4 129; CHECK-NEXT: [[T1:%.*]] = fadd fast float [[B]], [[A]] 130; CHECK-NEXT: [[T2:%.*]] = fadd fast float [[T1]], [[C]] 131; CHECK-NEXT: [[T3:%.*]] = fadd fast float [[B]], [[A]] 132; CHECK-NEXT: [[T4:%.*]] = fadd fast float [[T3]], [[C]] 133; CHECK-NEXT: store float [[T2]], float* @fe, align 4 134; CHECK-NEXT: store float [[T4]], float* @ff, align 4 135; CHECK-NEXT: ret void 136; 137 %A = load float, float* @fa 138 %B = load float, float* @fb 139 %C = load float, float* @fc 140 %t1 = fadd fast float %B, %A 141 %t2 = fadd fast float %C, %t1 142 %t3 = fadd fast float %C, %A 143 %t4 = fadd fast float %t3, %B 144 ; e = c+(b+a) 145 store float %t2, float* @fe 146 ; f = (c+a)+b 147 store float %t4, float* @ff 148 ret void 149} 150 151define float @test6(float %A, float %B, float %C) { 152; CHECK-LABEL: @test6( 153; CHECK-NEXT: [[REASS_ADD1:%.*]] = fadd fast float [[C:%.*]], [[B:%.*]] 154; CHECK-NEXT: [[REASS_MUL2:%.*]] = fmul fast float [[A:%.*]], [[A]] 155; CHECK-NEXT: [[REASS_MUL:%.*]] = fmul fast float [[REASS_MUL2]], [[REASS_ADD1]] 156; CHECK-NEXT: ret float [[REASS_MUL]] 157; 158 %aa = fmul fast float %A, %A 159 %aab = fmul fast float %aa, %B 160 %ac = fmul fast float %A, %C 161 %aac = fmul fast float %ac, %A 162 %r = fadd fast float %aab, %aac 163 ret float %r 164} 165 166define float @test6_reassoc(float %A, float %B, float %C) { 167; CHECK-LABEL: @test6_reassoc( 168; CHECK-NEXT: [[AA:%.*]] = fmul reassoc float [[A:%.*]], [[A]] 169; CHECK-NEXT: [[AAB:%.*]] = fmul reassoc float [[AA]], [[B:%.*]] 170; CHECK-NEXT: [[AC:%.*]] = fmul reassoc float [[A]], [[C:%.*]] 171; CHECK-NEXT: [[AAC:%.*]] = fmul reassoc float [[A]], [[AC]] 172; CHECK-NEXT: [[R:%.*]] = fadd reassoc float [[AAB]], [[AAC]] 173; CHECK-NEXT: ret float [[R]] 174; 175 %aa = fmul reassoc float %A, %A 176 %aab = fmul reassoc float %aa, %B 177 %ac = fmul reassoc float %A, %C 178 %aac = fmul reassoc float %ac, %A 179 %r = fadd reassoc float %aab, %aac 180 ret float %r 181} 182 183; (-X)*Y + Z -> Z-X*Y 184; TODO: check why IR transformation of test7 with 'fast' math flag 185; is worse than without it (and even without transformation) 186 187define float @test7(float %X, float %Y, float %Z) { 188; CHECK-LABEL: @test7( 189; CHECK-NEXT: [[TMP1:%.*]] = fsub fast float 0.000000e+00, 0.000000e+00 190; CHECK-NEXT: [[A:%.*]] = fmul fast float [[Y:%.*]], [[X:%.*]] 191; CHECK-NEXT: [[B:%.*]] = fmul fast float [[A]], 1.000000e+00 192; CHECK-NEXT: [[TMP2:%.*]] = fsub fast float [[Z:%.*]], [[B]] 193; CHECK-NEXT: ret float [[TMP2]] 194; 195 %A = fsub fast float 0.0, %X 196 %B = fmul fast float %A, %Y 197 %C = fadd fast float %B, %Z 198 ret float %C 199} 200 201define float @test7_unary_fneg(float %X, float %Y, float %Z) { 202; CHECK-LABEL: @test7_unary_fneg( 203; CHECK-NEXT: [[TMP1:%.*]] = fneg fast float 0.000000e+00 204; CHECK-NEXT: [[A:%.*]] = fmul fast float [[Y:%.*]], [[X:%.*]] 205; CHECK-NEXT: [[B:%.*]] = fmul fast float [[A]], 1.000000e+00 206; CHECK-NEXT: [[TMP2:%.*]] = fsub fast float [[Z:%.*]], [[B]] 207; CHECK-NEXT: ret float [[TMP2]] 208; 209 %A = fneg fast float %X 210 %B = fmul fast float %A, %Y 211 %C = fadd fast float %B, %Z 212 ret float %C 213} 214 215define float @test7_reassoc_nsz(float %X, float %Y, float %Z) { 216; CHECK-LABEL: @test7_reassoc_nsz( 217; CHECK-NEXT: [[A:%.*]] = fsub reassoc nsz float 0.000000e+00, [[X:%.*]] 218; CHECK-NEXT: [[B:%.*]] = fmul reassoc nsz float [[A]], [[Y:%.*]] 219; CHECK-NEXT: [[C:%.*]] = fadd reassoc nsz float [[B]], [[Z:%.*]] 220; CHECK-NEXT: ret float [[C]] 221; 222 %A = fsub reassoc nsz float 0.0, %X 223 %B = fmul reassoc nsz float %A, %Y 224 %C = fadd reassoc nsz float %B, %Z 225 ret float %C 226} 227 228; Verify that fold is not done only with 'reassoc' ('nsz' is required) 229define float @test7_reassoc(float %X, float %Y, float %Z) { 230; CHECK-LABEL: @test7_reassoc( 231; CHECK-NEXT: [[A:%.*]] = fsub reassoc float 0.000000e+00, [[X:%.*]] 232; CHECK-NEXT: [[B:%.*]] = fmul reassoc float [[A]], [[Y:%.*]] 233; CHECK-NEXT: [[C:%.*]] = fadd reassoc float [[B]], [[Z:%.*]] 234; CHECK-NEXT: ret float [[C]] 235; 236 %A = fsub reassoc float 0.0, %X 237 %B = fmul reassoc float %A, %Y 238 %C = fadd reassoc float %B, %Z 239 ret float %C 240} 241 242define float @test8(float %X) { 243; CHECK-LABEL: @test8( 244; CHECK-NEXT: [[FACTOR:%.*]] = fmul fast float [[X:%.*]], 9.400000e+01 245; CHECK-NEXT: ret float [[FACTOR]] 246; 247 %Y = fmul fast float %X, 4.700000e+01 248 %Z = fadd fast float %Y, %Y 249 ret float %Z 250} 251 252; Side note: (x + x + x) and (3*x) each have only a single rounding. So 253; transforming x+x+x to 3*x is always safe, even without any FMF. 254; To avoid that special-case, we have the addition of 'x' four times, here. 255define float @test9(float %X) { 256; CHECK-LABEL: @test9( 257; CHECK-NEXT: [[FACTOR:%.*]] = fmul fast float [[X:%.*]], 4.000000e+00 258; CHECK-NEXT: ret float [[FACTOR]] 259; 260 %Y = fadd fast float %X ,%X 261 %Z = fadd fast float %Y, %X 262 %W = fadd fast float %Z, %X 263 ret float %W 264} 265 266define float @test10(float %W) { 267; CHECK-LABEL: @test10( 268; CHECK-NEXT: [[FACTOR:%.*]] = fmul fast float [[W:%.*]], 3.810000e+02 269; CHECK-NEXT: ret float [[FACTOR]] 270; 271 %X = fmul fast float %W, 127.0 272 %Y = fadd fast float %X ,%X 273 %Z = fadd fast float %Y, %X 274 ret float %Z 275} 276 277define float @test11(float %X) { 278; CHECK-LABEL: @test11( 279; CHECK-NEXT: [[TMP1:%.*]] = fneg fast float 0.000000e+00 280; CHECK-NEXT: [[FACTOR:%.*]] = fmul fast float [[X:%.*]], -3.000000e+00 281; CHECK-NEXT: [[Z:%.*]] = fadd fast float [[FACTOR]], 6.000000e+00 282; CHECK-NEXT: ret float [[Z]] 283; 284 %A = fsub fast float 1.000000e+00, %X 285 %B = fsub fast float 2.000000e+00, %X 286 %C = fsub fast float 3.000000e+00, %X 287 %Y = fadd fast float %A ,%B 288 %Z = fadd fast float %Y, %C 289 ret float %Z 290} 291 292; TODO: check why IR transformation of test12 with 'fast' math flag 293; is worse than without it (and even without transformation) 294 295define float @test12(float %X1, float %X2, float %X3) { 296; CHECK-LABEL: @test12( 297; CHECK-NEXT: [[TMP1:%.*]] = fsub fast float 0.000000e+00, 0.000000e+00 298; CHECK-NEXT: [[A:%.*]] = fmul fast float [[X2:%.*]], [[X1:%.*]] 299; CHECK-NEXT: [[B:%.*]] = fmul fast float [[A]], 1.000000e+00 300; CHECK-NEXT: [[C:%.*]] = fmul fast float [[X3:%.*]], [[X1]] 301; CHECK-NEXT: [[TMP2:%.*]] = fsub fast float [[C]], [[B]] 302; CHECK-NEXT: ret float [[TMP2]] 303; 304 %A = fsub fast float 0.000000e+00, %X1 305 %B = fmul fast float %A, %X2 ; -X1*X2 306 %C = fmul fast float %X1, %X3 ; X1*X3 307 %D = fadd fast float %B, %C ; -X1*X2 + X1*X3 -> X1*(X3-X2) 308 ret float %D 309} 310 311define float @test12_unary_fneg(float %X1, float %X2, float %X3) { 312; CHECK-LABEL: @test12_unary_fneg( 313; CHECK-NEXT: [[TMP1:%.*]] = fneg fast float 0.000000e+00 314; CHECK-NEXT: [[A:%.*]] = fmul fast float [[X2:%.*]], [[X1:%.*]] 315; CHECK-NEXT: [[B:%.*]] = fmul fast float [[A]], 1.000000e+00 316; CHECK-NEXT: [[C:%.*]] = fmul fast float [[X3:%.*]], [[X1]] 317; CHECK-NEXT: [[TMP2:%.*]] = fsub fast float [[C]], [[B]] 318; CHECK-NEXT: ret float [[TMP2]] 319; 320 %A = fneg fast float %X1 321 %B = fmul fast float %A, %X2 ; -X1*X2 322 %C = fmul fast float %X1, %X3 ; X1*X3 323 %D = fadd fast float %B, %C ; -X1*X2 + X1*X3 -> X1*(X3-X2) 324 ret float %D 325} 326 327define float @test12_reassoc_nsz(float %X1, float %X2, float %X3) { 328; CHECK-LABEL: @test12_reassoc_nsz( 329; CHECK-NEXT: [[A:%.*]] = fsub reassoc nsz float 0.000000e+00, [[X1:%.*]] 330; CHECK-NEXT: [[B:%.*]] = fmul reassoc nsz float [[A]], [[X2:%.*]] 331; CHECK-NEXT: [[C:%.*]] = fmul reassoc nsz float [[X1]], [[X3:%.*]] 332; CHECK-NEXT: [[D:%.*]] = fadd reassoc nsz float [[B]], [[C]] 333; CHECK-NEXT: ret float [[D]] 334; 335 %A = fsub reassoc nsz float 0.000000e+00, %X1 336 %B = fmul reassoc nsz float %A, %X2 ; -X1*X2 337 %C = fmul reassoc nsz float %X1, %X3 ; X1*X3 338 %D = fadd reassoc nsz float %B, %C ; -X1*X2 + X1*X3 -> X1*(X3-X2) 339 ret float %D 340} 341 342; TODO: check if 'nsz' is technically required. Currently the optimization 343; is not done with only 'reassoc' without 'nsz'. 344define float @test12_reassoc(float %X1, float %X2, float %X3) { 345; CHECK-LABEL: @test12_reassoc( 346; CHECK-NEXT: [[A:%.*]] = fsub reassoc float 0.000000e+00, [[X1:%.*]] 347; CHECK-NEXT: [[B:%.*]] = fmul reassoc float [[A]], [[X2:%.*]] 348; CHECK-NEXT: [[C:%.*]] = fmul reassoc float [[X1]], [[X3:%.*]] 349; CHECK-NEXT: [[D:%.*]] = fadd reassoc float [[B]], [[C]] 350; CHECK-NEXT: ret float [[D]] 351; 352 %A = fsub reassoc float 0.000000e+00, %X1 353 %B = fmul reassoc float %A, %X2 ; -X1*X2 354 %C = fmul reassoc float %X1, %X3 ; X1*X3 355 %D = fadd reassoc float %B, %C ; -X1*X2 + X1*X3 -> X1*(X3-X2) 356 ret float %D 357} 358 359; (x1 * 47) + (x2 * -47) => (x1 - x2) * 47 360; That only works with both instcombine and reassociate passes enabled. 361; Check that reassociate is not enough. 362 363define float @test13(float %X1, float %X2) { 364; CHECK-LABEL: @test13( 365; CHECK-NEXT: [[B:%.*]] = fmul fast float [[X1:%.*]], 4.700000e+01 366; CHECK-NEXT: [[C:%.*]] = fmul fast float [[X2:%.*]], 4.700000e+01 367; CHECK-NEXT: [[TMP1:%.*]] = fsub fast float [[B]], [[C]] 368; CHECK-NEXT: ret float [[TMP1]] 369; 370 %B = fmul fast float %X1, 47. ; X1*47 371 %C = fmul fast float %X2, -47. ; X2*-47 372 %D = fadd fast float %B, %C ; X1*47 + X2*-47 -> 47*(X1-X2) 373 ret float %D 374} 375 376define float @test13_reassoc_nsz(float %X1, float %X2) { 377; CHECK-LABEL: @test13_reassoc_nsz( 378; CHECK-NEXT: [[B:%.*]] = fmul reassoc nsz float [[X1:%.*]], 4.700000e+01 379; CHECK-NEXT: [[C:%.*]] = fmul reassoc nsz float [[X2:%.*]], 4.700000e+01 380; CHECK-NEXT: [[TMP1:%.*]] = fsub reassoc nsz float [[B]], [[C]] 381; CHECK-NEXT: ret float [[TMP1]] 382; 383 %B = fmul reassoc nsz float %X1, 47. ; X1*47 384 %C = fmul reassoc nsz float %X2, -47. ; X2*-47 385 %D = fadd reassoc nsz float %B, %C ; X1*47 + X2*-47 -> 47*(X1-X2) 386 ret float %D 387} 388 389define float @test13_reassoc(float %X1, float %X2) { 390; CHECK-LABEL: @test13_reassoc( 391; CHECK-NEXT: [[B:%.*]] = fmul reassoc float [[X1:%.*]], 4.700000e+01 392; CHECK-NEXT: [[C:%.*]] = fmul reassoc float [[X2:%.*]], 4.700000e+01 393; CHECK-NEXT: [[TMP1:%.*]] = fsub reassoc float [[B]], [[C]] 394; CHECK-NEXT: ret float [[TMP1]] 395; 396 %B = fmul reassoc float %X1, 47. ; X1*47 397 %C = fmul reassoc float %X2, -47. ; X2*-47 398 %D = fadd reassoc float %B, %C ; X1*47 + X2*-47 -> 47*(X1-X2) 399 ret float %D 400} 401 402define float @test14(float %arg) { 403; CHECK-LABEL: @test14( 404; CHECK-NEXT: [[T2:%.*]] = fmul fast float [[ARG:%.*]], 1.440000e+02 405; CHECK-NEXT: ret float [[T2]] 406; 407 %t1 = fmul fast float 1.200000e+01, %arg 408 %t2 = fmul fast float %t1, 1.200000e+01 409 ret float %t2 410} 411 412; TODO: check if we can transform the code with 'reassoc' only. 413; The same IR is transformed to one fmul in instcombine pass. 414define float @test14_reassoc(float %arg) { 415; CHECK-LABEL: @test14_reassoc( 416; CHECK-NEXT: [[T1:%.*]] = fmul reassoc float [[ARG:%.*]], 1.200000e+01 417; CHECK-NEXT: [[T2:%.*]] = fmul reassoc float [[T1]], 1.200000e+01 418; CHECK-NEXT: ret float [[T2]] 419; 420 %t1 = fmul reassoc float 1.200000e+01, %arg 421 %t2 = fmul reassoc float %t1, 1.200000e+01 422 ret float %t2 423} 424 425; (b+(a+1234))+-a -> b+1234 426; That only works with both instcombine and reassociate passes enabled. 427; Check that reassociate is not enough. 428 429; TODO: check if we can remove dead fsub. 430define float @test15(float %b, float %a) { 431; CHECK-LABEL: @test15( 432; CHECK-NEXT: [[TMP1:%.*]] = fsub fast float 0.000000e+00, [[A:%.*]] 433; CHECK-NEXT: [[TMP2:%.*]] = fadd fast float [[B:%.*]], 1.234000e+03 434; CHECK-NEXT: ret float [[TMP2]] 435; 436 %1 = fadd fast float %a, 1234.0 437 %2 = fadd fast float %b, %1 438 %3 = fsub fast float 0.0, %a 439 %4 = fadd fast float %2, %3 440 ret float %4 441} 442 443; TODO: check if we can remove dead fneg. 444define float @test15_unary_fneg(float %b, float %a) { 445; CHECK-LABEL: @test15_unary_fneg( 446; CHECK-NEXT: [[TMP1:%.*]] = fneg fast float [[A:%.*]] 447; CHECK-NEXT: [[TMP2:%.*]] = fadd fast float [[B:%.*]], 1.234000e+03 448; CHECK-NEXT: ret float [[TMP2]] 449; 450 %1 = fadd fast float %a, 1234.0 451 %2 = fadd fast float %b, %1 452 %3 = fneg fast float %a 453 %4 = fadd fast float %2, %3 454 ret float %4 455} 456 457define float @test15_reassoc_nsz(float %b, float %a) { 458; CHECK-LABEL: @test15_reassoc_nsz( 459; CHECK-NEXT: [[TMP1:%.*]] = fadd reassoc nsz float [[A:%.*]], 1.234000e+03 460; CHECK-NEXT: [[TMP2:%.*]] = fadd reassoc nsz float [[B:%.*]], [[TMP1]] 461; CHECK-NEXT: [[TMP3:%.*]] = fsub reassoc nsz float 0.000000e+00, [[A]] 462; CHECK-NEXT: [[TMP4:%.*]] = fadd reassoc nsz float [[TMP3]], [[TMP2]] 463; CHECK-NEXT: ret float [[TMP4]] 464; 465 %1 = fadd reassoc nsz float %a, 1234.0 466 %2 = fadd reassoc nsz float %b, %1 467 %3 = fsub reassoc nsz float 0.0, %a 468 %4 = fadd reassoc nsz float %2, %3 469 ret float %4 470} 471 472define float @test15_reassoc(float %b, float %a) { 473; CHECK-LABEL: @test15_reassoc( 474; CHECK-NEXT: [[TMP1:%.*]] = fadd reassoc float [[A:%.*]], 1.234000e+03 475; CHECK-NEXT: [[TMP2:%.*]] = fadd reassoc float [[B:%.*]], [[TMP1]] 476; CHECK-NEXT: [[TMP3:%.*]] = fsub reassoc float 0.000000e+00, [[A]] 477; CHECK-NEXT: [[TMP4:%.*]] = fadd reassoc float [[TMP3]], [[TMP2]] 478; CHECK-NEXT: ret float [[TMP4]] 479; 480 %1 = fadd reassoc float %a, 1234.0 481 %2 = fadd reassoc float %b, %1 482 %3 = fsub reassoc float 0.0, %a 483 %4 = fadd reassoc float %2, %3 484 ret float %4 485} 486 487; Test that we can turn things like X*-(Y*Z) -> X*-1*Y*Z. 488; That only works with both instcombine and reassociate passes enabled. 489; Check that reassociate is not enough. 490 491define float @test16(float %a, float %b, float %z) { 492; CHECK-LABEL: @test16( 493; CHECK-NEXT: [[TMP1:%.*]] = fsub fast float 0.000000e+00, 0.000000e+00 494; CHECK-NEXT: [[C:%.*]] = fmul fast float [[A:%.*]], 1.234500e+04 495; CHECK-NEXT: [[E:%.*]] = fmul fast float [[C]], [[B:%.*]] 496; CHECK-NEXT: [[F:%.*]] = fmul fast float [[E]], [[Z:%.*]] 497; CHECK-NEXT: [[TMP2:%.*]] = fadd fast float [[F]], 0.000000e+00 498; CHECK-NEXT: ret float [[TMP2]] 499; 500 %c = fsub fast float 0.000000e+00, %z 501 %d = fmul fast float %a, %b 502 %e = fmul fast float %c, %d 503 %f = fmul fast float %e, 1.234500e+04 504 %g = fsub fast float 0.000000e+00, %f 505 ret float %g 506} 507 508define float @test16_unary_fneg(float %a, float %b, float %z) { 509; CHECK-LABEL: @test16_unary_fneg( 510; CHECK-NEXT: [[TMP1:%.*]] = fneg fast float 0.000000e+00 511; CHECK-NEXT: [[E:%.*]] = fmul fast float [[A:%.*]], 1.234500e+04 512; CHECK-NEXT: [[F:%.*]] = fmul fast float [[E]], [[B:%.*]] 513; CHECK-NEXT: [[G:%.*]] = fmul fast float [[F]], [[Z:%.*]] 514; CHECK-NEXT: ret float [[G]] 515; 516 %c = fneg fast float %z 517 %d = fmul fast float %a, %b 518 %e = fmul fast float %c, %d 519 %f = fmul fast float %e, 1.234500e+04 520 %g = fneg fast float %f 521 ret float %g 522} 523 524define float @test16_reassoc(float %a, float %b, float %z) { 525; CHECK-LABEL: @test16_reassoc( 526; CHECK-NEXT: [[C:%.*]] = fsub reassoc float 0.000000e+00, [[Z:%.*]] 527; CHECK-NEXT: [[D:%.*]] = fmul reassoc float [[A:%.*]], [[B:%.*]] 528; CHECK-NEXT: [[E:%.*]] = fmul reassoc float [[D]], [[C]] 529; CHECK-NEXT: [[F:%.*]] = fmul reassoc float [[E]], 1.234500e+04 530; CHECK-NEXT: [[G:%.*]] = fsub reassoc float 0.000000e+00, [[F]] 531; CHECK-NEXT: ret float [[G]] 532; 533 %c = fsub reassoc float 0.000000e+00, %z 534 %d = fmul reassoc float %a, %b 535 %e = fmul reassoc float %c, %d 536 %f = fmul reassoc float %e, 1.234500e+04 537 %g = fsub reassoc float 0.000000e+00, %f 538 ret float %g 539} 540 541; TODO: check if we can remove: 542; - fsub fast 0, 0 543; - fadd fast x, 0 544; ... as 'fast' implies 'nsz' 545define float @test17(float %a, float %b, float %z) { 546; CHECK-LABEL: @test17( 547; CHECK-NEXT: [[TMP1:%.*]] = fsub fast float 0.000000e+00, 0.000000e+00 548; CHECK-NEXT: [[C:%.*]] = fmul fast float [[A:%.*]], 4.000000e+01 549; CHECK-NEXT: [[E:%.*]] = fmul fast float [[C]], [[Z:%.*]] 550; CHECK-NEXT: [[TMP2:%.*]] = fadd fast float [[E]], 0.000000e+00 551; CHECK-NEXT: ret float [[TMP2]] 552; 553 %d = fmul fast float %z, 4.000000e+01 554 %c = fsub fast float 0.000000e+00, %d 555 %e = fmul fast float %a, %c 556 %f = fsub fast float 0.000000e+00, %e 557 ret float %f 558} 559 560; TODO: check if we can remove fneg fast 0 as 'fast' implies 'nsz' 561define float @test17_unary_fneg(float %a, float %b, float %z) { 562; CHECK-LABEL: @test17_unary_fneg( 563; CHECK-NEXT: [[TMP1:%.*]] = fneg fast float 0.000000e+00 564; CHECK-NEXT: [[E:%.*]] = fmul fast float [[A:%.*]], 4.000000e+01 565; CHECK-NEXT: [[F:%.*]] = fmul fast float [[E]], [[Z:%.*]] 566; CHECK-NEXT: ret float [[F]] 567; 568 %d = fmul fast float %z, 4.000000e+01 569 %c = fneg fast float %d 570 %e = fmul fast float %a, %c 571 %f = fneg fast float %e 572 ret float %f 573} 574 575; With sub reassociation, constant folding can eliminate the 12 and -12 constants. 576; TODO: check if we can remove fadd fast x, 0 as 'fast' implies 'nsz' 577define float @test18(float %A, float %B) { 578; CHECK-LABEL: @test18( 579; CHECK-NEXT: [[B_NEG:%.*]] = fneg fast float [[B:%.*]] 580; CHECK-NEXT: [[Y:%.*]] = fadd fast float [[A:%.*]], 0.000000e+00 581; CHECK-NEXT: [[Z:%.*]] = fadd fast float [[Y]], [[B_NEG]] 582; CHECK-NEXT: ret float [[Z]] 583; 584 %X = fadd fast float -1.200000e+01, %A 585 %Y = fsub fast float %X, %B 586 %Z = fadd fast float %Y, 1.200000e+01 587 ret float %Z 588} 589