RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-24 19:52:54 +01:00
Code Issues Projects Releases Wiki Activity

[InstCombine] In foldXorToXor, move the commutable matcher from the LHS match to the RHS match. No meaningful change intended.

Browse Source 
There are two conditions ORed here with similar checks and each contain two matches that must be true for the if to succeed. With the commutable match on the first half of the OR then both ifs basically have the same first part and only the second part distinguishs. With this change we move the commutable match to second half and make the first half unique.

This caused some tests to change because we now produce a commuted result, but this shouldn't matter in practice.

llvm-svn: 306800
This commit is contained in:
Craig Topper 2017-06-30 07:37:41 +00:00
parent 4b40b38f29
commit 68303c220e
3 changed files with 16 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
View File

@ -2301,10 +2301,10 @@ static Instruction *foldXorToXor(BinaryOperator &I) {
// (~B | A) ^ (~A | B) -> A ^ B
// (~A | B) ^ (A | ~B) -> A ^ B
// (B | ~A) ^ (A | ~B) -> A ^ B
if ((match(Op0, m_c_Or(m_Value(A), m_Not(m_Value(B)))) &&
match(Op1, m_Or(m_Not(m_Specific(A)), m_Specific(B)))) ||
(match(Op0, m_c_Or(m_Not(m_Value(A)), m_Value(B))) &&
match(Op1, m_Or(m_Specific(A), m_Not(m_Specific(B)))))) {
if ((match(Op0, m_Or(m_Value(A), m_Not(m_Value(B)))) &&
match(Op1, m_c_Or(m_Not(m_Specific(A)), m_Specific(B)))) ||
(match(Op0, m_Or(m_Not(m_Value(A)), m_Value(B))) &&
match(Op1, m_c_Or(m_Specific(A), m_Not(m_Specific(B)))))) {
I.setOperand(0, A);
I.setOperand(1, B);
return &I;
@ -2314,10 +2314,10 @@ static Instruction *foldXorToXor(BinaryOperator &I) {
// (~B & A) ^ (~A & B) -> A ^ B
// (~A & B) ^ (A & ~B) -> A ^ B
// (B & ~A) ^ (A & ~B) -> A ^ B
if ((match(Op0, m_c_And(m_Value(A), m_Not(m_Value(B)))) &&
match(Op1, m_And(m_Not(m_Specific(A)), m_Specific(B)))) ||
(match(Op0, m_c_And(m_Not(m_Value(A)), m_Value(B))) &&
match(Op1, m_And(m_Specific(A), m_Not(m_Specific(B)))))) {
if ((match(Op0, m_And(m_Value(A), m_Not(m_Value(B)))) &&
match(Op1, m_c_And(m_Not(m_Specific(A)), m_Specific(B)))) ||
(match(Op0, m_And(m_Not(m_Value(A)), m_Value(B))) &&
match(Op1, m_c_And(m_Specific(A), m_Not(m_Specific(B)))))) {
I.setOperand(0, A);
I.setOperand(1, B);
return &I;

8
test/Transforms/InstCombine/and-or-not.ll
View File

@ -370,7 +370,7 @@ define i32 @xor_to_xor6(float %fa, float %fb) {
; CHECK-LABEL: @xor_to_xor6(
; CHECK-NEXT: [[A:%.*]] = fptosi float %fa to i32
; CHECK-NEXT: [[B:%.*]] = fptosi float %fb to i32
; CHECK-NEXT: [[XOR:%.*]] = xor i32 [[B]], [[A]]
; CHECK-NEXT: [[XOR:%.*]] = xor i32 [[A]], [[B]]
; CHECK-NEXT: ret i32 [[XOR]]
;
%a = fptosi float %fa to i32
@ -408,7 +408,7 @@ define i32 @xor_to_xor8(float %fa, float %fb) {
; CHECK-LABEL: @xor_to_xor8(
; CHECK-NEXT: [[A:%.*]] = fptosi float %fa to i32
; CHECK-NEXT: [[B:%.*]] = fptosi float %fb to i32
; CHECK-NEXT: [[XOR:%.*]] = xor i32 [[B]], [[A]]
; CHECK-NEXT: [[XOR:%.*]] = xor i32 [[A]], [[B]]
; CHECK-NEXT: ret i32 [[XOR]]
;
%a = fptosi float %fa to i32
@ -446,7 +446,7 @@ define i32 @xor_to_xor10(float %fa, float %fb) {
; CHECK-LABEL: @xor_to_xor10(
; CHECK-NEXT: [[A:%.*]] = fptosi float %fa to i32
; CHECK-NEXT: [[B:%.*]] = fptosi float %fb to i32
; CHECK-NEXT: [[XOR:%.*]] = xor i32 [[B]], [[A]]
; CHECK-NEXT: [[XOR:%.*]] = xor i32 [[A]], [[B]]
; CHECK-NEXT: ret i32 [[XOR]]
;
%a = fptosi float %fa to i32
@ -484,7 +484,7 @@ define i32 @xor_to_xor12(float %fa, float %fb) {
; CHECK-LABEL: @xor_to_xor12(
; CHECK-NEXT: [[A:%.*]] = fptosi float %fa to i32
; CHECK-NEXT: [[B:%.*]] = fptosi float %fb to i32
; CHECK-NEXT: [[XOR:%.*]] = xor i32 [[B]], [[A]]
; CHECK-NEXT: [[XOR:%.*]] = xor i32 [[A]], [[B]]
; CHECK-NEXT: ret i32 [[XOR]]
;
%a = fptosi float %fa to i32

8
test/Transforms/InstCombine/or-xor.ll
View File

@ -178,7 +178,7 @@ define i32 @test13(i32 %x, i32 %y) {
; ((x | ~y) ^ (~x | y)) -> x ^ y
define i32 @test14(i32 %x, i32 %y) {
; CHECK-LABEL: @test14(
; CHECK-NEXT: [[XOR:%.*]] = xor i32 %x, %y
; CHECK-NEXT: [[XOR:%.*]] = xor i32 %y, %x
; CHECK-NEXT: ret i32 [[XOR]]
;
%noty = xor i32 %y, -1
@ -191,7 +191,7 @@ define i32 @test14(i32 %x, i32 %y) {
define i32 @test14_commuted(i32 %x, i32 %y) {
; CHECK-LABEL: @test14_commuted(
; CHECK-NEXT: [[XOR:%.*]] = xor i32 %x, %y
; CHECK-NEXT: [[XOR:%.*]] = xor i32 %y, %x
; CHECK-NEXT: ret i32 [[XOR]]
;
%noty = xor i32 %y, -1
@ -205,7 +205,7 @@ define i32 @test14_commuted(i32 %x, i32 %y) {
; ((x & ~y) ^ (~x & y)) -> x ^ y
define i32 @test15(i32 %x, i32 %y) {
; CHECK-LABEL: @test15(
; CHECK-NEXT: [[XOR:%.*]] = xor i32 %x, %y
; CHECK-NEXT: [[XOR:%.*]] = xor i32 %y, %x
; CHECK-NEXT: ret i32 [[XOR]]
;
%noty = xor i32 %y, -1
@ -218,7 +218,7 @@ define i32 @test15(i32 %x, i32 %y) {
define i32 @test15_commuted(i32 %x, i32 %y) {
; CHECK-LABEL: @test15_commuted(
; CHECK-NEXT: [[XOR:%.*]] = xor i32 %x, %y
; CHECK-NEXT: [[XOR:%.*]] = xor i32 %y, %x
; CHECK-NEXT: ret i32 [[XOR]]
;
%noty = xor i32 %y, -1