This patch adds a linear polynomial base class, called LinearPolyBase, which

serves as a base class for StackOffset. It tries to represent a linear

polynomial like:

c0 * scale0 + c1 * scale1 + ... + cK * scaleK

where the scale is implicit, meaning that only the coefficients are

encoded.

This patch also adds a univariate linear polynomial, which serves as

a base class for ElementCount and TypeSize. This tries to represent a

linear polynomial where only one dimension can be set at any one time,

i.e. a TypeSize is either fixed-sized, or scalable-sized, but cannot be

a combination of the two.

class LinearPolyBase ^ | +---- class StackOffset (dimensions = 2 (fixed/scalable), type = int64_t) class UnivariateLinearPolyBase | | +---- class LinearPolySize (dimensions = 2 (fixed/scalable)) ^ | +-------- class ElementCount (type = unsigned) | | +-------- class TypeSize (type = uint64_t)

Can you remove the need for ScalarTy by having Ty provide the scalar type? i.e. Ty::ScalarTy, where ScalarTy would be a typedef or something inside LinearPolyBase?

Instead of using multiple inheritance to get the operators, is it not possible to simply have the operators outside of any class? I think C++ allows you to do this provided the operators are friends of the relevant classes, i.e. just have

template <Ty>

LinearPolyBase<Ty> operator+(const LinearPolyBase<Ty> LHS, const LinearPolyBase<Ty> RHS) {

}

although I realise the example above only works if you have a simplified LinearPolyBase that assumes 2 dimensions, rather than the 3 template parameters you currently have for LinearPolyBase.