[SCEV] Add operand methods to Exprs

[samparker]

Summary

Preliminary patch for D86050 where it makes it much easier to write reusable code if the expressions have the same operand methods.

[lebedev.ri]

llvm/include/llvm/Analysis/ScalarEvolutionExpressions.h

77

I do not understand why you need std::array here.

op_range operands() const {
  return make_range(Op, Op+1);
}

will just work

296–298

Again, end() should be one-past-the-last element, not the last element.

[samparker]

Thanks. Fixed up iterators

[reames]

LGTM

[lebedev.ri]

lg

llvm/include/llvm/Analysis/ScalarEvolutionExpressions.h

inline unsigned short computeExpressionSize(ArrayRef<const SCEV *> Args) {
     for (auto *Arg : Args)
       Size = Size.uadd_sat(APInt(16, Arg->getExpressionSize()));
     return (unsigned short)Size.getZExtValue();
   }
 
   /// This is the base class for unary cast operator classes.
   class SCEVCastExpr : public SCEV {
   protected:
     const SCEV *Op;
     Type *Ty;
 
     SCEVCastExpr(const FoldingSetNodeIDRef ID,
                  unsigned SCEVTy, const SCEV *op, Type *ty);
 
   public:
     const SCEV *getOperand() const { return Op; }
+    const SCEV *getOperand(unsigned i) const {
+      assert(i == 0 && "Operand index out of range!");
+      return Op;
+    }
+    using op_iterator = const SCEV *const *;
+    using op_range = iterator_range<op_iterator>;
+    op_range operands() const {
+      return make_range(&Op, &Op + 1);
+    }
+    size_t getNumOperands() const { return 1; }
     Type *getType() const { return Ty; }
 
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     static bool classof(const SCEV *S) {
       return S->getSCEVType() == scTruncate ||
              S->getSCEVType() == scZeroExtend ||
              S->getSCEVType() == scSignExtend;
     }
static bool classof(const SCEV *S) {
       return S->getSCEVType() == scMulExpr;
     }
   };
 
   /// This class represents a binary unsigned division operation.
   class SCEVUDivExpr : public SCEV {
     friend class ScalarEvolution;
 
-    const SCEV *LHS;
-    const SCEV *RHS;
+    std::array<const SCEV*, 2> Operands;
 
     SCEVUDivExpr(const FoldingSetNodeIDRef ID, const SCEV *lhs, const SCEV *rhs)
-        : SCEV(ID, scUDivExpr, computeExpressionSize({lhs, rhs})), LHS(lhs),
-          RHS(rhs) {}
+        : SCEV(ID, scUDivExpr, computeExpressionSize({lhs, rhs})) {
+        Operands[0] = lhs;
+        Operands[1] = rhs;
+      }
 
   public:
-    const SCEV *getLHS() const { return LHS; }
-    const SCEV *getRHS() const { return RHS; }
+    const SCEV *getLHS() const { return Operands[0]; }
+    const SCEV *getRHS() const { return Operands[1]; }
+    size_t getNumOperands() const { return 2; }
+    const SCEV *getOperand(unsigned i) const {
+      assert((i == 0 || i == 1) && "Operand index out of range!");
+      return i == 0 ? getLHS() : getRHS();
+    }
+
+    using op_iterator = const SCEV *const *;
+    using op_range = iterator_range<op_iterator>;
+    op_range operands() const {
+      return make_range(Operands.begin(), Operands.end());
+    }
 
     Type *getType() const {
       // In most cases the types of LHS and RHS will be the same, but in some
       // crazy cases one or the other may be a pointer. ScalarEvolution doesn't
       // depend on the type for correctness, but handling types carefully can
       // avoid extra casts in the SCEVExpander. The LHS is more likely to be
       // a pointer type than the RHS, so use the RHS' type here.
       return getRHS()->getType();
     }