Lines Matching refs:Instruction
75 static void PrintOps(Instruction *I, const SmallVectorImpl<ValueEntry> &Ops) { in PrintOps()
77 dbgs() << Instruction::getOpcodeName(I->getOpcode()) << " " in PrintOps()
120 Instruction *I = dyn_cast<Instruction>(V); in XorOpnd()
123 if (I && (I->getOpcode() == Instruction::Or || in XorOpnd()
124 I->getOpcode() == Instruction::And)) { in XorOpnd()
134 isOr = (I->getOpcode() == Instruction::Or); in XorOpnd()
149 static bool hasFPAssociativeFlags(Instruction *I) { in hasFPAssociativeFlags()
192 for (Instruction &I : *BB) in BuildRankMap()
199 Instruction *I = dyn_cast<Instruction>(V); in getRank()
229 void ReassociatePass::canonicalizeOperands(Instruction *I) { in canonicalizeOperands()
242 Instruction *InsertBefore, Value *FlagsOp) { in CreateAdd()
254 Instruction *InsertBefore, Value *FlagsOp) { in CreateMul()
265 static Instruction *CreateNeg(Value *S1, const Twine &Name, in CreateNeg()
266 Instruction *InsertBefore, Value *FlagsOp) { in CreateNeg()
270 if (auto *FMFSource = dyn_cast<Instruction>(FlagsOp)) in CreateNeg()
277 static BinaryOperator *LowerNegateToMultiply(Instruction *Neg) { in LowerNegateToMultiply()
330 if (Instruction::isIdempotent(Opcode)) { in IncorporateWeight()
337 if (Instruction::isNilpotent(Opcode)) { in IncorporateWeight()
343 if (Opcode == Instruction::Add || Opcode == Instruction::FAdd) { in IncorporateWeight()
349 assert((Opcode == Instruction::Mul || Opcode == Instruction::FMul) && in IncorporateWeight()
460 static bool LinearizeExprTree(Instruction *I, in LinearizeExprTree()
481 SmallVector<std::pair<Instruction*, APInt>, 8> Worklist; // (Op, Weight) in LinearizeExprTree()
508 std::pair<Instruction*, APInt> P = Worklist.pop_back_val(); in LinearizeExprTree()
582 assert((!isa<Instruction>(Op) || in LinearizeExprTree()
583 cast<Instruction>(Op)->getOpcode() != Opcode in LinearizeExprTree()
585 !hasFPAssociativeFlags(cast<Instruction>(Op)))) && in LinearizeExprTree()
594 Instruction *Neg; in LinearizeExprTree()
595 if (((Opcode == Instruction::Mul && match(Op, m_Neg(m_Value()))) || in LinearizeExprTree()
596 (Opcode == Instruction::FMul && match(Op, m_FNeg(m_Value())))) && in LinearizeExprTree()
600 Instruction *Mul = LowerNegateToMultiply(Neg); in LinearizeExprTree()
779 NewOp = BinaryOperator::Create(Instruction::BinaryOps(Opcode), in RewriteExprTree()
834 static Value *NegateValue(Value *V, Instruction *BI, in NegateValue()
850 isReassociableOp(V, Instruction::Add, Instruction::FAdd)) { in NegateValue()
854 if (I->getOpcode() == Instruction::Add) { in NegateValue()
883 Instruction *TheNeg = cast<Instruction>(U); in NegateValue()
892 if (Instruction *InstInput = dyn_cast<Instruction>(V)) { in NegateValue()
923 if (TheNeg->getOpcode() == Instruction::Sub) { in NegateValue()
935 Instruction *NewNeg = CreateNeg(V, V->getName() + ".neg", BI, BI); in NegateValue()
945 static bool isLoadCombineCandidate(Instruction *Or) { in isLoadCombineCandidate()
946 SmallVector<Instruction *, 8> Worklist; in isLoadCombineCandidate()
947 SmallSet<Instruction *, 8> Visited; in isLoadCombineCandidate()
950 auto *I = dyn_cast<Instruction>(V); in isLoadCombineCandidate()
968 case Instruction::Or: in isLoadCombineCandidate()
975 case Instruction::Shl: in isLoadCombineCandidate()
976 case Instruction::ZExt: in isLoadCombineCandidate()
982 case Instruction::Load: in isLoadCombineCandidate()
995 static bool shouldConvertOrWithNoCommonBitsToAdd(Instruction *Or) { in shouldConvertOrWithNoCommonBitsToAdd()
1000 for (auto Op : {Instruction::Add, Instruction::Sub, Instruction::Mul, in shouldConvertOrWithNoCommonBitsToAdd()
1001 Instruction::Shl}) in shouldConvertOrWithNoCommonBitsToAdd()
1019 static BinaryOperator *convertOrWithNoCommonBitsToAdd(Instruction *Or) { in convertOrWithNoCommonBitsToAdd()
1036 static bool ShouldBreakUpSubtract(Instruction *Sub) { in ShouldBreakUpSubtract()
1048 if (isReassociableOp(V0, Instruction::Add, Instruction::FAdd) || in ShouldBreakUpSubtract()
1049 isReassociableOp(V0, Instruction::Sub, Instruction::FSub)) in ShouldBreakUpSubtract()
1052 if (isReassociableOp(V1, Instruction::Add, Instruction::FAdd) || in ShouldBreakUpSubtract()
1053 isReassociableOp(V1, Instruction::Sub, Instruction::FSub)) in ShouldBreakUpSubtract()
1057 (isReassociableOp(VB, Instruction::Add, Instruction::FAdd) || in ShouldBreakUpSubtract()
1058 isReassociableOp(VB, Instruction::Sub, Instruction::FSub))) in ShouldBreakUpSubtract()
1066 static BinaryOperator *BreakUpSubtract(Instruction *Sub, in BreakUpSubtract()
1089 static BinaryOperator *ConvertShiftToMul(Instruction *Shl) { in ConvertShiftToMul()
1126 if (Instruction *I1 = dyn_cast<Instruction>(Ops[j].Op)) in FindInOperandList()
1127 if (Instruction *I2 = dyn_cast<Instruction>(X)) in FindInOperandList()
1135 if (Instruction *I1 = dyn_cast<Instruction>(Ops[j].Op)) in FindInOperandList()
1136 if (Instruction *I2 = dyn_cast<Instruction>(X)) in FindInOperandList()
1145 static Value *EmitAddTreeOfValues(Instruction *I, in EmitAddTreeOfValues()
1158 BinaryOperator *BO = isReassociableOp(V, Instruction::Mul, Instruction::FMul); in RemoveFactorFromExpression()
1233 BinaryOperator *BO = isReassociableOp(V, Instruction::Mul, Instruction::FMul); in FindSingleUseMultiplyFactors()
1258 if (Opcode == Instruction::And) // ...&X&~X = 0 in OptimizeAndOrXor()
1261 if (Opcode == Instruction::Or) // ...|X|~X = -1 in OptimizeAndOrXor()
1270 if (Opcode == Instruction::And || Opcode == Instruction::Or) { in OptimizeAndOrXor()
1279 assert(Opcode == Instruction::Xor); in OptimizeAndOrXor()
1297 static Value *createAndInstr(Instruction *InsertBefore, Value *Opnd, in createAndInstr()
1305 Instruction *I = BinaryOperator::CreateAnd( in createAndInstr()
1318 bool ReassociatePass::CombineXorOpnd(Instruction *I, XorOpnd *Opnd1, in CombineXorOpnd()
1339 if (Instruction *T = dyn_cast<Instruction>(Opnd1->getValue())) in CombineXorOpnd()
1352 bool ReassociatePass::CombineXorOpnd(Instruction *I, XorOpnd *Opnd1, in CombineXorOpnd()
1416 if (Instruction *T = dyn_cast<Instruction>(Opnd1->getValue())) in CombineXorOpnd()
1418 if (Instruction *T = dyn_cast<Instruction>(Opnd2->getValue())) in CombineXorOpnd()
1427 Value *ReassociatePass::OptimizeXor(Instruction *I, in OptimizeXor()
1429 if (Value *V = OptimizeAndOrXor(Instruction::Xor, Ops)) in OptimizeXor()
1549 Value *ReassociatePass::OptimizeAdd(Instruction *I, in OptimizeAdd()
1577 Instruction *Mul = CreateMul(TheOp, C, "factor", I, I); in OptimizeAdd()
1648 isReassociableOp(Ops[i].Op, Instruction::Mul, Instruction::FMul); in OptimizeAdd()
1711 Instruction *DummyInst = in OptimizeAdd()
1720 isReassociableOp(Ops[i].Op, Instruction::Mul, Instruction::FMul); in OptimizeAdd()
1749 if (Instruction *VI = dyn_cast<Instruction>(V)) in OptimizeAdd()
1753 Instruction *V2 = CreateMul(V, MaxOccVal, "reass.mul", I, I); in OptimizeAdd()
1885 if (Instruction *MI = dyn_cast<Instruction>(M)) in buildMinimalMultiplyDAG()
1990 case Instruction::And: in OptimizeExpression()
1991 case Instruction::Or: in OptimizeExpression()
1996 case Instruction::Xor: in OptimizeExpression()
2001 case Instruction::Add: in OptimizeExpression()
2002 case Instruction::FAdd: in OptimizeExpression()
2007 case Instruction::Mul: in OptimizeExpression()
2008 case Instruction::FMul: in OptimizeExpression()
2021 void ReassociatePass::RecursivelyEraseDeadInsts(Instruction *I, in RecursivelyEraseDeadInsts()
2031 if (Instruction *OpInst = dyn_cast<Instruction>(Op)) in RecursivelyEraseDeadInsts()
2037 void ReassociatePass::EraseInst(Instruction *I) { in EraseInst()
2048 SmallPtrSet<Instruction *, 8> Visited; // Detect self-referential nodes. in EraseInst()
2050 if (Instruction *Op = dyn_cast<Instruction>(Ops[i])) { in EraseInst()
2074 SmallVectorImpl<Instruction *> &Candidates) { in getNegatibleInsts()
2077 Instruction *I; in getNegatibleInsts()
2085 case Instruction::FMul: in getNegatibleInsts()
2097 case Instruction::FDiv: in getNegatibleInsts()
2119 Instruction *ReassociatePass::canonicalizeNegFPConstantsForOp(Instruction *I, in canonicalizeNegFPConstantsForOp()
2120 Instruction *Op, in canonicalizeNegFPConstantsForOp()
2122 assert((I->getOpcode() == Instruction::FAdd || in canonicalizeNegFPConstantsForOp()
2123 I->getOpcode() == Instruction::FSub) && "Expected fadd/fsub"); in canonicalizeNegFPConstantsForOp()
2127 SmallVector<Instruction *, 4> Candidates; in canonicalizeNegFPConstantsForOp()
2135 bool IsFSub = I->getOpcode() == Instruction::FSub; in canonicalizeNegFPConstantsForOp()
2140 for (Instruction *Negatible : Candidates) { in canonicalizeNegFPConstantsForOp()
2171 return dyn_cast<Instruction>(NewInst); in canonicalizeNegFPConstantsForOp()
2182 Instruction *ReassociatePass::canonicalizeNegFPConstants(Instruction *I) { in canonicalizeNegFPConstants()
2185 Instruction *Op; in canonicalizeNegFPConstants()
2187 if (Instruction *R = canonicalizeNegFPConstantsForOp(I, Op, X)) in canonicalizeNegFPConstants()
2190 if (Instruction *R = canonicalizeNegFPConstantsForOp(I, Op, X)) in canonicalizeNegFPConstants()
2193 if (Instruction *R = canonicalizeNegFPConstantsForOp(I, Op, X)) in canonicalizeNegFPConstants()
2200 void ReassociatePass::OptimizeInst(Instruction *I) { in OptimizeInst()
2205 if (I->getOpcode() == Instruction::Shl && isa<ConstantInt>(I->getOperand(1))) in OptimizeInst()
2208 if (isReassociableOp(I->getOperand(0), Instruction::Mul) || in OptimizeInst()
2210 (isReassociableOp(I->user_back(), Instruction::Mul) || in OptimizeInst()
2211 isReassociableOp(I->user_back(), Instruction::Add)))) { in OptimizeInst()
2212 Instruction *NI = ConvertShiftToMul(I); in OptimizeInst()
2225 if (Instruction *Res = canonicalizeNegFPConstants(I)) in OptimizeInst()
2244 if (I->getOpcode() == Instruction::Or && in OptimizeInst()
2249 Instruction *NI = convertOrWithNoCommonBitsToAdd(I); in OptimizeInst()
2257 if (I->getOpcode() == Instruction::Sub) { in OptimizeInst()
2259 Instruction *NI = BreakUpSubtract(I, RedoInsts); in OptimizeInst()
2266 if (isReassociableOp(I->getOperand(1), Instruction::Mul) && in OptimizeInst()
2268 !isReassociableOp(I->user_back(), Instruction::Mul))) { in OptimizeInst()
2269 Instruction *NI = LowerNegateToMultiply(I); in OptimizeInst()
2281 } else if (I->getOpcode() == Instruction::FNeg || in OptimizeInst()
2282 I->getOpcode() == Instruction::FSub) { in OptimizeInst()
2284 Instruction *NI = BreakUpSubtract(I, RedoInsts); in OptimizeInst()
2293 if (isReassociableOp(Op, Instruction::FMul) && in OptimizeInst()
2295 !isReassociableOp(I->user_back(), Instruction::FMul))) { in OptimizeInst()
2298 Instruction *NI = LowerNegateToMultiply(I); in OptimizeInst()
2329 if (BO->hasOneUse() && BO->getOpcode() == Instruction::Add && in OptimizeInst()
2330 cast<Instruction>(BO->user_back())->getOpcode() == Instruction::Sub) in OptimizeInst()
2332 if (BO->hasOneUse() && BO->getOpcode() == Instruction::FAdd && in OptimizeInst()
2333 cast<Instruction>(BO->user_back())->getOpcode() == Instruction::FSub) in OptimizeInst()
2369 if (Instruction *VI = dyn_cast<Instruction>(V)) in ReassociateExpression()
2382 if (I->getOpcode() == Instruction::Mul && in ReassociateExpression()
2383 cast<Instruction>(I->user_back())->getOpcode() == Instruction::Add && in ReassociateExpression()
2388 } else if (I->getOpcode() == Instruction::FMul && in ReassociateExpression()
2389 cast<Instruction>(I->user_back())->getOpcode() == in ReassociateExpression()
2390 Instruction::FAdd && in ReassociateExpression()
2408 if (Instruction *OI = dyn_cast<Instruction>(Ops[0].Op)) in ReassociateExpression()
2424 unsigned Idx = I->getOpcode() - Instruction::BinaryOpsBegin; in ReassociateExpression()
2468 for (Instruction &I : *BI) { in BuildPairMap()
2483 Instruction *OpI = dyn_cast<Instruction>(Op); in BuildPairMap()
2499 unsigned BinaryIdx = I.getOpcode() - Instruction::BinaryOpsBegin; in BuildPairMap()
2569 Instruction *I = ToRedo.pop_back_val(); in run()
2579 Instruction *I = RedoInsts.front(); in run()