Lines Matching refs:Instruction
82 static void PrintOps(Instruction *I, const SmallVectorImpl<ValueEntry> &Ops) { in PrintOps()
84 dbgs() << Instruction::getOpcodeName(I->getOpcode()) << " " in PrintOps()
127 Instruction *I = dyn_cast<Instruction>(V); in XorOpnd()
130 if (I && (I->getOpcode() == Instruction::Or || in XorOpnd()
131 I->getOpcode() == Instruction::And)) { in XorOpnd()
141 isOr = (I->getOpcode() == Instruction::Or); in XorOpnd()
156 static bool hasFPAssociativeFlags(Instruction *I) { in hasFPAssociativeFlags()
199 for (Instruction &I : *BB) in BuildRankMap()
206 Instruction *I = dyn_cast<Instruction>(V); in getRank()
236 void ReassociatePass::canonicalizeOperands(Instruction *I) { in canonicalizeOperands()
249 Instruction *InsertBefore, Value *FlagsOp) { in CreateAdd()
261 Instruction *InsertBefore, Value *FlagsOp) { in CreateMul()
272 static Instruction *CreateNeg(Value *S1, const Twine &Name, in CreateNeg()
273 Instruction *InsertBefore, Value *FlagsOp) { in CreateNeg()
277 if (auto *FMFSource = dyn_cast<Instruction>(FlagsOp)) in CreateNeg()
284 static BinaryOperator *LowerNegateToMultiply(Instruction *Neg) { in LowerNegateToMultiply()
337 if (Instruction::isIdempotent(Opcode)) { in IncorporateWeight()
344 if (Instruction::isNilpotent(Opcode)) { in IncorporateWeight()
350 if (Opcode == Instruction::Add || Opcode == Instruction::FAdd) { in IncorporateWeight()
356 assert((Opcode == Instruction::Mul || Opcode == Instruction::FMul) && in IncorporateWeight()
467 static bool LinearizeExprTree(Instruction *I, in LinearizeExprTree()
489 SmallVector<std::pair<Instruction*, APInt>, 8> Worklist; // (Op, Weight) in LinearizeExprTree()
516 std::pair<Instruction*, APInt> P = Worklist.pop_back_val(); in LinearizeExprTree()
593 assert((!isa<Instruction>(Op) || in LinearizeExprTree()
594 cast<Instruction>(Op)->getOpcode() != Opcode in LinearizeExprTree()
596 !hasFPAssociativeFlags(cast<Instruction>(Op)))) && in LinearizeExprTree()
605 Instruction *Neg; in LinearizeExprTree()
606 if (((Opcode == Instruction::Mul && match(Op, m_Neg(m_Value()))) || in LinearizeExprTree()
607 (Opcode == Instruction::FMul && match(Op, m_FNeg(m_Value())))) && in LinearizeExprTree()
611 Instruction *Mul = LowerNegateToMultiply(Neg); in LinearizeExprTree()
796 NewOp = BinaryOperator::Create(Instruction::BinaryOps(Opcode), in RewriteExprTree()
833 if (HasNUW && ExpressionChangedStart->getOpcode() == Instruction::Add) in RewriteExprTree()
868 static Value *NegateValue(Value *V, Instruction *BI, in NegateValue()
873 ? ConstantFoldUnaryOpOperand(Instruction::FNeg, C, DL) in NegateValue()
889 isReassociableOp(V, Instruction::Add, Instruction::FAdd)) { in NegateValue()
893 if (I->getOpcode() == Instruction::Add) { in NegateValue()
922 Instruction *TheNeg = dyn_cast<Instruction>(U); in NegateValue()
936 if (Instruction *InstInput = dyn_cast<Instruction>(V)) { in NegateValue()
949 if (TheNeg->getOpcode() == Instruction::Sub) { in NegateValue()
961 Instruction *NewNeg = CreateNeg(V, V->getName() + ".neg", BI, BI); in NegateValue()
971 static bool isLoadCombineCandidate(Instruction *Or) { in isLoadCombineCandidate()
972 SmallVector<Instruction *, 8> Worklist; in isLoadCombineCandidate()
973 SmallSet<Instruction *, 8> Visited; in isLoadCombineCandidate()
976 auto *I = dyn_cast<Instruction>(V); in isLoadCombineCandidate()
994 case Instruction::Or: in isLoadCombineCandidate()
1001 case Instruction::Shl: in isLoadCombineCandidate()
1002 case Instruction::ZExt: in isLoadCombineCandidate()
1008 case Instruction::Load: in isLoadCombineCandidate()
1021 static bool shouldConvertOrWithNoCommonBitsToAdd(Instruction *Or) { in shouldConvertOrWithNoCommonBitsToAdd()
1026 for (auto Op : {Instruction::Add, Instruction::Sub, Instruction::Mul, in shouldConvertOrWithNoCommonBitsToAdd()
1027 Instruction::Shl}) in shouldConvertOrWithNoCommonBitsToAdd()
1045 static BinaryOperator *convertOrWithNoCommonBitsToAdd(Instruction *Or) { in convertOrWithNoCommonBitsToAdd()
1062 static bool ShouldBreakUpSubtract(Instruction *Sub) { in ShouldBreakUpSubtract()
1074 if (isReassociableOp(V0, Instruction::Add, Instruction::FAdd) || in ShouldBreakUpSubtract()
1075 isReassociableOp(V0, Instruction::Sub, Instruction::FSub)) in ShouldBreakUpSubtract()
1078 if (isReassociableOp(V1, Instruction::Add, Instruction::FAdd) || in ShouldBreakUpSubtract()
1079 isReassociableOp(V1, Instruction::Sub, Instruction::FSub)) in ShouldBreakUpSubtract()
1083 (isReassociableOp(VB, Instruction::Add, Instruction::FAdd) || in ShouldBreakUpSubtract()
1084 isReassociableOp(VB, Instruction::Sub, Instruction::FSub))) in ShouldBreakUpSubtract()
1092 static BinaryOperator *BreakUpSubtract(Instruction *Sub, in BreakUpSubtract()
1115 static BinaryOperator *ConvertShiftToMul(Instruction *Shl) { in ConvertShiftToMul()
1152 if (Instruction *I1 = dyn_cast<Instruction>(Ops[j].Op)) in FindInOperandList()
1153 if (Instruction *I2 = dyn_cast<Instruction>(X)) in FindInOperandList()
1161 if (Instruction *I1 = dyn_cast<Instruction>(Ops[j].Op)) in FindInOperandList()
1162 if (Instruction *I2 = dyn_cast<Instruction>(X)) in FindInOperandList()
1171 static Value *EmitAddTreeOfValues(Instruction *I, in EmitAddTreeOfValues()
1184 BinaryOperator *BO = isReassociableOp(V, Instruction::Mul, Instruction::FMul); in RemoveFactorFromExpression()
1260 BinaryOperator *BO = isReassociableOp(V, Instruction::Mul, Instruction::FMul); in FindSingleUseMultiplyFactors()
1285 if (Opcode == Instruction::And) // ...&X&~X = 0 in OptimizeAndOrXor()
1288 if (Opcode == Instruction::Or) // ...|X|~X = -1 in OptimizeAndOrXor()
1297 if (Opcode == Instruction::And || Opcode == Instruction::Or) { in OptimizeAndOrXor()
1306 assert(Opcode == Instruction::Xor); in OptimizeAndOrXor()
1324 static Value *createAndInstr(Instruction *InsertBefore, Value *Opnd, in createAndInstr()
1332 Instruction *I = BinaryOperator::CreateAnd( in createAndInstr()
1345 bool ReassociatePass::CombineXorOpnd(Instruction *I, XorOpnd *Opnd1, in CombineXorOpnd()
1366 if (Instruction *T = dyn_cast<Instruction>(Opnd1->getValue())) in CombineXorOpnd()
1379 bool ReassociatePass::CombineXorOpnd(Instruction *I, XorOpnd *Opnd1, in CombineXorOpnd()
1443 if (Instruction *T = dyn_cast<Instruction>(Opnd1->getValue())) in CombineXorOpnd()
1445 if (Instruction *T = dyn_cast<Instruction>(Opnd2->getValue())) in CombineXorOpnd()
1454 Value *ReassociatePass::OptimizeXor(Instruction *I, in OptimizeXor()
1456 if (Value *V = OptimizeAndOrXor(Instruction::Xor, Ops)) in OptimizeXor()
1575 Value *ReassociatePass::OptimizeAdd(Instruction *I, in OptimizeAdd()
1603 Instruction *Mul = CreateMul(TheOp, C, "factor", I, I); in OptimizeAdd()
1674 isReassociableOp(Ops[i].Op, Instruction::Mul, Instruction::FMul); in OptimizeAdd()
1736 Instruction *DummyInst = in OptimizeAdd()
1745 isReassociableOp(Ops[i].Op, Instruction::Mul, Instruction::FMul); in OptimizeAdd()
1774 if (Instruction *VI = dyn_cast<Instruction>(V)) in OptimizeAdd()
1778 Instruction *V2 = CreateMul(V, MaxOccVal, "reass.mul", I, I); in OptimizeAdd()
1910 if (Instruction *MI = dyn_cast<Instruction>(M)) in buildMinimalMultiplyDAG()
2015 case Instruction::And: in OptimizeExpression()
2016 case Instruction::Or: in OptimizeExpression()
2021 case Instruction::Xor: in OptimizeExpression()
2026 case Instruction::Add: in OptimizeExpression()
2027 case Instruction::FAdd: in OptimizeExpression()
2032 case Instruction::Mul: in OptimizeExpression()
2033 case Instruction::FMul: in OptimizeExpression()
2046 void ReassociatePass::RecursivelyEraseDeadInsts(Instruction *I, in RecursivelyEraseDeadInsts()
2056 if (Instruction *OpInst = dyn_cast<Instruction>(Op)) in RecursivelyEraseDeadInsts()
2062 void ReassociatePass::EraseInst(Instruction *I) { in EraseInst()
2073 SmallPtrSet<Instruction *, 8> Visited; // Detect self-referential nodes. in EraseInst()
2075 if (Instruction *Op = dyn_cast<Instruction>(Ops[i])) { in EraseInst()
2099 SmallVectorImpl<Instruction *> &Candidates) { in getNegatibleInsts()
2102 Instruction *I; in getNegatibleInsts()
2110 case Instruction::FMul: in getNegatibleInsts()
2122 case Instruction::FDiv: in getNegatibleInsts()
2144 Instruction *ReassociatePass::canonicalizeNegFPConstantsForOp(Instruction *I, in canonicalizeNegFPConstantsForOp()
2145 Instruction *Op, in canonicalizeNegFPConstantsForOp()
2147 assert((I->getOpcode() == Instruction::FAdd || in canonicalizeNegFPConstantsForOp()
2148 I->getOpcode() == Instruction::FSub) && "Expected fadd/fsub"); in canonicalizeNegFPConstantsForOp()
2152 SmallVector<Instruction *, 4> Candidates; in canonicalizeNegFPConstantsForOp()
2160 bool IsFSub = I->getOpcode() == Instruction::FSub; in canonicalizeNegFPConstantsForOp()
2165 for (Instruction *Negatible : Candidates) { in canonicalizeNegFPConstantsForOp()
2196 return dyn_cast<Instruction>(NewInst); in canonicalizeNegFPConstantsForOp()
2207 Instruction *ReassociatePass::canonicalizeNegFPConstants(Instruction *I) { in canonicalizeNegFPConstants()
2210 Instruction *Op; in canonicalizeNegFPConstants()
2212 if (Instruction *R = canonicalizeNegFPConstantsForOp(I, Op, X)) in canonicalizeNegFPConstants()
2215 if (Instruction *R = canonicalizeNegFPConstantsForOp(I, Op, X)) in canonicalizeNegFPConstants()
2218 if (Instruction *R = canonicalizeNegFPConstantsForOp(I, Op, X)) in canonicalizeNegFPConstants()
2225 void ReassociatePass::OptimizeInst(Instruction *I) { in OptimizeInst()
2230 if (I->getOpcode() == Instruction::Shl && isa<ConstantInt>(I->getOperand(1))) in OptimizeInst()
2233 if (isReassociableOp(I->getOperand(0), Instruction::Mul) || in OptimizeInst()
2235 (isReassociableOp(I->user_back(), Instruction::Mul) || in OptimizeInst()
2236 isReassociableOp(I->user_back(), Instruction::Add)))) { in OptimizeInst()
2237 Instruction *NI = ConvertShiftToMul(I); in OptimizeInst()
2250 if (Instruction *Res = canonicalizeNegFPConstants(I)) in OptimizeInst()
2269 if (I->getOpcode() == Instruction::Or && in OptimizeInst()
2275 Instruction *NI = convertOrWithNoCommonBitsToAdd(I); in OptimizeInst()
2283 if (I->getOpcode() == Instruction::Sub) { in OptimizeInst()
2285 Instruction *NI = BreakUpSubtract(I, RedoInsts); in OptimizeInst()
2292 if (isReassociableOp(I->getOperand(1), Instruction::Mul) && in OptimizeInst()
2294 !isReassociableOp(I->user_back(), Instruction::Mul))) { in OptimizeInst()
2295 Instruction *NI = LowerNegateToMultiply(I); in OptimizeInst()
2307 } else if (I->getOpcode() == Instruction::FNeg || in OptimizeInst()
2308 I->getOpcode() == Instruction::FSub) { in OptimizeInst()
2310 Instruction *NI = BreakUpSubtract(I, RedoInsts); in OptimizeInst()
2319 if (isReassociableOp(Op, Instruction::FMul) && in OptimizeInst()
2321 !isReassociableOp(I->user_back(), Instruction::FMul))) { in OptimizeInst()
2324 Instruction *NI = LowerNegateToMultiply(I); in OptimizeInst()
2355 if (BO->hasOneUse() && BO->getOpcode() == Instruction::Add && in OptimizeInst()
2356 cast<Instruction>(BO->user_back())->getOpcode() == Instruction::Sub) in OptimizeInst()
2358 if (BO->hasOneUse() && BO->getOpcode() == Instruction::FAdd && in OptimizeInst()
2359 cast<Instruction>(BO->user_back())->getOpcode() == Instruction::FSub) in OptimizeInst()
2396 if (Instruction *VI = dyn_cast<Instruction>(V)) in ReassociateExpression()
2409 if (I->getOpcode() == Instruction::Mul && in ReassociateExpression()
2410 cast<Instruction>(I->user_back())->getOpcode() == Instruction::Add && in ReassociateExpression()
2415 } else if (I->getOpcode() == Instruction::FMul && in ReassociateExpression()
2416 cast<Instruction>(I->user_back())->getOpcode() == in ReassociateExpression()
2417 Instruction::FAdd && in ReassociateExpression()
2435 if (Instruction *OI = dyn_cast<Instruction>(Ops[0].Op)) in ReassociateExpression()
2451 unsigned Idx = I->getOpcode() - Instruction::BinaryOpsBegin; in ReassociateExpression()
2469 const auto *CurrLeafInstr = dyn_cast<Instruction>(Val); in ReassociateExpression()
2570 for (Instruction &I : *BI) { in BuildPairMap()
2585 Instruction *OpI = dyn_cast<Instruction>(Op); in BuildPairMap()
2601 unsigned BinaryIdx = I.getOpcode() - Instruction::BinaryOpsBegin; in BuildPairMap()
2671 Instruction *I = ToRedo.pop_back_val(); in run()
2681 Instruction *I = RedoInsts.front(); in run()