reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

lib/Transforms/Scalar/Reassociate.cpp
 2073   if (!isa<UnaryOperator>(I) && !isa<BinaryOperator>(I))
 2073   if (!isa<UnaryOperator>(I) && !isa<BinaryOperator>(I))
 2076   if (I->getOpcode() == Instruction::Shl && isa<ConstantInt>(I->getOperand(1)))
 2076   if (I->getOpcode() == Instruction::Shl && isa<ConstantInt>(I->getOperand(1)))
 2079     if (isReassociableOp(I->getOperand(0), Instruction::Mul) ||
 2080         (I->hasOneUse() &&
 2081          (isReassociableOp(I->user_back(), Instruction::Mul) ||
 2082           isReassociableOp(I->user_back(), Instruction::Add)))) {
 2083       Instruction *NI = ConvertShiftToMul(I);
 2084       RedoInsts.insert(I);
 2086       I = NI;
 2092   if (I->isCommutative())
 2093     canonicalizeOperands(I);
 2096   if (Instruction *Res = canonicalizeNegFPConstants(I))
 2097     I = Res;
 2100   if (I->getType()->isFPOrFPVectorTy() && !I->isFast())
 2100   if (I->getType()->isFPOrFPVectorTy() && !I->isFast())
 2109   if (I->getType()->isIntegerTy(1))
 2114   if (I->getOpcode() == Instruction::Sub) {
 2115     if (ShouldBreakUpSubtract(I)) {
 2116       Instruction *NI = BreakUpSubtract(I, RedoInsts);
 2117       RedoInsts.insert(I);
 2119       I = NI;
 2120     } else if (match(I, m_Neg(m_Value()))) {
 2123       if (isReassociableOp(I->getOperand(1), Instruction::Mul) &&
 2124           (!I->hasOneUse() ||
 2125            !isReassociableOp(I->user_back(), Instruction::Mul))) {
 2126         Instruction *NI = LowerNegateToMultiply(I);
 2133         RedoInsts.insert(I);
 2135         I = NI;
 2138   } else if (I->getOpcode() == Instruction::FNeg ||
 2139              I->getOpcode() == Instruction::FSub) {
 2140     if (ShouldBreakUpSubtract(I)) {
 2141       Instruction *NI = BreakUpSubtract(I, RedoInsts);
 2142       RedoInsts.insert(I);
 2144       I = NI;
 2145     } else if (match(I, m_FNeg(m_Value()))) {
 2148       Value *Op = isa<BinaryOperator>(I) ? I->getOperand(1) :
 2148       Value *Op = isa<BinaryOperator>(I) ? I->getOperand(1) :
 2149                                            I->getOperand(0);
 2151           (!I->hasOneUse() ||
 2152            !isReassociableOp(I->user_back(), Instruction::FMul))) {
 2155         Instruction *NI = LowerNegateToMultiply(I);
 2160         RedoInsts.insert(I);
 2162         I = NI;
 2168   if (!I->isAssociative()) return;
 2169   BinaryOperator *BO = cast<BinaryOperator>(I);