1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py 2; RUN: opt < %s -passes=instsimplify -S | FileCheck %s 3 4define i32 @test1(i32 %A) { 5; CHECK-LABEL: @test1( 6; CHECK-NEXT: ret i32 [[A:%.*]] 7; 8 %B = or i32 %A, 0 9 ret i32 %B 10} 11 12define i32 @all_ones(i32 %A) { 13; CHECK-LABEL: @all_ones( 14; CHECK-NEXT: ret i32 -1 15; 16 %B = or i32 %A, -1 17 ret i32 %B 18} 19 20define <3 x i8> @all_ones_vec_with_undef_elt(<3 x i8> %A) { 21; CHECK-LABEL: @all_ones_vec_with_undef_elt( 22; CHECK-NEXT: ret <3 x i8> <i8 -1, i8 -1, i8 -1> 23; 24 %B = or <3 x i8> %A, <i8 -1, i8 undef, i8 -1> 25 ret <3 x i8> %B 26} 27 28define i1 @test3(i1 %A) { 29; CHECK-LABEL: @test3( 30; CHECK-NEXT: ret i1 [[A:%.*]] 31; 32 %B = or i1 %A, false 33 ret i1 %B 34} 35 36define i1 @test4(i1 %A) { 37; CHECK-LABEL: @test4( 38; CHECK-NEXT: ret i1 true 39; 40 %B = or i1 %A, true 41 ret i1 %B 42} 43 44define i1 @test5(i1 %A) { 45; CHECK-LABEL: @test5( 46; CHECK-NEXT: ret i1 [[A:%.*]] 47; 48 %B = or i1 %A, %A 49 ret i1 %B 50} 51 52define i32 @test6(i32 %A) { 53; CHECK-LABEL: @test6( 54; CHECK-NEXT: ret i32 [[A:%.*]] 55; 56 %B = or i32 %A, %A 57 ret i32 %B 58} 59 60; A | ~A == -1 61 62define i32 @or_not(i32 %A) { 63; CHECK-LABEL: @or_not( 64; CHECK-NEXT: ret i32 -1 65; 66 %NotA = xor i32 %A, -1 67 %B = or i32 %A, %NotA 68 ret i32 %B 69} 70 71define <2 x i4> @or_not_commute_vec_undef(<2 x i4> %A) { 72; CHECK-LABEL: @or_not_commute_vec_undef( 73; CHECK-NEXT: ret <2 x i4> <i4 -1, i4 -1> 74; 75 %NotA = xor <2 x i4> %A, <i4 -1, i4 undef> 76 %B = or <2 x i4> %NotA, %A 77 ret <2 x i4> %B 78} 79 80define i8 @test8(i8 %A) { 81; CHECK-LABEL: @test8( 82; CHECK-NEXT: ret i8 -1 83; 84 %B = or i8 %A, -2 85 %C = or i8 %B, 1 86 ret i8 %C 87} 88 89; Test that (A|c1)|(B|c2) == (A|B)|(c1|c2) 90define i8 @test9(i8 %A, i8 %B) { 91; CHECK-LABEL: @test9( 92; CHECK-NEXT: ret i8 -1 93; 94 %C = or i8 %A, 1 95 %D = or i8 %B, -2 96 %E = or i8 %C, %D 97 ret i8 %E 98} 99 100; (X & C1) | C2 --> (X | C2) & (C1|C2) 101define i8 @test10(i8 %A) { 102; CHECK-LABEL: @test10( 103; CHECK-NEXT: ret i8 -2 104; 105 %B = or i8 %A, 1 106 %C = and i8 %B, -2 107 %D = or i8 %C, -2 108 ret i8 %D 109} 110 111; The following two cases only get folded by InstCombine, 112; see InstCombine/or-xor.ll. 113 114; (X ^ C1) | C2 --> (X | C2) ^ (C1&~C2) 115define i8 @test11(i8 %A) { 116; CHECK-LABEL: @test11( 117; CHECK-NEXT: [[B:%.*]] = or i8 [[A:%.*]], -2 118; CHECK-NEXT: [[C:%.*]] = xor i8 [[B]], 13 119; CHECK-NEXT: [[D:%.*]] = or i8 [[C]], 1 120; CHECK-NEXT: [[E:%.*]] = xor i8 [[D]], 12 121; CHECK-NEXT: ret i8 [[E]] 122; 123 %B = or i8 %A, -2 124 %C = xor i8 %B, 13 125 %D = or i8 %C, 1 126 %E = xor i8 %D, 12 127 ret i8 %E 128} 129 130define i8 @test11v(<2 x i8> %A) { 131; CHECK-LABEL: @test11v( 132; CHECK-NEXT: [[B:%.*]] = or <2 x i8> [[A:%.*]], <i8 -2, i8 0> 133; CHECK-NEXT: [[CV:%.*]] = xor <2 x i8> [[B]], <i8 13, i8 13> 134; CHECK-NEXT: [[C:%.*]] = extractelement <2 x i8> [[CV]], i32 0 135; CHECK-NEXT: [[D:%.*]] = or i8 [[C]], 1 136; CHECK-NEXT: [[E:%.*]] = xor i8 [[D]], 12 137; CHECK-NEXT: ret i8 [[E]] 138; 139 %B = or <2 x i8> %A, <i8 -2, i8 0> 140 %CV = xor <2 x i8> %B, <i8 13, i8 13> 141 %C = extractelement <2 x i8> %CV, i32 0 142 %D = or i8 %C, 1 143 %E = xor i8 %D, 12 144 ret i8 %E 145} 146 147; Test the case where integer BitWidth <= 64 && BitWidth % 2 != 0. 148; If we have: ((V + N) & C1) | (V & C2) 149; .. and C2 = ~C1 and C2 is 0+1+ and (N & C2) == 0 150; replace with V+N. 151define i39 @test1_apint(i39 %V, i39 %M) { 152; CHECK-LABEL: @test1_apint( 153; CHECK-NEXT: [[N:%.*]] = and i39 [[M:%.*]], -274877906944 154; CHECK-NEXT: [[A:%.*]] = add i39 [[V:%.*]], [[N]] 155; CHECK-NEXT: ret i39 [[A]] 156; 157 %C1 = xor i39 274877906943, -1 ;; C2 = 274877906943 158 %N = and i39 %M, 274877906944 159 %A = add i39 %V, %N 160 %B = and i39 %A, %C1 161 %D = and i39 %V, 274877906943 162 %R = or i39 %B, %D 163 ret i39 %R 164} 165 166define i7 @test2_apint(i7 %X) { 167; CHECK-LABEL: @test2_apint( 168; CHECK-NEXT: ret i7 [[X:%.*]] 169; 170 %Y = or i7 %X, 0 171 ret i7 %Y 172} 173 174define i17 @test3_apint(i17 %X) { 175; CHECK-LABEL: @test3_apint( 176; CHECK-NEXT: ret i17 -1 177; 178 %Y = or i17 %X, -1 179 ret i17 %Y 180} 181 182; Test the case where Integer BitWidth > 64 && BitWidth <= 1024. 183; If we have: ((V + N) & C1) | (V & C2) 184; .. and C2 = ~C1 and C2 is 0+1+ and (N & C2) == 0 185; replace with V+N. 186define i399 @test4_apint(i399 %V, i399 %M) { 187; CHECK-LABEL: @test4_apint( 188; CHECK-NEXT: [[N:%.*]] = and i399 [[M:%.*]], 18446742974197923840 189; CHECK-NEXT: [[A:%.*]] = add i399 [[V:%.*]], [[N]] 190; CHECK-NEXT: ret i399 [[A]] 191; 192 %C1 = xor i399 274877906943, -1 ;; C2 = 274877906943 193 %N = and i399 %M, 18446742974197923840 194 %A = add i399 %V, %N 195 %B = and i399 %A, %C1 196 %D = and i399 %V, 274877906943 197 %R = or i399 %D, %B 198 ret i399 %R 199} 200 201define i777 @test5_apint(i777 %X) { 202; CHECK-LABEL: @test5_apint( 203; CHECK-NEXT: ret i777 [[X:%.*]] 204; 205 %Y = or i777 %X, 0 206 ret i777 %Y 207} 208 209define i117 @test6_apint(i117 %X) { 210; CHECK-LABEL: @test6_apint( 211; CHECK-NEXT: ret i117 -1 212; 213 %Y = or i117 %X, -1 214 ret i117 %Y 215} 216 217; Test the case where integer BitWidth <= 64 && BitWidth % 2 != 0. 218; Vector version of test1_apint with the add commuted 219; If we have: ((V + N) & C1) | (V & C2) 220; .. and C2 = ~C1 and C2 is 0+1+ and (N & C2) == 0 221; replace with V+N. 222define <2 x i39> @test7_apint(<2 x i39> %V, <2 x i39> %M) { 223; CHECK-LABEL: @test7_apint( 224; CHECK-NEXT: [[N:%.*]] = and <2 x i39> [[M:%.*]], <i39 -274877906944, i39 -274877906944> 225; CHECK-NEXT: [[A:%.*]] = add <2 x i39> [[N]], [[V:%.*]] 226; CHECK-NEXT: ret <2 x i39> [[A]] 227; 228 %C1 = xor <2 x i39> <i39 274877906943, i39 274877906943>, <i39 -1, i39 -1> ;; C2 = 274877906943 229 %N = and <2 x i39> %M, <i39 274877906944, i39 274877906944> 230 %A = add <2 x i39> %N, %V 231 %B = and <2 x i39> %A, %C1 232 %D = and <2 x i39> %V, <i39 274877906943, i39 274877906943> 233 %R = or <2 x i39> %B, %D 234 ret <2 x i39> %R 235} 236 237; Test the case where Integer BitWidth > 64 && BitWidth <= 1024. 238; Vector version of test4_apint with the add and the or commuted 239; If we have: ((V + N) & C1) | (V & C2) 240; .. and C2 = ~C1 and C2 is 0+1+ and (N & C2) == 0 241; replace with V+N. 242define <2 x i399> @test8_apint(<2 x i399> %V, <2 x i399> %M) { 243; CHECK-LABEL: @test8_apint( 244; CHECK-NEXT: [[N:%.*]] = and <2 x i399> [[M:%.*]], <i399 18446742974197923840, i399 18446742974197923840> 245; CHECK-NEXT: [[A:%.*]] = add <2 x i399> [[N]], [[V:%.*]] 246; CHECK-NEXT: ret <2 x i399> [[A]] 247; 248 %C1 = xor <2 x i399> <i399 274877906943, i399 274877906943>, <i399 -1, i399 -1> ;; C2 = 274877906943 249 %N = and <2 x i399> %M, <i399 18446742974197923840, i399 18446742974197923840> 250 %A = add <2 x i399> %N, %V 251 %B = and <2 x i399> %A, %C1 252 %D = and <2 x i399> %V, <i399 274877906943, i399 274877906943> 253 %R = or <2 x i399> %D, %B 254 ret <2 x i399> %R 255} 256 257; (A & B) | A = A 258 259define i8 @or_and_common_op_commute0(i8 %a, i8 %b) { 260; CHECK-LABEL: @or_and_common_op_commute0( 261; CHECK-NEXT: ret i8 [[A:%.*]] 262; 263 %and = and i8 %a, %b 264 %or = or i8 %and, %a 265 ret i8 %or 266} 267 268define <2 x i8> @or_and_common_op_commute1(<2 x i8> %a, <2 x i8> %b) { 269; CHECK-LABEL: @or_and_common_op_commute1( 270; CHECK-NEXT: ret <2 x i8> [[A:%.*]] 271; 272 %and = and <2 x i8> %b, %a 273 %or = or <2 x i8> %and, %a 274 ret <2 x i8> %or 275} 276 277define i8 @or_and_common_op_commute2(i8 %a, i8 %b) { 278; CHECK-LABEL: @or_and_common_op_commute2( 279; CHECK-NEXT: ret i8 [[A:%.*]] 280; 281 %and = and i8 %a, %b 282 %or = or i8 %a, %and 283 ret i8 %or 284} 285 286define <2 x i8> @or_and_common_op_commute3(<2 x i8> %a, <2 x i8> %b) { 287; CHECK-LABEL: @or_and_common_op_commute3( 288; CHECK-NEXT: ret <2 x i8> [[A:%.*]] 289; 290 %and = and <2 x i8> %b, %a 291 %or = or <2 x i8> %a, %and 292 ret <2 x i8> %or 293} 294 295; A | ~(A & B) = -1 296 297define i1 @or_with_not_op_commute1(i1 %a, i1 %b) { 298; CHECK-LABEL: @or_with_not_op_commute1( 299; CHECK-NEXT: ret i1 true 300; 301 %ab = and i1 %a, %b 302 %not = xor i1 %ab, -1 303 %r = or i1 %a, %not 304 ret i1 %r 305} 306 307; A | ~(B & A) = -1 308 309define i8 @or_with_not_op_commute2(i8 %a, i8 %b) { 310; CHECK-LABEL: @or_with_not_op_commute2( 311; CHECK-NEXT: ret i8 -1 312; 313 %ab = and i8 %b, %a 314 %not = xor i8 %ab, -1 315 %r = or i8 %a, %not 316 ret i8 %r 317} 318 319; ~(A & B) | A = -1 320 321define <3 x i17> @or_with_not_op_commute3(<3 x i17> %a, <3 x i17> %b) { 322; CHECK-LABEL: @or_with_not_op_commute3( 323; CHECK-NEXT: ret <3 x i17> <i17 -1, i17 -1, i17 -1> 324; 325 %ab = and <3 x i17> %a, %b 326 %not = xor <3 x i17> %ab, <i17 -1, i17 -1, i17 -1> 327 %r = or <3 x i17> %not, %a 328 ret <3 x i17> %r 329} 330 331; ~(B & A) | A = -1 332 333define <2 x i1> @or_with_not_op_commute4(<2 x i1> %a, <2 x i1> %b) { 334; CHECK-LABEL: @or_with_not_op_commute4( 335; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true> 336; 337 %ab = and <2 x i1> %b, %a 338 %not = xor <2 x i1> %ab, <i1 -1, i1 undef> 339 %r = or <2 x i1> %not, %a 340 ret <2 x i1> %r 341} 342 343define i32 @poison(i32 %x) { 344; CHECK-LABEL: @poison( 345; CHECK-NEXT: ret i32 poison 346; 347 %v = or i32 %x, poison 348 ret i32 %v 349} 350 351; (~A & B) | ~(A | B) --> ~A 352 353define i4 @and_or_not_or_commute0(i4 %A, i4 %B) { 354; CHECK-LABEL: @and_or_not_or_commute0( 355; CHECK-NEXT: [[NOTA:%.*]] = xor i4 [[A:%.*]], -1 356; CHECK-NEXT: ret i4 [[NOTA]] 357; 358 %nota = xor i4 %A, -1 359 %and = and i4 %nota, %B 360 %or = or i4 %A, %B 361 %notab = xor i4 %or, -1 362 %r = or i4 %and, %notab 363 ret i4 %r 364} 365 366define i41 @and_or_not_or_commute1(i41 %A, i41 %B) { 367; CHECK-LABEL: @and_or_not_or_commute1( 368; CHECK-NEXT: [[NOTA:%.*]] = xor i41 [[A:%.*]], -1 369; CHECK-NEXT: ret i41 [[NOTA]] 370; 371 %nota = xor i41 %A, -1 372 %and = and i41 %B, %nota 373 %or = or i41 %A, %B 374 %notab = xor i41 %or, -1 375 %r = or i41 %and, %notab 376 ret i41 %r 377} 378 379define i8 @and_or_not_or_commute2(i8 %A, i8 %B) { 380; CHECK-LABEL: @and_or_not_or_commute2( 381; CHECK-NEXT: [[NOTA:%.*]] = xor i8 [[A:%.*]], -1 382; CHECK-NEXT: ret i8 [[NOTA]] 383; 384 %nota = xor i8 %A, -1 385 %and = and i8 %nota, %B 386 %or = or i8 %B, %A 387 %notab = xor i8 %or, -1 388 %r = or i8 %and, %notab 389 ret i8 %r 390} 391 392define <2 x i4> @and_or_not_or_commute3(<2 x i4> %A, <2 x i4> %B) { 393; CHECK-LABEL: @and_or_not_or_commute3( 394; CHECK-NEXT: [[NOTA:%.*]] = xor <2 x i4> [[A:%.*]], <i4 -1, i4 -1> 395; CHECK-NEXT: ret <2 x i4> [[NOTA]] 396; 397 %nota = xor <2 x i4> %A, <i4 -1, i4 -1> 398 %and = and <2 x i4> %B, %nota 399 %or = or <2 x i4> %B, %A 400 %notab = xor <2 x i4> %or, <i4 -1, i4 -1> 401 %r = or <2 x i4> %and, %notab 402 ret <2 x i4> %r 403} 404 405define i4 @and_or_not_or_commute4(i4 %A, i4 %B) { 406; CHECK-LABEL: @and_or_not_or_commute4( 407; CHECK-NEXT: [[NOTA:%.*]] = xor i4 [[A:%.*]], -1 408; CHECK-NEXT: ret i4 [[NOTA]] 409; 410 %nota = xor i4 %A, -1 411 %and = and i4 %nota, %B 412 %or = or i4 %A, %B 413 %notab = xor i4 %or, -1 414 %r = or i4 %notab, %and 415 ret i4 %r 416} 417 418define i41 @and_or_not_or_commute5(i41 %A, i41 %B) { 419; CHECK-LABEL: @and_or_not_or_commute5( 420; CHECK-NEXT: [[NOTA:%.*]] = xor i41 [[A:%.*]], -1 421; CHECK-NEXT: ret i41 [[NOTA]] 422; 423 %nota = xor i41 %A, -1 424 %and = and i41 %B, %nota 425 %or = or i41 %A, %B 426 %notab = xor i41 %or, -1 427 %r = or i41 %notab, %and 428 ret i41 %r 429} 430 431define i8 @and_or_not_or_commute6(i8 %A, i8 %B) { 432; CHECK-LABEL: @and_or_not_or_commute6( 433; CHECK-NEXT: [[NOTA:%.*]] = xor i8 [[A:%.*]], -1 434; CHECK-NEXT: ret i8 [[NOTA]] 435; 436 %nota = xor i8 %A, -1 437 %and = and i8 %nota, %B 438 %or = or i8 %B, %A 439 %notab = xor i8 %or, -1 440 %r = or i8 %notab, %and 441 ret i8 %r 442} 443 444define <2 x i4> @and_or_not_or_commute7(<2 x i4> %A, <2 x i4> %B) { 445; CHECK-LABEL: @and_or_not_or_commute7( 446; CHECK-NEXT: [[NOTA:%.*]] = xor <2 x i4> [[A:%.*]], <i4 -1, i4 -1> 447; CHECK-NEXT: ret <2 x i4> [[NOTA]] 448; 449 %nota = xor <2 x i4> %A, <i4 -1, i4 -1> 450 %and = and <2 x i4> %B, %nota 451 %or = or <2 x i4> %B, %A 452 %notab = xor <2 x i4> %or, <i4 -1, i4 -1> 453 %r = or <2 x i4> %notab, %and 454 ret <2 x i4> %r 455} 456 457; negative test - It is not safe to propagate an undef element from the 'not' op. 458 459define <2 x i4> @and_or_not_or_commute7_undef_elt(<2 x i4> %A, <2 x i4> %B) { 460; CHECK-LABEL: @and_or_not_or_commute7_undef_elt( 461; CHECK-NEXT: [[NOTA:%.*]] = xor <2 x i4> [[A:%.*]], <i4 undef, i4 -1> 462; CHECK-NEXT: [[AND:%.*]] = and <2 x i4> [[B:%.*]], [[NOTA]] 463; CHECK-NEXT: [[OR:%.*]] = or <2 x i4> [[B]], [[A]] 464; CHECK-NEXT: [[NOTAB:%.*]] = xor <2 x i4> [[OR]], <i4 -1, i4 -1> 465; CHECK-NEXT: [[R:%.*]] = or <2 x i4> [[NOTAB]], [[AND]] 466; CHECK-NEXT: ret <2 x i4> [[R]] 467; 468 %nota = xor <2 x i4> %A, <i4 undef, i4 -1> 469 %and = and <2 x i4> %B, %nota 470 %or = or <2 x i4> %B, %A 471 %notab = xor <2 x i4> %or, <i4 -1, i4 -1> 472 %r = or <2 x i4> %notab, %and 473 ret <2 x i4> %r 474} 475 476; (A | B) | (A ^ B) --> A | B 477 478define i69 @or_or_xor(i69 %A, i69 %B) { 479; CHECK-LABEL: @or_or_xor( 480; CHECK-NEXT: [[I1:%.*]] = or i69 [[A:%.*]], [[B:%.*]] 481; CHECK-NEXT: ret i69 [[I1]] 482; 483 %i1 = or i69 %A, %B 484 %i2 = xor i69 %A, %B 485 %i3 = or i69 %i1, %i2 486 ret i69 %i3 487} 488 489; (B | A) | (A ^ B) --> B | A 490 491define i8 @or_or_xor_inner_or_commuted(i8 %A, i8 %B) { 492; CHECK-LABEL: @or_or_xor_inner_or_commuted( 493; CHECK-NEXT: [[I1:%.*]] = or i8 [[B:%.*]], [[A:%.*]] 494; CHECK-NEXT: ret i8 [[I1]] 495; 496 %i1 = or i8 %B, %A 497 %i2 = xor i8 %A, %B 498 %i3 = or i8 %i1, %i2 499 ret i8 %i3 500} 501 502; (A ^ B) | (A | B) --> A | B 503 504define <4 x i4> @or_or_xor_commuted(<4 x i4> %A, <4 x i4> %B) { 505; CHECK-LABEL: @or_or_xor_commuted( 506; CHECK-NEXT: [[I1:%.*]] = or <4 x i4> [[A:%.*]], [[B:%.*]] 507; CHECK-NEXT: ret <4 x i4> [[I1]] 508; 509 %i1 = or <4 x i4> %A, %B 510 %i2 = xor <4 x i4> %A, %B 511 %i3 = or <4 x i4> %i2, %i1 512 ret <4 x i4> %i3 513} 514 515; (A ^ B) | (B | A) --> B | A 516 517define i4 @or_or_xor_inner_or_outer_or_commuted(i4 %A, i4 %B) { 518; CHECK-LABEL: @or_or_xor_inner_or_outer_or_commuted( 519; CHECK-NEXT: [[I1:%.*]] = or i4 [[B:%.*]], [[A:%.*]] 520; CHECK-NEXT: ret i4 [[I1]] 521; 522 %i1 = or i4 %B, %A 523 %i2 = xor i4 %A, %B 524 %i3 = or i4 %i2, %i1 525 ret i4 %i3 526} 527 528define i32 @shifted_all_ones(i32 %shamt) { 529; CHECK-LABEL: @shifted_all_ones( 530; CHECK-NEXT: ret i32 -1 531; 532 %r = lshr i32 -1, %shamt 533 %s = sub i32 32, %shamt 534 %l = shl i32 -1, %s 535 %o = or i32 %r, %l 536 ret i32 %o 537} 538 539; Sub from less than bitwidth is ok (overlapping ones). 540 541define i32 @shifted_all_ones_commute(i32 %shamt) { 542; CHECK-LABEL: @shifted_all_ones_commute( 543; CHECK-NEXT: ret i32 -1 544; 545 %r = lshr i32 -1, %shamt 546 %s = sub i32 31, %shamt 547 %l = shl i32 -1, %s 548 %o = or i32 %l, %r 549 ret i32 %o 550} 551 552define <2 x i9> @shifted_all_ones_sub_on_lshr(<2 x i9> %shamt) { 553; CHECK-LABEL: @shifted_all_ones_sub_on_lshr( 554; CHECK-NEXT: ret <2 x i9> <i9 -1, i9 -1> 555; 556 %l = shl <2 x i9> <i9 -1, i9 -1>, %shamt 557 %s = sub <2 x i9> <i9 5, i9 5>, %shamt 558 %r = lshr <2 x i9> <i9 -1, i9 -1>, %s 559 %o = or <2 x i9> %l, %r 560 ret <2 x i9> %o 561} 562 563define i8 @shifted_all_ones_sub_on_lshr_commute(i8 %shamt) { 564; CHECK-LABEL: @shifted_all_ones_sub_on_lshr_commute( 565; CHECK-NEXT: ret i8 -1 566; 567 %l = shl i8 -1, %shamt 568 %s = sub i8 8, %shamt 569 %r = lshr i8 -1, %s 570 %o = or i8 %r, %l 571 ret i8 %o 572} 573 574; negative test - need -1 in general case 575 576define i32 @shifted_not_all_ones(i32 %shamt) { 577; CHECK-LABEL: @shifted_not_all_ones( 578; CHECK-NEXT: [[R:%.*]] = lshr i32 -2, [[SHAMT:%.*]] 579; CHECK-NEXT: [[S:%.*]] = sub i32 31, [[SHAMT]] 580; CHECK-NEXT: [[L:%.*]] = shl i32 -1, [[S]] 581; CHECK-NEXT: [[O:%.*]] = or i32 [[R]], [[L]] 582; CHECK-NEXT: ret i32 [[O]] 583; 584 %r = lshr i32 -2, %shamt 585 %s = sub i32 31, %shamt 586 %l = shl i32 -1, %s 587 %o = or i32 %r, %l 588 ret i32 %o 589} 590 591; negative test - opposite shift amount may be too big 592 593define i32 @shifted_all_ones_greater_than_bitwidth(i32 %shamt) { 594; CHECK-LABEL: @shifted_all_ones_greater_than_bitwidth( 595; CHECK-NEXT: [[R:%.*]] = lshr i32 -1, [[SHAMT:%.*]] 596; CHECK-NEXT: [[S:%.*]] = sub i32 33, [[SHAMT]] 597; CHECK-NEXT: [[L:%.*]] = shl i32 -1, [[S]] 598; CHECK-NEXT: [[O:%.*]] = or i32 [[R]], [[L]] 599; CHECK-NEXT: ret i32 [[O]] 600; 601 %r = lshr i32 -1, %shamt 602 %s = sub i32 33, %shamt 603 %l = shl i32 -1, %s 604 %o = or i32 %r, %l 605 ret i32 %o 606} 607 608; negative test - shift amount must be derived from same base 609 610define i32 @shifted_all_ones_not_same_amt(i32 %shamt, i32 %other) { 611; CHECK-LABEL: @shifted_all_ones_not_same_amt( 612; CHECK-NEXT: [[R:%.*]] = lshr i32 -1, [[SHAMT:%.*]] 613; CHECK-NEXT: [[S:%.*]] = sub i32 32, [[OTHER:%.*]] 614; CHECK-NEXT: [[L:%.*]] = shl i32 -1, [[S]] 615; CHECK-NEXT: [[O:%.*]] = or i32 [[R]], [[L]] 616; CHECK-NEXT: ret i32 [[O]] 617; 618 %r = lshr i32 -1, %shamt 619 %s = sub i32 32, %other 620 %l = shl i32 -1, %s 621 %o = or i32 %r, %l 622 ret i32 %o 623} 624 625; (A & B) | ~(A ^ B) --> ~(A ^ B) 626 627define i4 @or_nxor_and_commute0(i4 %a, i4 %b) { 628; CHECK-LABEL: @or_nxor_and_commute0( 629; CHECK-NEXT: [[XOR:%.*]] = xor i4 [[A:%.*]], [[B:%.*]] 630; CHECK-NEXT: [[NOT:%.*]] = xor i4 [[XOR]], -1 631; CHECK-NEXT: ret i4 [[NOT]] 632; 633 %and = and i4 %a, %b 634 %xor = xor i4 %a, %b 635 %not = xor i4 %xor, -1 636 %r = or i4 %and, %not 637 ret i4 %r 638} 639 640define <2 x i4> @or_nxor_and_commute1(<2 x i4> %a, <2 x i4> %b) { 641; CHECK-LABEL: @or_nxor_and_commute1( 642; CHECK-NEXT: [[XOR:%.*]] = xor <2 x i4> [[A:%.*]], [[B:%.*]] 643; CHECK-NEXT: [[NOT:%.*]] = xor <2 x i4> [[XOR]], <i4 -1, i4 -1> 644; CHECK-NEXT: ret <2 x i4> [[NOT]] 645; 646 %and = and <2 x i4> %a, %b 647 %xor = xor <2 x i4> %a, %b 648 %not = xor <2 x i4> %xor, <i4 -1, i4 -1> 649 %r = or <2 x i4> %not, %and 650 ret <2 x i4> %r 651} 652 653define i74 @or_nxor_and_commute2(i74 %a, i74 %b) { 654; CHECK-LABEL: @or_nxor_and_commute2( 655; CHECK-NEXT: [[XOR:%.*]] = xor i74 [[A:%.*]], [[B:%.*]] 656; CHECK-NEXT: [[NOT:%.*]] = xor i74 [[XOR]], -1 657; CHECK-NEXT: ret i74 [[NOT]] 658; 659 %and = and i74 %b, %a 660 %xor = xor i74 %a, %b 661 %not = xor i74 %xor, -1 662 %r = or i74 %and, %not 663 ret i74 %r 664} 665 666define <2 x i4> @or_nxor_and_commute3(<2 x i4> %a, <2 x i4> %b) { 667; CHECK-LABEL: @or_nxor_and_commute3( 668; CHECK-NEXT: [[XOR:%.*]] = xor <2 x i4> [[A:%.*]], [[B:%.*]] 669; CHECK-NEXT: [[NOT:%.*]] = xor <2 x i4> [[XOR]], <i4 -1, i4 -1> 670; CHECK-NEXT: ret <2 x i4> [[NOT]] 671; 672 %and = and <2 x i4> %b, %a 673 %xor = xor <2 x i4> %a, %b 674 %not = xor <2 x i4> %xor, <i4 -1, i4 -1> 675 %r = or <2 x i4> %not, %and 676 ret <2 x i4> %r 677} 678 679; negative test - must have common operands 680 681define i4 @or_nxor_and_wrong_val1(i4 %a, i4 %b, i4 %c) { 682; CHECK-LABEL: @or_nxor_and_wrong_val1( 683; CHECK-NEXT: [[AND:%.*]] = and i4 [[A:%.*]], [[C:%.*]] 684; CHECK-NEXT: [[XOR:%.*]] = xor i4 [[A]], [[B:%.*]] 685; CHECK-NEXT: [[NOT:%.*]] = xor i4 [[XOR]], -1 686; CHECK-NEXT: [[R:%.*]] = or i4 [[AND]], [[NOT]] 687; CHECK-NEXT: ret i4 [[R]] 688; 689 %and = and i4 %a, %c 690 %xor = xor i4 %a, %b 691 %not = xor i4 %xor, -1 692 %r = or i4 %and, %not 693 ret i4 %r 694} 695 696; negative test - must have common operands 697 698define i4 @or_nxor_and_wrong_val2(i4 %a, i4 %b, i4 %c) { 699; CHECK-LABEL: @or_nxor_and_wrong_val2( 700; CHECK-NEXT: [[AND:%.*]] = and i4 [[C:%.*]], [[B:%.*]] 701; CHECK-NEXT: [[XOR:%.*]] = xor i4 [[A:%.*]], [[B]] 702; CHECK-NEXT: [[NOT:%.*]] = xor i4 [[XOR]], -1 703; CHECK-NEXT: [[R:%.*]] = or i4 [[AND]], [[NOT]] 704; CHECK-NEXT: ret i4 [[R]] 705; 706 %and = and i4 %c, %b 707 %xor = xor i4 %a, %b 708 %not = xor i4 %xor, -1 709 %r = or i4 %and, %not 710 ret i4 %r 711} 712 713; negative test - undef in 'not' is allowed 714 715define <2 x i4> @or_nxor_and_undef_elt(<2 x i4> %a, <2 x i4> %b) { 716; CHECK-LABEL: @or_nxor_and_undef_elt( 717; CHECK-NEXT: [[AND:%.*]] = and <2 x i4> [[B:%.*]], [[A:%.*]] 718; CHECK-NEXT: [[XOR:%.*]] = xor <2 x i4> [[A]], [[B]] 719; CHECK-NEXT: [[NOT:%.*]] = xor <2 x i4> [[XOR]], <i4 -1, i4 undef> 720; CHECK-NEXT: [[R:%.*]] = or <2 x i4> [[NOT]], [[AND]] 721; CHECK-NEXT: ret <2 x i4> [[R]] 722; 723 %and = and <2 x i4> %b, %a 724 %xor = xor <2 x i4> %a, %b 725 %not = xor <2 x i4> %xor, <i4 -1, i4 undef> 726 %r = or <2 x i4> %not, %and 727 ret <2 x i4> %r 728} 729 730; ~(A ^ B) | (A | B) --> -1 731 732define i4 @or_nxor_or_commute0(i4 %a, i4 %b) { 733; CHECK-LABEL: @or_nxor_or_commute0( 734; CHECK-NEXT: ret i4 -1 735; 736 %or = or i4 %a, %b 737 %xor = xor i4 %a, %b 738 %not = xor i4 %xor, -1 739 %r = or i4 %not, %or 740 ret i4 %r 741} 742 743define <2 x i4> @or_nxor_or_commute1(<2 x i4> %a, <2 x i4> %b) { 744; CHECK-LABEL: @or_nxor_or_commute1( 745; CHECK-NEXT: ret <2 x i4> <i4 -1, i4 -1> 746; 747 %or = or <2 x i4> %a, %b 748 %xor = xor <2 x i4> %a, %b 749 %not = xor <2 x i4> %xor, <i4 -1, i4 -1> 750 %r = or <2 x i4> %or, %not 751 ret <2 x i4> %r 752} 753 754define i74 @or_nxor_or_commute2(i74 %a, i74 %b) { 755; CHECK-LABEL: @or_nxor_or_commute2( 756; CHECK-NEXT: ret i74 -1 757; 758 %or = or i74 %b, %a 759 %xor = xor i74 %a, %b 760 %not = xor i74 %xor, -1 761 %r = or i74 %not, %or 762 ret i74 %r 763} 764 765define <2 x i4> @or_nxor_or_commute3(<2 x i4> %a, <2 x i4> %b) { 766; CHECK-LABEL: @or_nxor_or_commute3( 767; CHECK-NEXT: ret <2 x i4> <i4 -1, i4 -1> 768; 769 %or = or <2 x i4> %b, %a 770 %xor = xor <2 x i4> %a, %b 771 %not = xor <2 x i4> %xor, <i4 -1, i4 -1> 772 %r = or <2 x i4> %or, %not 773 ret <2 x i4> %r 774} 775 776; negative test - must have common operands 777 778define i4 @or_nxor_or_wrong_val1(i4 %a, i4 %b, i4 %c) { 779; CHECK-LABEL: @or_nxor_or_wrong_val1( 780; CHECK-NEXT: [[OR:%.*]] = or i4 [[A:%.*]], [[C:%.*]] 781; CHECK-NEXT: [[XOR:%.*]] = xor i4 [[A]], [[B:%.*]] 782; CHECK-NEXT: [[NOT:%.*]] = xor i4 [[XOR]], -1 783; CHECK-NEXT: [[R:%.*]] = or i4 [[NOT]], [[OR]] 784; CHECK-NEXT: ret i4 [[R]] 785; 786 %or = or i4 %a, %c 787 %xor = xor i4 %a, %b 788 %not = xor i4 %xor, -1 789 %r = or i4 %not, %or 790 ret i4 %r 791} 792 793; negative test - must have common operands 794 795define i4 @or_nxor_or_wrong_val2(i4 %a, i4 %b, i4 %c) { 796; CHECK-LABEL: @or_nxor_or_wrong_val2( 797; CHECK-NEXT: [[OR:%.*]] = or i4 [[C:%.*]], [[B:%.*]] 798; CHECK-NEXT: [[XOR:%.*]] = xor i4 [[A:%.*]], [[B]] 799; CHECK-NEXT: [[NOT:%.*]] = xor i4 [[XOR]], -1 800; CHECK-NEXT: [[R:%.*]] = or i4 [[NOT]], [[OR]] 801; CHECK-NEXT: ret i4 [[R]] 802; 803 %or = or i4 %c, %b 804 %xor = xor i4 %a, %b 805 %not = xor i4 %xor, -1 806 %r = or i4 %not, %or 807 ret i4 %r 808} 809 810; negative test - undef in 'not' is allowed 811 812define <2 x i4> @or_nxor_or_undef_elt(<2 x i4> %a, <2 x i4> %b) { 813; CHECK-LABEL: @or_nxor_or_undef_elt( 814; CHECK-NEXT: ret <2 x i4> <i4 -1, i4 -1> 815; 816 %or = or <2 x i4> %b, %a 817 %xor = xor <2 x i4> %a, %b 818 %not = xor <2 x i4> %xor, <i4 -1, i4 undef> 819 %r = or <2 x i4> %or, %not 820 ret <2 x i4> %r 821} 822 823; (A ^ B) | (~A | B) --> -1 824 825define i4 @or_xor_not_op_or(i4 %a, i4 %b){ 826; CHECK-LABEL: @or_xor_not_op_or( 827; CHECK-NEXT: ret i4 -1 828; 829 %xor = xor i4 %a, %b 830 %nota = xor i4 %a, -1 831 %or = or i4 %nota, %b 832 %r = or i4 %xor, %or 833 ret i4 %r 834} 835 836; (A ^ B) | (B | ~A) --> -1 837 838define i71 @or_xor_not_op_or_commute1(i71 %a, i71 %b){ 839; CHECK-LABEL: @or_xor_not_op_or_commute1( 840; CHECK-NEXT: ret i71 -1 841; 842 %xor = xor i71 %a, %b 843 %nota = xor i71 %a, -1 844 %or = or i71 %b, %nota 845 %r = or i71 %xor, %or 846 ret i71 %r 847} 848 849; (B ^ A) | (~A | B) --> -1 850 851define i32 @or_xor_not_op_or_commute2(i32 %a, i32 %b){ 852; CHECK-LABEL: @or_xor_not_op_or_commute2( 853; CHECK-NEXT: ret i32 -1 854; 855 %xor = xor i32 %b, %a 856 %nota = xor i32 %a, -1 857 %or = or i32 %nota, %b 858 %r = or i32 %xor, %or 859 ret i32 %r 860} 861 862; (B ^ A) | (B | ~A) --> -1 863 864define i32 @or_xor_not_op_or_commute3(i32 %a, i32 %b){ 865; CHECK-LABEL: @or_xor_not_op_or_commute3( 866; CHECK-NEXT: ret i32 -1 867; 868 %xor = xor i32 %b, %a 869 %nota = xor i32 %a, -1 870 %or = or i32 %b, %nota 871 %r = or i32 %xor, %or 872 ret i32 %r 873} 874 875; (~A | B) | (A ^ B) --> -1 876 877define i32 @or_xor_not_op_or_commute4(i32 %a, i32 %b){ 878; CHECK-LABEL: @or_xor_not_op_or_commute4( 879; CHECK-NEXT: ret i32 -1 880; 881 %xor = xor i32 %a, %b 882 %nota = xor i32 %a, -1 883 %or = or i32 %nota, %b 884 %r = or i32 %or, %xor 885 ret i32 %r 886} 887 888; (B | ~A) | (A ^ B) --> -1 889 890define i32 @or_xor_not_op_or_commute5(i32 %a, i32 %b){ 891; CHECK-LABEL: @or_xor_not_op_or_commute5( 892; CHECK-NEXT: ret i32 -1 893; 894 %xor = xor i32 %a, %b 895 %nota = xor i32 %a, -1 896 %or = or i32 %b, %nota 897 %r = or i32 %or, %xor 898 ret i32 %r 899} 900 901; (~A | B) | (B ^ A) --> -1 902 903define i32 @or_xor_not_op_or_commute6(i32 %a, i32 %b){ 904; CHECK-LABEL: @or_xor_not_op_or_commute6( 905; CHECK-NEXT: ret i32 -1 906; 907 %xor = xor i32 %b, %a 908 %nota = xor i32 %a, -1 909 %or = or i32 %nota, %b 910 %r = or i32 %or, %xor 911 ret i32 %r 912} 913 914; (B | ~A) | (B ^ A) --> -1 915 916define i32 @or_xor_not_op_or_commute7(i32 %a, i32 %b){ 917; CHECK-LABEL: @or_xor_not_op_or_commute7( 918; CHECK-NEXT: ret i32 -1 919; 920 %xor = xor i32 %b, %a 921 %nota = xor i32 %a, -1 922 %or = or i32 %b, %nota 923 %r = or i32 %or, %xor 924 ret i32 %r 925} 926 927define <2 x i4> @or_xor_not_op_or_undef_elt(<2 x i4> %a, <2 x i4> %b) { 928; CHECK-LABEL: @or_xor_not_op_or_undef_elt( 929; CHECK-NEXT: ret <2 x i4> <i4 -1, i4 -1> 930; 931 %xor = xor <2 x i4> %a, %b 932 %nota = xor <2 x i4> %a, <i4 -1, i4 undef> 933 %or = or <2 x i4> %nota, %b 934 %r = or <2 x i4> %xor, %or 935 ret <2 x i4> %r 936} 937 938; negative test 939 940define i16 @or_xor_not_op_or_wrong_val(i16 %a, i16 %b, i16 %c) { 941; CHECK-LABEL: @or_xor_not_op_or_wrong_val( 942; CHECK-NEXT: [[XOR:%.*]] = xor i16 [[A:%.*]], [[C:%.*]] 943; CHECK-NEXT: [[NOTA:%.*]] = xor i16 [[A]], -1 944; CHECK-NEXT: [[OR:%.*]] = or i16 [[NOTA]], [[B:%.*]] 945; CHECK-NEXT: [[R:%.*]] = or i16 [[XOR]], [[OR]] 946; CHECK-NEXT: ret i16 [[R]] 947; 948 %xor = xor i16 %a, %c 949 %nota = xor i16 %a, -1 950 %or = or i16 %nota, %b 951 %r = or i16 %xor, %or 952 ret i16 %r 953} 954 955; ~(x & y) | (x ^ y) --> ~(x & y) 956 957define i4 @or_nand_xor(i4 %x, i4 %y) { 958; CHECK-LABEL: @or_nand_xor( 959; CHECK-NEXT: [[AND:%.*]] = and i4 [[X:%.*]], [[Y:%.*]] 960; CHECK-NEXT: [[NAND:%.*]] = xor i4 [[AND]], -1 961; CHECK-NEXT: ret i4 [[NAND]] 962; 963 %and = and i4 %x, %y 964 %xor = xor i4 %x, %y 965 %nand = xor i4 %and, -1 966 %or = or i4 %xor, %nand 967 ret i4 %or 968} 969 970define <2 x i4> @or_nand_xor_commute1(<2 x i4> %x, <2 x i4> %y) { 971; CHECK-LABEL: @or_nand_xor_commute1( 972; CHECK-NEXT: [[AND:%.*]] = and <2 x i4> [[Y:%.*]], [[X:%.*]] 973; CHECK-NEXT: [[NAND:%.*]] = xor <2 x i4> [[AND]], <i4 -1, i4 -1> 974; CHECK-NEXT: ret <2 x i4> [[NAND]] 975; 976 %and = and <2 x i4> %y, %x 977 %xor = xor <2 x i4> %x, %y 978 %nand = xor <2 x i4> %and, <i4 -1, i4 -1> 979 %or = or <2 x i4> %xor, %nand 980 ret <2 x i4> %or 981} 982 983define i71 @or_nand_xor_commute2(i71 %x, i71 %y) { 984; CHECK-LABEL: @or_nand_xor_commute2( 985; CHECK-NEXT: [[AND:%.*]] = and i71 [[X:%.*]], [[Y:%.*]] 986; CHECK-NEXT: [[NAND:%.*]] = xor i71 [[AND]], -1 987; CHECK-NEXT: ret i71 [[NAND]] 988; 989 %and = and i71 %x, %y 990 %xor = xor i71 %x, %y 991 %nand = xor i71 %and, -1 992 %or = or i71 %nand, %xor 993 ret i71 %or 994} 995 996define i4 @or_nand_xor_commute3(i4 %x, i4 %y) { 997; CHECK-LABEL: @or_nand_xor_commute3( 998; CHECK-NEXT: [[AND:%.*]] = and i4 [[Y:%.*]], [[X:%.*]] 999; CHECK-NEXT: [[NAND:%.*]] = xor i4 [[AND]], -1 1000; CHECK-NEXT: ret i4 [[NAND]] 1001; 1002 %and = and i4 %y, %x 1003 %xor = xor i4 %x, %y 1004 %nand = xor i4 %and, -1 1005 %or = or i4 %nand, %xor 1006 ret i4 %or 1007} 1008 1009; negative test wrong operand 1010 1011define i4 @or_nand_xor_wrong_val(i4 %x, i4 %y, i4 %z) { 1012; CHECK-LABEL: @or_nand_xor_wrong_val( 1013; CHECK-NEXT: [[AND:%.*]] = and i4 [[X:%.*]], [[Y:%.*]] 1014; CHECK-NEXT: [[XOR:%.*]] = xor i4 [[X]], [[Z:%.*]] 1015; CHECK-NEXT: [[NAND:%.*]] = xor i4 [[AND]], -1 1016; CHECK-NEXT: [[OR:%.*]] = or i4 [[XOR]], [[NAND]] 1017; CHECK-NEXT: ret i4 [[OR]] 1018; 1019 %and = and i4 %x, %y 1020 %xor = xor i4 %x, %z 1021 %nand = xor i4 %and, -1 1022 %or = or i4 %xor, %nand 1023 ret i4 %or 1024} 1025 1026; negative test - undef element in 'not' is not allowed 1027 1028define <2 x i4> @or_nand_xor_undef_elt(<2 x i4> %x, <2 x i4> %y) { 1029; CHECK-LABEL: @or_nand_xor_undef_elt( 1030; CHECK-NEXT: [[AND:%.*]] = and <2 x i4> [[Y:%.*]], [[X:%.*]] 1031; CHECK-NEXT: [[XOR:%.*]] = xor <2 x i4> [[X]], [[Y]] 1032; CHECK-NEXT: [[NAND:%.*]] = xor <2 x i4> [[AND]], <i4 undef, i4 -1> 1033; CHECK-NEXT: [[OR:%.*]] = or <2 x i4> [[XOR]], [[NAND]] 1034; CHECK-NEXT: ret <2 x i4> [[OR]] 1035; 1036 %and = and <2 x i4> %y, %x 1037 %xor = xor <2 x i4> %x, %y 1038 %nand = xor <2 x i4> %and, <i4 undef, i4 -1> 1039 %or = or <2 x i4> %xor, %nand 1040 ret <2 x i4> %or 1041} 1042 1043declare i32 @llvm.fshl.i32 (i32, i32, i32) 1044declare i32 @llvm.fshr.i32 (i32, i32, i32) 1045 1046define i32 @or_shl_fshl(i32 %x, i32 %y, i32 %s) { 1047; CHECK-LABEL: @or_shl_fshl( 1048; CHECK-NEXT: [[FUN:%.*]] = call i32 @llvm.fshl.i32(i32 [[Y:%.*]], i32 [[X:%.*]], i32 [[S:%.*]]) 1049; CHECK-NEXT: ret i32 [[FUN]] 1050; 1051 %shy = shl i32 %y, %s 1052 %fun = call i32 @llvm.fshl.i32(i32 %y, i32 %x, i32 %s) 1053 %or = or i32 %fun, %shy 1054 ret i32 %or 1055} 1056 1057define i32 @or_shl_fshl_commute(i32 %x, i32 %y, i32 %s) { 1058; CHECK-LABEL: @or_shl_fshl_commute( 1059; CHECK-NEXT: [[FUN:%.*]] = call i32 @llvm.fshl.i32(i32 [[Y:%.*]], i32 [[X:%.*]], i32 [[S:%.*]]) 1060; CHECK-NEXT: ret i32 [[FUN]] 1061; 1062 %shy = shl i32 %y, %s 1063 %fun = call i32 @llvm.fshl.i32(i32 %y, i32 %x, i32 %s) 1064 %or = or i32 %shy, %fun 1065 ret i32 %or 1066} 1067 1068; negative test - fshl operands are not commutative 1069 1070define i32 @or_shl_fshl_wrong_order(i32 %x, i32 %y, i32 %s) { 1071; CHECK-LABEL: @or_shl_fshl_wrong_order( 1072; CHECK-NEXT: [[SHY:%.*]] = shl i32 [[Y:%.*]], [[S:%.*]] 1073; CHECK-NEXT: [[FUN:%.*]] = call i32 @llvm.fshl.i32(i32 [[X:%.*]], i32 [[Y]], i32 [[S]]) 1074; CHECK-NEXT: [[OR:%.*]] = or i32 [[FUN]], [[SHY]] 1075; CHECK-NEXT: ret i32 [[OR]] 1076; 1077 %shy = shl i32 %y, %s 1078 %fun = call i32 @llvm.fshl.i32(i32 %x, i32 %y, i32 %s) 1079 %or = or i32 %fun, %shy 1080 ret i32 %or 1081} 1082 1083define i32 @or_lshr_fshr(i32 %x, i32 %y, i32 %s) { 1084; CHECK-LABEL: @or_lshr_fshr( 1085; CHECK-NEXT: [[FUN:%.*]] = call i32 @llvm.fshr.i32(i32 [[X:%.*]], i32 [[Y:%.*]], i32 [[S:%.*]]) 1086; CHECK-NEXT: ret i32 [[FUN]] 1087; 1088 %shy = lshr i32 %y, %s 1089 %fun = call i32 @llvm.fshr.i32(i32 %x, i32 %y, i32 %s) 1090 %or = or i32 %fun, %shy 1091 ret i32 %or 1092} 1093 1094define i32 @or_lshr_fshr_commute(i32 %x, i32 %y, i32 %s) { 1095; CHECK-LABEL: @or_lshr_fshr_commute( 1096; CHECK-NEXT: [[FUN:%.*]] = call i32 @llvm.fshr.i32(i32 [[X:%.*]], i32 [[Y:%.*]], i32 [[S:%.*]]) 1097; CHECK-NEXT: ret i32 [[FUN]] 1098; 1099 %shy = lshr i32 %y, %s 1100 %fun = call i32 @llvm.fshr.i32(i32 %x, i32 %y, i32 %s) 1101 %or = or i32 %shy, %fun 1102 ret i32 %or 1103} 1104 1105; negative test - fshr operands are not commutative 1106 1107define i32 @or_lshr_fshr_wrong_order(i32 %x, i32 %y, i32 %s) { 1108; CHECK-LABEL: @or_lshr_fshr_wrong_order( 1109; CHECK-NEXT: [[SHY:%.*]] = lshr i32 [[Y:%.*]], [[S:%.*]] 1110; CHECK-NEXT: [[FUN:%.*]] = call i32 @llvm.fshr.i32(i32 [[Y]], i32 [[X:%.*]], i32 [[S]]) 1111; CHECK-NEXT: [[OR:%.*]] = or i32 [[FUN]], [[SHY]] 1112; CHECK-NEXT: ret i32 [[OR]] 1113; 1114 %shy = lshr i32 %y, %s 1115 %fun = call i32 @llvm.fshr.i32(i32 %y, i32 %x, i32 %s) 1116 %or = or i32 %fun, %shy 1117 ret i32 %or 1118} 1119