Lines Matching defs:Ops
76 /// Print out the expression identified in the Ops list.
77 static void PrintOps(Instruction *I, const SmallVectorImpl<ValueEntry> &Ops) {
80 << *Ops[0].Op->getType() << '\t';
81 for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
83 Ops[i].Op->printAsOperand(dbgs(), false, M);
84 dbgs() << ", #" << Ops[i].Rank << "] ";
381 /// nodes in Ops along with their weights (how many times the leaf occurs). The
383 /// (Ops[0].first op Ops[0].first op ... Ops[0].first) <- Ops[0].second times
385 /// (Ops[1].first op Ops[1].first op ... Ops[1].first) <- Ops[1].second times
389 /// (Ops[N].first op Ops[N].first op ... Ops[N].first) <- Ops[N].second times
391 /// Note that the values Ops[0].first, ..., Ops[N].first are all distinct.
396 /// you MUST either replace I with a new expression computed from the Ops array,
418 /// The leaf nodes are C, E, F and G. The Ops array will contain (maybe not in
454 SmallVectorImpl<RepeatedValue> &Ops) {
619 Ops.push_back(std::make_pair(V, Weight));
625 if (Ops.empty()) {
628 Ops.emplace_back(Identity, APInt(Bitwidth, 1));
637 SmallVectorImpl<ValueEntry> &Ops) {
638 assert(Ops.size() > 1 && "Single values should be used directly!");
666 for (unsigned i = 0, e = Ops.size(); i != e; ++i)
667 NotRewritable.insert(Ops[i].Op);
675 // operands will come from Ops, rather than just one with the other being
677 if (i+2 == Ops.size()) {
678 Value *NewLHS = Ops[i].Op;
679 Value *NewRHS = Ops[i+1].Op;
722 // while the right-hand side will be the current element of Ops.
723 Value *NewRHS = Ops[i].Op;
782 // expression tree is dominated by all of Ops.
1007 static unsigned FindInOperandList(const SmallVectorImpl<ValueEntry> &Ops,
1009 unsigned XRank = Ops[i].Rank;
1010 unsigned e = Ops.size();
1011 for (unsigned j = i+1; j != e && Ops[j].Rank == XRank; ++j) {
1012 if (Ops[j].Op == X)
1014 if (Instruction *I1 = dyn_cast<Instruction>(Ops[j].Op))
1020 for (unsigned j = i-1; j != ~0U && Ops[j].Rank == XRank; --j) {
1021 if (Ops[j].Op == X)
1023 if (Instruction *I1 = dyn_cast<Instruction>(Ops[j].Op))
1031 /// Emit a tree of add instructions, summing Ops together
1034 SmallVectorImpl<WeakTrackingVH> &Ops) {
1035 if (Ops.size() == 1) return Ops.back();
1037 Value *V1 = Ops.back();
1038 Ops.pop_back();
1039 Value *V2 = EmitAddTreeOfValues(I, Ops);
1119 /// Ops is the top-level list of add operands we're trying to factor.
1135 /// it is returned, otherwise the Ops list is mutated as necessary.
1137 SmallVectorImpl<ValueEntry> &Ops) {
1140 for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
1142 assert(i < Ops.size());
1144 if (match(Ops[i].Op, m_Not(m_Value(X)))) { // Cannot occur for ^.
1145 unsigned FoundX = FindInOperandList(Ops, i, X);
1157 assert(i < Ops.size());
1158 if (i+1 != Ops.size() && Ops[i+1].Op == Ops[i].Op) {
1161 Ops.erase(Ops.begin()+i);
1170 return Constant::getNullValue(Ops[0].Op->getType());
1173 Ops.erase(Ops.begin()+i, Ops.begin()+i+2);
1314 /// to a single Value, it is returned, otherwise the Ops list is mutated as
1317 SmallVectorImpl<ValueEntry> &Ops) {
1318 if (Value *V = OptimizeAndOrXor(Instruction::Xor, Ops))
1321 if (Ops.size() == 1)
1326 Type *Ty = Ops[0].Op->getType();
1330 for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
1331 Value *V = Ops[i].Op;
1409 // Step 4: Reassemble the Ops
1411 Ops.clear();
1417 Ops.push_back(VE);
1422 Ops.push_back(VE);
1424 unsigned Sz = Ops.size();
1426 return Ops.back().Op;
1438 /// is returned, otherwise the Ops list is mutated as necessary.
1440 SmallVectorImpl<ValueEntry> &Ops) {
1446 for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
1447 Value *TheOp = Ops[i].Op;
1451 if (i+1 != Ops.size() && Ops[i+1].Op == TheOp) {
1455 Ops.erase(Ops.begin()+i);
1457 } while (i != Ops.size() && Ops[i].Op == TheOp);
1475 if (Ops.empty())
1481 Ops.insert(Ops.begin(), ValueEntry(getRank(Mul), Mul));
1484 e = Ops.size();
1494 unsigned FoundX = FindInOperandList(Ops, i, X);
1499 if (Ops.size() == 2 &&
1504 if (Ops.size() == 2 && match(TheOp, m_Not(m_Value())))
1507 Ops.erase(Ops.begin()+i);
1512 Ops.erase(Ops.begin()+FoundX);
1520 Ops.insert(Ops.end(), ValueEntry(getRank(V), V));
1536 for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
1538 isReassociableOp(Ops[i].Op, Instruction::Mul, Instruction::FMul);
1607 for (unsigned i = 0; i != Ops.size(); ++i) {
1610 isReassociableOp(Ops[i].Op, Instruction::Mul, Instruction::FMul);
1614 if (Value *V = RemoveFactorFromExpression(Ops[i].Op, MaxOccVal)) {
1617 for (unsigned j = Ops.size(); j != i;) {
1619 if (Ops[j].Op == Ops[i].Op) {
1621 Ops.erase(Ops.begin()+j);
1651 if (Ops.empty())
1657 Ops.insert(Ops.begin(), ValueEntry(getRank(V2), V2));
1674 static bool collectMultiplyFactors(SmallVectorImpl<ValueEntry> &Ops,
1676 // FIXME: Have Ops be (ValueEntry, Multiplicity) pairs, simplifying this.
1679 for (unsigned Idx = 1, Size = Ops.size(); Idx < Size; ++Idx) {
1680 Value *Op = Ops[Idx-1].Op;
1684 for (; Idx < Size && Ops[Idx].Op == Op; ++Idx)
1698 // Now gather the simplifiable factors, removing them from Ops.
1700 for (unsigned Idx = 1; Idx < Ops.size(); ++Idx) {
1701 Value *Op = Ops[Idx-1].Op;
1705 for (; Idx < Ops.size() && Ops[Idx].Op == Op; ++Idx)
1714 Ops.erase(Ops.begin()+Idx, Ops.begin()+Idx+Count);
1727 /// Build a tree of multiplies, computing the product of Ops.
1729 SmallVectorImpl<Value*> &Ops) {
1730 if (Ops.size() == 1)
1731 return Ops.back();
1733 Value *LHS = Ops.pop_back_val();
1736 LHS = Builder.CreateMul(LHS, Ops.pop_back_val());
1738 LHS = Builder.CreateFMul(LHS, Ops.pop_back_val());
1739 } while (!Ops.empty());
1809 SmallVectorImpl<ValueEntry> &Ops) {
1812 if (Ops.size() < 4)
1819 if (!collectMultiplyFactors(Ops, Factors))
1830 if (Ops.empty())
1834 Ops.insert(llvm::lower_bound(Ops, NewEntry), NewEntry);
1839 SmallVectorImpl<ValueEntry> &Ops) {
1844 while (!Ops.empty() && isa<Constant>(Ops.back().Op)) {
1845 Constant *C = cast<Constant>(Ops.pop_back_val().Op);
1849 if (Ops.empty())
1858 Ops.push_back(ValueEntry(0, Cst));
1861 if (Ops.size() == 1) return Ops[0].Op;
1865 unsigned NumOps = Ops.size();
1870 if (Value *Result = OptimizeAndOrXor(Opcode, Ops))
1875 if (Value *Result = OptimizeXor(I, Ops))
1881 if (Value *Result = OptimizeAdd(I, Ops))
1887 if (Value *Result = OptimizeMul(I, Ops))
1892 if (Ops.size() != NumOps)
1893 return OptimizeExpression(I, Ops);
1902 SmallVector<Value *, 4> Ops(I->op_begin(), I->op_end());
1908 for (auto Op : Ops)
1919 SmallVector<Value*, 8> Ops(I->op_begin(), I->op_end());
1927 for (unsigned i = 0, e = Ops.size(); i != e; ++i)
1928 if (Instruction *Op = dyn_cast<Instruction>(Ops[i])) {
2208 SmallVector<ValueEntry, 8> Ops;
2209 Ops.reserve(Tree.size());
2212 Ops.append(E.second.getZExtValue(),
2216 LLVM_DEBUG(dbgs() << "RAIn:\t"; PrintOps(I, Ops); dbgs() << '\n');
2224 llvm::stable_sort(Ops);
2228 if (Value *V = OptimizeExpression(I, Ops)) {
2251 isa<ConstantInt>(Ops.back().Op) &&
2252 cast<ConstantInt>(Ops.back().Op)->isMinusOne()) {
2253 ValueEntry Tmp = Ops.pop_back_val();
2254 Ops.insert(Ops.begin(), Tmp);
2258 isa<ConstantFP>(Ops.back().Op) &&
2259 cast<ConstantFP>(Ops.back().Op)->isExactlyValue(-1.0)) {
2260 ValueEntry Tmp = Ops.pop_back_val();
2261 Ops.insert(Ops.begin(), Tmp);
2265 LLVM_DEBUG(dbgs() << "RAOut:\t"; PrintOps(I, Ops); dbgs() << '\n');
2267 if (Ops.size() == 1) {
2268 if (Ops[0].Op == I)
2274 I->replaceAllUsesWith(Ops[0].Op);
2275 if (Instruction *OI = dyn_cast<Instruction>(Ops[0].Op))
2281 if (Ops.size() > 2 && Ops.size() <= GlobalReassociateLimit) {
2292 for (unsigned i = 0; i < Ops.size() - 1; ++i)
2293 for (unsigned j = i + 1; j < Ops.size(); ++j) {
2295 Value *Op0 = Ops[i].Op;
2296 Value *Op1 = Ops[j].Op;
2310 unsigned MaxRank = std::max(Ops[i].Rank, Ops[j].Rank);
2318 auto Op0 = Ops[BestPair.first];
2319 auto Op1 = Ops[BestPair.second];
2320 Ops.erase(&Ops[BestPair.second]);
2321 Ops.erase(&Ops[BestPair.first]);
2322 Ops.push_back(Op0);
2323 Ops.push_back(Op1);
2328 RewriteExprTree(I, Ops);
2347 SmallVector<Value *, 8> Ops;
2348 while (!Worklist.empty() && Ops.size() <= GlobalReassociateLimit) {
2352 Ops.push_back(Op);
2362 if (Ops.size() > GlobalReassociateLimit)
2368 for (unsigned i = 0; i < Ops.size() - 1; ++i) {
2369 for (unsigned j = i + 1; j < Ops.size(); ++j) {
2371 Value *Op0 = Ops[i];
2372 Value *Op1 = Ops[j];