In the following loop:

void foo(int *a, int *b, int N) { for (int i=0; i<N; ++i) a[i + 4] = a[i] + b[i]; }

The loop dependence constrains the VF to a maximum of (4, fixed), which

would mean using `<4 x i32>` as the vector type in vectorization.

Extending this to scalable vectorization, a VF of (4, scalable) implies

a vector type of `<vscale x 4 x i32>`. To determine if this is legal

vscale must be taken into account. For this example, unless

max(vscale)=1, it's unsafe to vectorize.

For SVE, the number of bits in an SVE register is architecturally

defined to be a multiple of 128 bits with a maximum of 2048 bits, thus

the maximum vscale is 16. In the loop above it is therefore unfeasible

to vectorize with SVE. However, in this loop:

void foo(int *a, int *b, int N) { #pragma clang loop vectorize_width(X, scalable) for (int i=0; i<N; ++i) a[i + 32] = a[i] + b[i]; }

As long as max(vscale) multiplied by the number of lanes 'X' doesn't

exceed the dependence distance, it is safe to vectorize. For SVE a VF of

(2, scalable) is within this constraint, since a vector of `<16 x 2 x 32>`

will have no dependencies between lanes. For any number of lanes larger

than this it would be unsafe to vectorize.

This patch extends 'computeFeasibleMaxVF' to legalize scalable VFs

specified as loop hints, implementing the following behaviour:

- If the backend does not support scalable vectors, ignore the hint.
- If scalable vectorization is unfeasible given the loop dependence, like in the first example above for SVE, then use a fixed VF.
- Accept scalable VFs if it's safe to do so.
- Otherwise, clamp scalable VFs that exceed the maximum safe VF.