Well, all of this seems workable, but I have to say I had something slightly different in mind. Basically, like this:

    template <>
    struct VLoadStore128<ushort> {
        typedef uint16x8_t reg_type;
        static reg_type load(const ushort * p) { ... }
        static store(ushort * p, reg_type value) { ... }
    };

Then you could do stuff like:

    template<>
    struct VAdd<ushort> {
        static VLoadStore<ushort>::reg_type do(VLoadStore<ushort>::reg_type a, VLoadStore<ushort>::reg_type b) { ... }
    };

(all generatable with a macro, of course)

What you gain is that you reduce the number of macro arguments to 4 for each load/store pair (you currently have 10) and 3 for every arithmetic operation (you have 4). You also get the `VLoadStore<T>::reg_type` metafunction, which you might need elsewhere.

I can accept this as it is, since it can always be refactored later, but consider my approach.