Lines Matching refs:Op0
244 if (BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS))
245 if (Op0->getOpcode() == OpcodeToExpand) {
247 Value *A = Op0->getOperand(0), *B = Op0->getOperand(1), *C = RHS;
304 BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS);
308 if (Op0 && Op0->getOpcode() == Opcode) {
309 Value *A = Op0->getOperand(0);
310 Value *B = Op0->getOperand(1);
350 if (Op0 && Op0->getOpcode() == Opcode) {
351 Value *A = Op0->getOperand(0);
352 Value *B = Op0->getOperand(1);
602 Value *&Op0, Value *&Op1,
604 if (auto *CLHS = dyn_cast<Constant>(Op0)) {
610 std::swap(Op0, Op1);
617 static Value *SimplifyAddInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW,
619 if (Constant *C = foldOrCommuteConstant(Instruction::Add, Op0, Op1, Q))
628 return Op0;
631 if (isKnownNegation(Op0, Op1))
632 return Constant::getNullValue(Op0->getType());
638 if (match(Op1, m_Sub(m_Value(Y), m_Specific(Op0))) ||
639 match(Op0, m_Sub(m_Value(Y), m_Specific(Op1))))
643 Type *Ty = Op0->getType();
644 if (match(Op0, m_Not(m_Specific(Op1))) ||
645 match(Op1, m_Not(m_Specific(Op0))))
652 match(Op0, m_Xor(m_Value(Y), m_SignMask())))
660 if (MaxRecurse && Op0->getType()->isIntOrIntVectorTy(1))
661 if (Value *V = SimplifyXorInst(Op0, Op1, Q, MaxRecurse-1))
665 if (Value *V = SimplifyAssociativeBinOp(Instruction::Add, Op0, Op1, Q,
681 Value *llvm::SimplifyAddInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW,
683 return ::SimplifyAddInst(Op0, Op1, IsNSW, IsNUW, Query, RecursionLimit);
736 static Value *SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
738 if (Constant *C = foldOrCommuteConstant(Instruction::Sub, Op0, Op1, Q))
743 if (match(Op0, m_Undef()) || match(Op1, m_Undef()))
744 return UndefValue::get(Op0->getType());
748 return Op0;
751 if (Op0 == Op1)
752 return Constant::getNullValue(Op0->getType());
755 if (match(Op0, m_Zero())) {
758 return Constant::getNullValue(Op0->getType());
765 return Constant::getNullValue(Op0->getType());
775 if (MaxRecurse && match(Op0, m_Add(m_Value(X), m_Value(Y)))) { // (X + Y) - Z
796 X = Op0;
818 Z = Op0;
830 if (MaxRecurse && match(Op0, m_Trunc(m_Value(X))) &&
836 if (Value *W = SimplifyCastInst(Instruction::Trunc, V, Op0->getType(),
842 if (match(Op0, m_PtrToInt(m_Value(X))) &&
845 return ConstantExpr::getIntegerCast(Result, Op0->getType(), true);
848 if (MaxRecurse && Op0->getType()->isIntOrIntVectorTy(1))
849 if (Value *V = SimplifyXorInst(Op0, Op1, Q, MaxRecurse-1))
864 Value *llvm::SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
866 return ::SimplifySubInst(Op0, Op1, isNSW, isNUW, Q, RecursionLimit);
871 static Value *SimplifyMulInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
873 if (Constant *C = foldOrCommuteConstant(Instruction::Mul, Op0, Op1, Q))
879 return Constant::getNullValue(Op0->getType());
883 return Op0;
888 (match(Op0,
890 match(Op1, m_Exact(m_IDiv(m_Value(X), m_Specific(Op0)))))) // Y * (X / Y)
894 if (MaxRecurse && Op0->getType()->isIntOrIntVectorTy(1))
895 if (Value *V = SimplifyAndInst(Op0, Op1, Q, MaxRecurse-1))
899 if (Value *V = SimplifyAssociativeBinOp(Instruction::Mul, Op0, Op1, Q,
904 if (Value *V = ExpandBinOp(Instruction::Mul, Op0, Op1, Instruction::Add,
910 if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
911 if (Value *V = ThreadBinOpOverSelect(Instruction::Mul, Op0, Op1, Q,
917 if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
918 if (Value *V = ThreadBinOpOverPHI(Instruction::Mul, Op0, Op1, Q,
925 Value *llvm::SimplifyMulInst(Value *Op0, Value *Op1, const SimplifyQuery &Q) {
926 return ::SimplifyMulInst(Op0, Op1, Q, RecursionLimit);
931 static Value *simplifyDivRem(Value *Op0, Value *Op1, bool IsDiv) {
932 Type *Ty = Op0->getType();
960 if (match(Op0, m_Undef()))
965 if (match(Op0, m_Zero()))
966 return Constant::getNullValue(Op0->getType());
970 if (Op0 == Op1)
981 return IsDiv ? Op0 : Constant::getNullValue(Ty);
1049 static Value *simplifyDiv(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1,
1051 if (Constant *C = foldOrCommuteConstant(Opcode, Op0, Op1, Q))
1054 if (Value *V = simplifyDivRem(Op0, Op1, true))
1061 if (match(Op0, m_c_Mul(m_Value(X), m_Specific(Op1)))) {
1062 auto *Mul = cast<OverflowingBinaryOperator>(Op0);
1074 if ((IsSigned && match(Op0, m_SRem(m_Value(), m_Specific(Op1)))) ||
1075 (!IsSigned && match(Op0, m_URem(m_Value(), m_Specific(Op1)))))
1076 return Constant::getNullValue(Op0->getType());
1080 if (!IsSigned && match(Op0, m_UDiv(m_Value(X), m_ConstantInt(C1))) &&
1085 return Constant::getNullValue(Op0->getType());
1090 if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
1091 if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, Q, MaxRecurse))
1096 if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
1097 if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, Q, MaxRecurse))
1100 if (isDivZero(Op0, Op1, Q, MaxRecurse, IsSigned))
1101 return Constant::getNullValue(Op0->getType());
1107 static Value *simplifyRem(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1,
1109 if (Constant *C = foldOrCommuteConstant(Opcode, Op0, Op1, Q))
1112 if (Value *V = simplifyDivRem(Op0, Op1, false))
1117 match(Op0, m_SRem(m_Value(), m_Specific(Op1)))) ||
1119 match(Op0, m_URem(m_Value(), m_Specific(Op1)))))
1120 return Op0;
1125 match(Op0, m_NSWShl(m_Specific(Op1), m_Value()))) ||
1127 match(Op0, m_NUWShl(m_Specific(Op1), m_Value())))))
1128 return Constant::getNullValue(Op0->getType());
1132 if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
1133 if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, Q, MaxRecurse))
1138 if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
1139 if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, Q, MaxRecurse))
1143 if (isDivZero(Op0, Op1, Q, MaxRecurse, Opcode == Instruction::SRem))
1144 return Op0;
1151 static Value *SimplifySDivInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
1154 if (isKnownNegation(Op0, Op1, /*NeedNSW=*/true))
1155 return Constant::getAllOnesValue(Op0->getType());
1157 return simplifyDiv(Instruction::SDiv, Op0, Op1, Q, MaxRecurse);
1160 Value *llvm::SimplifySDivInst(Value *Op0, Value *Op1, const SimplifyQuery &Q) {
1161 return ::SimplifySDivInst(Op0, Op1, Q, RecursionLimit);
1166 static Value *SimplifyUDivInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
1168 return simplifyDiv(Instruction::UDiv, Op0, Op1, Q, MaxRecurse);
1171 Value *llvm::SimplifyUDivInst(Value *Op0, Value *Op1, const SimplifyQuery &Q) {
1172 return ::SimplifyUDivInst(Op0, Op1, Q, RecursionLimit);
1177 static Value *SimplifySRemInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
1180 // srem Op0, (sext i1 X) --> srem Op0, -1 --> 0
1183 return ConstantInt::getNullValue(Op0->getType());
1186 if (isKnownNegation(Op0, Op1))
1187 return ConstantInt::getNullValue(Op0->getType());
1189 return simplifyRem(Instruction::SRem, Op0, Op1, Q, MaxRecurse);
1192 Value *llvm::SimplifySRemInst(Value *Op0, Value *Op1, const SimplifyQuery &Q) {
1193 return ::SimplifySRemInst(Op0, Op1, Q, RecursionLimit);
1198 static Value *SimplifyURemInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
1200 return simplifyRem(Instruction::URem, Op0, Op1, Q, MaxRecurse);
1203 Value *llvm::SimplifyURemInst(Value *Op0, Value *Op1, const SimplifyQuery &Q) {
1204 return ::SimplifyURemInst(Op0, Op1, Q, RecursionLimit);
1237 static Value *SimplifyShift(Instruction::BinaryOps Opcode, Value *Op0,
1239 if (Constant *C = foldOrCommuteConstant(Opcode, Op0, Op1, Q))
1243 if (match(Op0, m_Zero()))
1244 return Constant::getNullValue(Op0->getType());
1252 return Op0;
1256 return UndefValue::get(Op0->getType());
1260 if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
1261 if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, Q, MaxRecurse))
1266 if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
1267 if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, Q, MaxRecurse))
1274 return UndefValue::get(Op0->getType());
1280 return Op0;
1287 static Value *SimplifyRightShift(Instruction::BinaryOps Opcode, Value *Op0,
1290 if (Value *V = SimplifyShift(Opcode, Op0, Op1, Q, MaxRecurse))
1294 if (Op0 == Op1)
1295 return Constant::getNullValue(Op0->getType());
1299 if (match(Op0, m_Undef()))
1300 return isExact ? Op0 : Constant::getNullValue(Op0->getType());
1304 KnownBits Op0Known = computeKnownBits(Op0, Q.DL, /*Depth=*/0, Q.AC, Q.CxtI, Q.DT);
1306 return Op0;
1314 static Value *SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
1316 if (Value *V = SimplifyShift(Instruction::Shl, Op0, Op1, Q, MaxRecurse))
1321 if (match(Op0, m_Undef()))
1322 return isNSW || isNUW ? Op0 : Constant::getNullValue(Op0->getType());
1327 match(Op0, m_Exact(m_Shr(m_Value(X), m_Specific(Op1)))))
1331 if (isNUW && match(Op0, m_Negative()))
1332 return Op0;
1339 Value *llvm::SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
1341 return ::SimplifyShlInst(Op0, Op1, isNSW, isNUW, Q, RecursionLimit);
1346 static Value *SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact,
1348 if (Value *V = SimplifyRightShift(Instruction::LShr, Op0, Op1, isExact, Q,
1354 if (match(Op0, m_NUWShl(m_Value(X), m_Specific(Op1))))
1365 match(Op0, m_c_Or(m_NUWShl(m_Value(X), m_APInt(ShLAmt)), m_Value(Y))) &&
1368 const unsigned Width = Op0->getType()->getScalarSizeInBits();
1377 Value *llvm::SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact,
1379 return ::SimplifyLShrInst(Op0, Op1, isExact, Q, RecursionLimit);
1384 static Value *SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact,
1386 if (Value *V = SimplifyRightShift(Instruction::AShr, Op0, Op1, isExact, Q,
1391 // Do not return Op0 because it may contain undef elements if it's a vector.
1392 if (match(Op0, m_AllOnes()))
1393 return Constant::getAllOnesValue(Op0->getType());
1397 if (Q.IIQ.UseInstrInfo && match(Op0, m_NSWShl(m_Value(X), m_Specific(Op1))))
1401 unsigned NumSignBits = ComputeNumSignBits(Op0, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
1402 if (NumSignBits == Op0->getType()->getScalarSizeInBits())
1403 return Op0;
1408 Value *llvm::SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact,
1410 return ::SimplifyAShrInst(Op0, Op1, isExact, Q, RecursionLimit);
1525 static Value *simplifyAndOfICmpsWithSameOperands(ICmpInst *Op0, ICmpInst *Op1) {
1528 if (!match(Op0, m_ICmp(Pred0, m_Value(A), m_Value(B))) ||
1533 // If Op1 is always implied true by Op0, then Op0 is a subset of Op1, and we
1536 return Op0;
1543 return getFalse(Op0->getType());
1550 static Value *simplifyOrOfICmpsWithSameOperands(ICmpInst *Op0, ICmpInst *Op1) {
1553 if (!match(Op0, m_ICmp(Pred0, m_Value(A), m_Value(B))) ||
1558 // If Op1 is always implied true by Op0, then Op0 is a subset of Op1, and we
1559 // can eliminate Op0 from this 'or'.
1569 return getTrue(Op0->getType());
1651 static Value *simplifyAndOfICmpsWithAdd(ICmpInst *Op0, ICmpInst *Op1,
1657 if (!match(Op0, m_ICmp(Pred0, m_Add(m_Value(V), m_APInt(C0)), m_APInt(C1))))
1663 auto *AddInst = cast<OverflowingBinaryOperator>(Op0->getOperand(0));
1667 Type *ITy = Op0->getType();
1756 static Value *simplifyAndOfICmps(ICmpInst *Op0, ICmpInst *Op1,
1758 if (Value *X = simplifyUnsignedRangeCheck(Op0, Op1, /*IsAnd=*/true, Q))
1760 if (Value *X = simplifyUnsignedRangeCheck(Op1, Op0, /*IsAnd=*/true, Q))
1763 if (Value *X = simplifyAndOfICmpsWithSameOperands(Op0, Op1))
1765 if (Value *X = simplifyAndOfICmpsWithSameOperands(Op1, Op0))
1768 if (Value *X = simplifyAndOrOfICmpsWithConstants(Op0, Op1, true))
1771 if (Value *X = simplifyAndOrOfICmpsWithLimitConst(Op0, Op1, true))
1774 if (Value *X = simplifyAndOrOfICmpsWithZero(Op0, Op1, true))
1777 if (Value *X = simplifyAndOfICmpsWithAdd(Op0, Op1, Q.IIQ))
1779 if (Value *X = simplifyAndOfICmpsWithAdd(Op1, Op0, Q.IIQ))
1785 static Value *simplifyOrOfICmpsWithAdd(ICmpInst *Op0, ICmpInst *Op1,
1791 if (!match(Op0, m_ICmp(Pred0, m_Add(m_Value(V), m_APInt(C0)), m_APInt(C1))))
1797 auto *AddInst = cast<BinaryOperator>(Op0->getOperand(0));
1801 Type *ITy = Op0->getType();
1832 static Value *simplifyOrOfICmps(ICmpInst *Op0, ICmpInst *Op1,
1834 if (Value *X = simplifyUnsignedRangeCheck(Op0, Op1, /*IsAnd=*/false, Q))
1836 if (Value *X = simplifyUnsignedRangeCheck(Op1, Op0, /*IsAnd=*/false, Q))
1839 if (Value *X = simplifyOrOfICmpsWithSameOperands(Op0, Op1))
1841 if (Value *X = simplifyOrOfICmpsWithSameOperands(Op1, Op0))
1844 if (Value *X = simplifyAndOrOfICmpsWithConstants(Op0, Op1, false))
1847 if (Value *X = simplifyAndOrOfICmpsWithLimitConst(Op0, Op1, false))
1850 if (Value *X = simplifyAndOrOfICmpsWithZero(Op0, Op1, false))
1853 if (Value *X = simplifyOrOfICmpsWithAdd(Op0, Op1, Q.IIQ))
1855 if (Value *X = simplifyOrOfICmpsWithAdd(Op1, Op0, Q.IIQ))
1900 Value *Op0, Value *Op1, bool IsAnd) {
1902 auto *Cast0 = dyn_cast<CastInst>(Op0);
1906 Op0 = Cast0->getOperand(0);
1911 auto *ICmp0 = dyn_cast<ICmpInst>(Op0);
1917 auto *FCmp0 = dyn_cast<FCmpInst>(Op0);
1960 /// %Op0 = icmp ne i4 %X, 0
1963 /// %??? = and i1 %Op0, %Op1
1965 static Value *omitCheckForZeroBeforeMulWithOverflow(Value *Op0, Value *Op1) {
1968 if (!match(Op0, m_ICmp(Pred, m_Value(X), m_Zero())) ||
1982 /// %Op0 = icmp eq i4 %X, 0
1986 /// %or = or i1 %Op0, %NotOp1
1988 static Value *omitCheckForZeroBeforeInvertedMulWithOverflow(Value *Op0,
1992 if (!match(Op0, m_ICmp(Pred, m_Value(X), m_Zero())) ||
2008 static Value *SimplifyAndInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
2010 if (Constant *C = foldOrCommuteConstant(Instruction::And, Op0, Op1, Q))
2015 return Constant::getNullValue(Op0->getType());
2018 if (Op0 == Op1)
2019 return Op0;
2023 return Constant::getNullValue(Op0->getType());
2027 return Op0;
2030 if (match(Op0, m_Not(m_Specific(Op1))) ||
2031 match(Op1, m_Not(m_Specific(Op0))))
2032 return Constant::getNullValue(Op0->getType());
2035 if (match(Op0, m_c_Or(m_Specific(Op1), m_Value())))
2039 if (match(Op1, m_c_Or(m_Specific(Op0), m_Value())))
2040 return Op0;
2049 if (match(Op0, m_Shl(m_Value(X), m_APInt(ShAmt))) &&
2051 return Op0;
2055 if (match(Op0, m_LShr(m_Value(X), m_APInt(ShAmt))) &&
2057 return Op0;
2063 if (Value *V = omitCheckForZeroBeforeMulWithOverflow(Op0, Op1))
2065 if (Value *V = omitCheckForZeroBeforeMulWithOverflow(Op1, Op0))
2069 if (match(Op0, m_Neg(m_Specific(Op1))) ||
2070 match(Op1, m_Neg(m_Specific(Op0)))) {
2071 if (isKnownToBeAPowerOfTwo(Op0, Q.DL, /*OrZero*/ true, 0, Q.AC, Q.CxtI,
2073 return Op0;
2082 if (match(Op0, m_Add(m_Specific(Op1), m_AllOnes())) &&
2085 if (match(Op1, m_Add(m_Specific(Op0), m_AllOnes())) &&
2086 isKnownToBeAPowerOfTwo(Op0, Q.DL, /*OrZero*/ true, 0, Q.AC, Q.CxtI, Q.DT))
2087 return Constant::getNullValue(Op0->getType());
2089 if (Value *V = simplifyAndOrOfCmps(Q, Op0, Op1, true))
2093 if (Value *V = SimplifyAssociativeBinOp(Instruction::And, Op0, Op1, Q,
2098 if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Or,
2103 if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Xor,
2109 if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
2110 if (Value *V = ThreadBinOpOverSelect(Instruction::And, Op0, Op1, Q,
2116 if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
2117 if (Value *V = ThreadBinOpOverPHI(Instruction::And, Op0, Op1, Q,
2133 match(Op0, m_c_Or(m_CombineAnd(m_NUWShl(m_Value(X), m_APInt(ShAmt)),
2136 const unsigned Width = Op0->getType()->getScalarSizeInBits();
2158 Value *llvm::SimplifyAndInst(Value *Op0, Value *Op1, const SimplifyQuery &Q) {
2159 return ::SimplifyAndInst(Op0, Op1, Q, RecursionLimit);
2164 static Value *SimplifyOrInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
2166 if (Constant *C = foldOrCommuteConstant(Instruction::Or, Op0, Op1, Q))
2173 return Constant::getAllOnesValue(Op0->getType());
2177 if (Op0 == Op1 || match(Op1, m_Zero()))
2178 return Op0;
2181 if (match(Op0, m_Not(m_Specific(Op1))) ||
2182 match(Op1, m_Not(m_Specific(Op0))))
2183 return Constant::getAllOnesValue(Op0->getType());
2186 if (match(Op0, m_c_And(m_Specific(Op1), m_Value())))
2190 if (match(Op1, m_c_And(m_Specific(Op0), m_Value())))
2191 return Op0;
2194 if (match(Op0, m_Not(m_c_And(m_Specific(Op1), m_Value()))))
2198 if (match(Op1, m_Not(m_c_And(m_Specific(Op0), m_Value()))))
2199 return Constant::getAllOnesValue(Op0->getType());
2207 (match(Op0, m_c_And(m_Specific(A), m_Not(m_Specific(B)))) ||
2208 match(Op0, m_c_And(m_Not(m_Specific(A)), m_Specific(B)))))
2216 if (match(Op0, m_Xor(m_Value(A), m_Value(B))) &&
2219 return Op0;
2225 if (match(Op0, m_And(m_Value(A), m_Value(B))) &&
2235 (match(Op0, m_c_Xor(m_Specific(A), m_Not(m_Specific(B)))) ||
2236 match(Op0, m_c_Xor(m_Not(m_Specific(A)), m_Specific(B)))))
2237 return Op0;
2239 if (Value *V = simplifyAndOrOfCmps(Q, Op0, Op1, false))
2245 if (Value *V = omitCheckForZeroBeforeInvertedMulWithOverflow(Op0, Op1))
2247 if (Value *V = omitCheckForZeroBeforeInvertedMulWithOverflow(Op1, Op0))
2251 if (Value *V = SimplifyAssociativeBinOp(Instruction::Or, Op0, Op1, Q,
2256 if (Value *V = ExpandBinOp(Instruction::Or, Op0, Op1, Instruction::And, Q,
2262 if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
2263 if (Value *V = ThreadBinOpOverSelect(Instruction::Or, Op0, Op1, Q,
2269 if (match(Op0, m_And(m_Value(A), m_APInt(C1))) &&
2295 if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
2296 if (Value *V = ThreadBinOpOverPHI(Instruction::Or, Op0, Op1, Q, MaxRecurse))
2302 Value *llvm::SimplifyOrInst(Value *Op0, Value *Op1, const SimplifyQuery &Q) {
2303 return ::SimplifyOrInst(Op0, Op1, Q, RecursionLimit);
2308 static Value *SimplifyXorInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
2310 if (Constant *C = foldOrCommuteConstant(Instruction::Xor, Op0, Op1, Q))
2319 return Op0;
2322 if (Op0 == Op1)
2323 return Constant::getNullValue(Op0->getType());
2326 if (match(Op0, m_Not(m_Specific(Op1))) ||
2327 match(Op1, m_Not(m_Specific(Op0))))
2328 return Constant::getAllOnesValue(Op0->getType());
2331 if (Value *V = SimplifyAssociativeBinOp(Instruction::Xor, Op0, Op1, Q,
2347 Value *llvm::SimplifyXorInst(Value *Op0, Value *Op1, const SimplifyQuery &Q) {
2348 return ::SimplifyXorInst(Op0, Op1, Q, RecursionLimit);
4501 static Value *foldIdentityShuffles(int DestElt, Value *Op0, Value *Op1,
4513 int InVecNumElts = cast<VectorType>(Op0->getType())->getNumElements();
4515 Value *SourceOp = Op0;
4549 static Value *SimplifyShuffleVectorInst(Value *Op0, Value *Op1,
4556 auto *InVecTy = cast<VectorType>(Op0->getType());
4579 Op0 = UndefValue::get(InVecTy);
4584 auto *Op0Const = dyn_cast<Constant>(Op0);
4597 std::swap(Op0, Op1);
4609 if (!Scalable && match(Op0, m_InsertElt(m_Value(), m_Constant(C),
4629 if (auto *OpShuf = dyn_cast<ShuffleVectorInst>(Op0))
4632 return Op0;
4654 foldIdentityShuffles(i, Op0, Op1, Indices[i], RootVec, MaxRecurse);
4664 Value *llvm::SimplifyShuffleVectorInst(Value *Op0, Value *Op1,
4667 return ::SimplifyShuffleVectorInst(Op0, Op1, Mask, RetTy, Q, RecursionLimit);
4733 static Value *SimplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF,
4735 if (Constant *C = foldOrCommuteConstant(Instruction::FAdd, Op0, Op1, Q))
4738 if (Constant *C = simplifyFPOp({Op0, Op1}, FMF))
4743 return Op0;
4747 (FMF.noSignedZeros() || CannotBeNegativeZero(Op0, Q.TLI)))
4748 return Op0;
4758 if (match(Op0, m_FSub(m_AnyZeroFP(), m_Specific(Op1))) ||
4759 match(Op1, m_FSub(m_AnyZeroFP(), m_Specific(Op0))))
4760 return ConstantFP::getNullValue(Op0->getType());
4762 if (match(Op0, m_FNeg(m_Specific(Op1))) ||
4763 match(Op1, m_FNeg(m_Specific(Op0))))
4764 return ConstantFP::getNullValue(Op0->getType());
4771 (match(Op0, m_FSub(m_Value(X), m_Specific(Op1))) ||
4772 match(Op1, m_FSub(m_Value(X), m_Specific(Op0)))))
4780 static Value *SimplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF,
4782 if (Constant *C = foldOrCommuteConstant(Instruction::FSub, Op0, Op1, Q))
4785 if (Constant *C = simplifyFPOp({Op0, Op1}, FMF))
4790 return Op0;
4794 (FMF.noSignedZeros() || CannotBeNegativeZero(Op0, Q.TLI)))
4795 return Op0;
4800 if (match(Op0, m_NegZeroFP()) &&
4806 if (FMF.noSignedZeros() && match(Op0, m_AnyZeroFP()) &&
4812 if (FMF.noNaNs() && Op0 == Op1)
4813 return Constant::getNullValue(Op0->getType());
4818 (match(Op1, m_FSub(m_Specific(Op0), m_Value(X))) ||
4819 match(Op0, m_c_FAdd(m_Specific(Op1), m_Value(X)))))
4825 static Value *SimplifyFMAFMul(Value *Op0, Value *Op1, FastMathFlags FMF,
4827 if (Constant *C = simplifyFPOp({Op0, Op1}, FMF))
4832 return Op0;
4835 if (match(Op0, m_FPOne()))
4840 return ConstantFP::getNullValue(Op0->getType());
4843 if (FMF.noNaNs() && FMF.noSignedZeros() && match(Op0, m_AnyZeroFP()))
4851 if (Op0 == Op1 && match(Op0, m_Intrinsic<Intrinsic::sqrt>(m_Value(X))) &&
4859 static Value *SimplifyFMulInst(Value *Op0, Value *Op1, FastMathFlags FMF,
4861 if (Constant *C = foldOrCommuteConstant(Instruction::FMul, Op0, Op1, Q))
4865 return SimplifyFMAFMul(Op0, Op1, FMF, Q, MaxRecurse);
4868 Value *llvm::SimplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF,
4870 return ::SimplifyFAddInst(Op0, Op1, FMF, Q, RecursionLimit);
4874 Value *llvm::SimplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF,
4876 return ::SimplifyFSubInst(Op0, Op1, FMF, Q, RecursionLimit);
4879 Value *llvm::SimplifyFMulInst(Value *Op0, Value *Op1, FastMathFlags FMF,
4881 return ::SimplifyFMulInst(Op0, Op1, FMF, Q, RecursionLimit);
4884 Value *llvm::SimplifyFMAFMul(Value *Op0, Value *Op1, FastMathFlags FMF,
4886 return ::SimplifyFMAFMul(Op0, Op1, FMF, Q, RecursionLimit);
4889 static Value *SimplifyFDivInst(Value *Op0, Value *Op1, FastMathFlags FMF,
4891 if (Constant *C = foldOrCommuteConstant(Instruction::FDiv, Op0, Op1, Q))
4894 if (Constant *C = simplifyFPOp({Op0, Op1}, FMF))
4899 return Op0;
4904 if (FMF.noNaNs() && FMF.noSignedZeros() && match(Op0, m_AnyZeroFP()))
4905 return ConstantFP::getNullValue(Op0->getType());
4910 if (Op0 == Op1)
4911 return ConstantFP::get(Op0->getType(), 1.0);
4915 if (FMF.allowReassoc() && match(Op0, m_c_FMul(m_Value(X), m_Specific(Op1))))
4921 if (match(Op0, m_FNegNSZ(m_Specific(Op1))) ||
4922 match(Op1, m_FNegNSZ(m_Specific(Op0))))
4923 return ConstantFP::get(Op0->getType(), -1.0);
4929 Value *llvm::SimplifyFDivInst(Value *Op0, Value *Op1, FastMathFlags FMF,
4931 return ::SimplifyFDivInst(Op0, Op1, FMF, Q, RecursionLimit);
4934 static Value *SimplifyFRemInst(Value *Op0, Value *Op1, FastMathFlags FMF,
4936 if (Constant *C = foldOrCommuteConstant(Instruction::FRem, Op0, Op1, Q))
4939 if (Constant *C = simplifyFPOp({Op0, Op1}, FMF))
4947 if (match(Op0, m_PosZeroFP()))
4948 return ConstantFP::getNullValue(Op0->getType());
4950 if (match(Op0, m_NegZeroFP()))
4951 return ConstantFP::getNegativeZero(Op0->getType());
4957 Value *llvm::SimplifyFRemInst(Value *Op0, Value *Op1, FastMathFlags FMF,
4959 return ::SimplifyFRemInst(Op0, Op1, FMF, Q, RecursionLimit);
5162 static Value *simplifyUnaryIntrinsic(Function *F, Value *Op0,
5167 if (auto *II = dyn_cast<IntrinsicInst>(Op0))
5174 if (SignBitMustBeZero(Op0, Q.TLI)) return Op0;
5178 if (match(Op0, m_BSwap(m_Value(X)))) return X;
5182 if (match(Op0, m_BitReverse(m_Value(X)))) return X;
5187 match(Op0, m_Intrinsic<Intrinsic::log>(m_Value(X)))) return X;
5192 match(Op0, m_Intrinsic<Intrinsic::log2>(m_Value(X)))) return X;
5197 match(Op0, m_Intrinsic<Intrinsic::exp>(m_Value(X)))) return X;
5202 (match(Op0, m_Intrinsic<Intrinsic::exp2>(m_Value(X))) ||
5203 match(Op0, m_Intrinsic<Intrinsic::pow>(m_SpecificFP(2.0),
5209 match(Op0, m_Intrinsic<Intrinsic::pow>(m_SpecificFP(10.0),
5225 if (match(Op0, m_SIToFP(m_Value())) || match(Op0, m_UIToFP(m_Value())))
5226 return Op0;
5236 static Value *simplifyBinaryIntrinsic(Function *F, Value *Op0, Value *Op1,
5244 if (Op0 == Op1)
5253 if (isa<UndefValue>(Op0) || isa<UndefValue>(Op1)) {
5264 if (match(Op0, m_Zero()) || match(Op1, m_Zero()))
5268 if (match(Op0, m_Undef()) || match(Op1, m_Undef()))
5274 if (match(Op0, m_AllOnes()) || match(Op1, m_AllOnes()))
5282 if (match(Op0, m_Undef()) || match(Op1, m_Undef()))
5287 return Op0;
5289 if (match(Op0, m_Zero()))
5294 if (match(Op0, m_Zero()) || match(Op1, m_AllOnes()))
5299 if (Op0 == Op1 || match(Op0, m_Undef()) || match(Op1, m_Undef()))
5303 return Op0;
5306 if (auto *C0 = dyn_cast<Constant>(Op0))
5314 return ConstantFP::get(Op0->getType(), 1.0);
5317 return Op0;
5322 if (Op0 == Op1)
5323 return Op0;
5326 if (match(Op0, m_FNeg(m_Specific(Op1))) ||
5327 match(Op1, m_FNeg(m_Specific(Op0))))
5335 if (Op0 == Op1) return Op0;
5338 if (match(Op0, m_Undef()))
5341 return Op0;
5345 if (match(Op0, m_NaN()))
5346 return PropagateNaN ? Op0 : Op1;
5348 return PropagateNaN ? Op1 : Op0;
5352 if (auto *M0 = dyn_cast<IntrinsicInst>(Op0))
5355 return Op0;
5358 (M1->getOperand(0) == Op0 || M1->getOperand(1) == Op0))
5365 if ((match(Op0, m_APFloat(C)) && C->isInfinity() &&
5413 Value *Op0 = Call->getArgOperand(0), *Op1 = Call->getArgOperand(1),
5417 if (match(Op0, m_Undef()) && match(Op1, m_Undef()))
5435 Value *Op0 = Call->getArgOperand(0);
5438 if (Value *V = simplifyFPOp({ Op0, Op1, Op2 }))
5488 static Value *SimplifyFreezeInst(Value *Op0, const SimplifyQuery &Q) {
5490 if (llvm::isGuaranteedNotToBeUndefOrPoison(Op0, Q.CxtI, Q.DT))
5491 return Op0;
5496 Value *llvm::SimplifyFreezeInst(Value *Op0, const SimplifyQuery &Q) {
5497 return ::SimplifyFreezeInst(Op0, Q);