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

References

lib/Transforms/Scalar/Reassociate.cpp
   78        << *Ops[0].Op->getType() << '\t';
   81     Ops[i].Op->printAsOperand(dbgs(), false, M);
  665     NotRewritable.insert(Ops[i].Op);
  676       Value *NewLHS = Ops[i].Op;
  677       Value *NewRHS = Ops[i+1].Op;
  721     Value *NewRHS = Ops[i].Op;
 1007     if (Ops[j].Op == X)
 1009     if (Instruction *I1 = dyn_cast<Instruction>(Ops[j].Op))
 1016     if (Ops[j].Op == X)
 1018     if (Instruction *I1 = dyn_cast<Instruction>(Ops[j].Op))
 1059     if (Factors[i].Op == Factor) {
 1067       if (ConstantInt *FC2 = dyn_cast<ConstantInt>(Factors[i].Op))
 1074       if (ConstantFP *FC2 = dyn_cast<ConstantFP>(Factors[i].Op)) {
 1099     V = Factors[0].Op;
 1139     if (match(Ops[i].Op, m_Not(m_Value(X)))) {    // Cannot occur for ^.
 1153     if (i+1 != Ops.size() && Ops[i+1].Op == Ops[i].Op) {
 1153     if (i+1 != Ops.size() && Ops[i+1].Op == Ops[i].Op) {
 1165         return Constant::getNullValue(Ops[0].Op->getType());
 1321   Type *Ty = Ops[0].Op->getType();
 1326     Value *V = Ops[i].Op;
 1421       return Ops.back().Op;
 1442     Value *TheOp = Ops[i].Op;
 1446     if (i+1 != Ops.size() && Ops[i+1].Op == TheOp) {
 1452       } while (i != Ops.size() && Ops[i].Op == TheOp);
 1533         isReassociableOp(Ops[i].Op, Instruction::Mul, Instruction::FMul);
 1605           isReassociableOp(Ops[i].Op, Instruction::Mul, Instruction::FMul);
 1609       if (Value *V = RemoveFactorFromExpression(Ops[i].Op, MaxOccVal)) {
 1614           if (Ops[j].Op == Ops[i].Op) {
 1614           if (Ops[j].Op == Ops[i].Op) {
 1675     Value *Op = Ops[Idx-1].Op;
 1679     for (; Idx < Size && Ops[Idx].Op == Op; ++Idx)
 1696     Value *Op = Ops[Idx-1].Op;
 1700     for (; Idx < Ops.size() && Ops[Idx].Op == Op; ++Idx)
 1839   while (!Ops.empty() && isa<Constant>(Ops.back().Op)) {
 1840     Constant *C = cast<Constant>(Ops.pop_back_val().Op);
 1856   if (Ops.size() == 1) return Ops[0].Op;
 2244         isa<ConstantInt>(Ops.back().Op) &&
 2245         cast<ConstantInt>(Ops.back().Op)->isMinusOne()) {
 2251                isa<ConstantFP>(Ops.back().Op) &&
 2252                cast<ConstantFP>(Ops.back().Op)->isExactlyValue(-1.0)) {
 2261     if (Ops[0].Op == I)
 2267     I->replaceAllUsesWith(Ops[0].Op);
 2268     if (Instruction *OI = dyn_cast<Instruction>(Ops[0].Op))
 2288         Value *Op0 = Ops[i].Op;
 2289         Value *Op1 = Ops[j].Op;