Transforms/InstCombine/InstCombineAndOrXor.cpp

128 // OptAndOp - This handles expressions of the form ((val OP C1) & C2).  Where
129 // the Op parameter is 'OP', OpRHS is 'C1', and AndRHS is 'C2'.  Op is
143       // (X ^ C1) & C2 --> (X & C2) ^ (C1&C2)
152         // (X | C1) & C2 --> (X | (C1&C2)) & C2
160         // (X | C1) & C2 --> (X & (C2^(C1&C2))) | C1
254         // (Val ashr C1) & C2 -> (Val lshr C1) & C2
805   // This only handles icmp of constants: (icmp1 A, C1) & (icmp2 B, C2).
827   // (trunc x) == C1 & (and x, CA) == C2 -> (and x, CA|CMAX) == C1|C2
835     // (trunc x) == C1 & (and x, CA) == C2
836     // (and x, CA) == C2 & (trunc x) == C1
863   //    (icmp1 A, C1) & (icmp2 A, C2) --> something simpler.
1117     // Optimize a variety of ((val OP C1) & C2) combinations...
1646   // This only handles icmp of constants: (icmp1 A, C1) | (icmp2 B, C2).
1657   // (icmp ult (X + CA), C1) | (icmp eq X, C2) -> (icmp ule (X + CA), C1)
1658   //   iff C2 + CA == C1.
1667   //    (icmp1 A, C1) | (icmp2 A, C2) --> something simpler.
1712         // (A == C1 || A == C2) -> (A & ~(C1 ^ C2)) == C1
1889 ///     ((A | B) & C1) | (B & C2)
1893 ///     (A & C1) | B
1933     ConstantInt *C1 = 0; Value *X = 0;
1934     // (X & C1) | C2 --> (X | C2) & (C1|C2)
1935     // iff (C1 & C2) == 0.
1936     if (match(Op0, m_And(m_Value(X), m_ConstantInt(C1))) &&
1937         (RHS->getValue() & C1->getValue()) != 0 &&
1942                              Builder->getInt(RHS->getValue() | C1->getValue()));
1945     // (X ^ C1) | C2 --> (X | C2) ^ (C1&~C2)
1946     if (match(Op0, m_Xor(m_Value(X), m_ConstantInt(C1))) &&
1951                             Builder->getInt(C1->getValue() & ~RHS->getValue()));
1965   ConstantInt *C1 = 0, *C2 = 0;
1979       match(Op0, m_Xor(m_Value(A), m_ConstantInt(C1))) &&
1980       MaskedValueIsZero(Op1, C1->getValue())) {
1983     return BinaryOperator::CreateXor(NOr, C1);
1988       match(Op1, m_Xor(m_Value(A), m_ConstantInt(C1))) &&
1989       MaskedValueIsZero(Op0, C1->getValue())) {
1992     return BinaryOperator::CreateXor(NOr, C1);
2000     C1 = dyn_cast<ConstantInt>(C);
2002     if (C1 && C2) {  // (A & C1)|(B & C2)
2003       // If we have: ((V + N) & C1) | (V & C2)
2004       // .. and C2 = ~C1 and C2 is 0+1+ and (N & C2) == 0
2006       if (C1->getValue() == ~C2->getValue()) {
2016         if ((C1->getValue() & (C1->getValue()+1)) == 0 &&
2019           if (V1 == A && MaskedValueIsZero(V2, C1->getValue()))
2021           if (V2 == A && MaskedValueIsZero(V1, C1->getValue()))
2026       if ((C1->getValue() & C2->getValue()) == 0) {
2027         // ((V | N) & C1) | (V & C2) --> (V|N) & (C1|C2)
2028         // iff (C1&C2) == 0 and (N&~C1) == 0
2030             ((V1 == B && MaskedValueIsZero(V2, ~C1->getValue())) ||  // (V|N)
2031              (V2 == B && MaskedValueIsZero(V1, ~C1->getValue()))))   // (N|V)
2033                                 Builder->getInt(C1->getValue()|C2->getValue()));
2039                                 Builder->getInt(C1->getValue()|C2->getValue()));
2041         // ((V|C3)&C1) | ((V|C4)&C2) --> (V|C3|C4)&(C1|C2)
2042         // iff (C1&C2) == 0 and (C3&~C1) == 0 and (C4&~C2) == 0.
2045             (C3->getValue() & ~C1->getValue()) == 0 &&
2050                                 Builder->getInt(C1->getValue()|C2->getValue()));
2225       match(Op0, m_Or(m_Value(A), m_ConstantInt(C1)))) {
2228     return BinaryOperator::CreateOr(Inner, C1);
2353           // (X|C1)^C2 -> X^(C1|C2) iff X&~C1 == 0
2356             // Anything in both C1 and C2 is known to be zero, remove it from
2367           // ((X^C1) >> C2) ^ C3 -> (X>>C2) ^ ((C1>>C2)^C3)
2368           // E1 = "X ^ C1"
2370           ConstantInt *C1;
2374               (C1 = dyn_cast<ConstantInt>(E1->getOperand(1)))) {
2375             // fold (C1 >> C2) ^ C3
2377             APInt FoldConst = C1->getValue().lshr(C2->getValue());