[llvm] [RISCV] Allow non-loop invariant steps in RISCVGatherScatterLowering (PR #122244)

[Luke Lau via llvm-commits]

lukel97 wrote:

> I _think_ the reasoning is okay here because having a strided start + splat(A) + splat(B) + splat(C) is still a strided pattern. I'm a bit concerned about the logic for unwinding through non-recurrence adjustments, but I _think_ this is correct.

Yeah the stride is always the same, but as for the non-recurrence adjustments I'm reasoning about it in terms of the first pointer of the vector phi and the resulting scalar phi being equivalent.

If for example we have 

```llvm
%vec.ind = phi <vscale x 1 x ptr> [(start + id * stride), entry], [%vec.ind.next, loop]
%add = add %vec.ind, %x
%mul = mul %vec.ind, %y
%v = gather %mul
...
; variant step each iteration
%vec.ind.next = add %vec.ind, %{a,b,c,...}
```

We can workout the value of the first pointer each iteration:
```
1. %mul[0] = (start + x) * y
2. %mul[0] = ((start + a) + x) * y
3. %mul[0] = (((start + b) + a) + x) * y
...
```

When we transform it to a scalar phi:

```llvm
%vec.ind.scalar = phi ptr [(start + x) * y, entry], [%vec.ind.scalar.next, loop]
%v = strided.load %vec.ind.scalar
...
; variant step each iteration
%step = mul %{a,b,c,...}, %y
%vec.ind.scalar.next = add %vec.ind, %step
```

We can work out the address to the strided load

```
1: addr = (start + x) * y
2: addr = (a * y) + ((start + x) * y)
3: addr = (b * y) + (a * y) + ((start + x) * y)
...
```

Which at each iteration the address is equivalent to the previous first pointer in the vector indices.

https://github.com/llvm/llvm-project/pull/122244