Lines Matching refs:Or
138 /// opcode and two operands into either a constant true or false, or a brand
183 /// PredicatesFoldable - Return true if both predicates match sign or if at
212 case Instruction::Or:
216 Value *Or = Builder->CreateOr(X, Together);
217 Or->takeName(Op);
218 return BinaryOperator::CreateAnd(Or, AndRHS);
336 /// whether to treat the V, Lo and HI as signed or not. IB is the location to
438 case Instruction::Or:
455 /// described as the "AMask" or "BMask" part of the enum. If the enum
458 /// is trivial if C == A, or C == 0. If both A and C are constants, this
462 /// if (A & B) == A, or all bits of A are set in B.
465 /// if (A & B) == 0, or all bits of A are cleared in B.
467 /// The part "Mixed" declares, that (A & B) == C and C might or might not
1059 case Instruction::Or: {
1158 Value *Or = Builder->CreateOr(Op0NotVal, Op1NotVal,
1160 return BinaryOperator::CreateNot(Or);
1196 // A is originally -1 (or a vector of -1 and undefs), then we enter
1300 // If this is an or instruction, it may be an inner node of the bswap.
1301 if (I->getOpcode() == Instruction::Or) {
1340 // Scan every byte of the and mask, seeing if the byte is either 0 or 255.
1370 // Okay, we got to something that isn't a shift, 'or' or 'and'. This must be
1393 // If the destination byte value is already defined, the values are or'd
1394 // together, which isn't a bswap (unless it's an or of the same bits).
1401 /// MatchBSwap - Given an OR instruction, check to see if this is a bswap idiom.
1434 /// If A is (cond?-1:0) and either B or D is ~(cond?-1,0) or (cond?0,-1), then
1435 /// we can simplify this expression to "cond ? C : D or B".
1547 // comparing a value against two constants and or'ing the result
1716 // If both are ordered or unordered, return a new fcmp with
1717 // or'ed predicates.
1776 Value *Or = Builder->CreateOr(X, RHS);
1777 Or->takeName(Op0);
1778 return BinaryOperator::CreateAnd(Or,
1786 Value *Or = Builder->CreateOr(X, RHS);
1787 Or->takeName(Op0);
1788 return BinaryOperator::CreateXor(Or,
1854 // Or commutes, try both ways.
1874 // Or commutes, try both ways.
1989 Op1->hasOneUse() && (B->getOpcode() == Instruction::Or ||
2008 // fold (or (cast A), (cast B)) -> (cast (or A, B))
2026 // If this is or(cast(icmp), cast(icmp)), try to fold this even if the
2033 // If this is or(cast(fcmp), cast(fcmp)), try to fold this even if the
2043 // or(sext(A), B) -> A ? -1 : B where A is an i1
2044 // or(A, sext(B)) -> B ? -1 : A where B is an i1
2050 // Note: If we've gotten to the point of visiting the outer OR, then the
2085 Op0I->getOpcode() == Instruction::Or) {
2171 } else if (Op0I->getOpcode() == Instruction::Or) {
