[llvm] [LV][VPlan] Add initial support for CSA vectorization (PR #121222)

[via llvm-commits]

ayalz wrote:

> > @Mel-Chen can you chime in here? Can FindLast handle non-monotonic cases? I think the reason we took the approach proposed in this patch was because FindLast only works for monotonic cases.
> 
> I think what @ayalz wants to discuss with you is the newly added `RecurKind::FindLast`, rather than the existing `RecurKind::FindLastIV`.
> 
> I still believe that the semantics you are implementing are a form of reduction. Therefore, reusing the existing reduction framework is appropriate. I don't think this change would affect how you ultimately generate the vectorized IR.
> 
> Ideally, the vectorizer should select the best vectorization approach in the following order:
> 
> 1. Try `RecurKind::AnyOf` (select between invariants)
> 2. If not applicable, try `RecurKind::FindLastIV` (select from a monotonic increasing sequence)
> 3. If not applicable, try `RecurKind::FindLast` (select from a set of  variables)
> 4. If none apply, then it cannot be vectorized.

Curious about there need for both FindLast and FindLastIV. The desired output may be some function of the last IV found, and this function may be applied after the loop or folded into the loop along with the reduction if preferred (similar to two invariants per boolean AnyOf), but the canonical reduction pattern for both is presumably that of finding the last iteration?

Trying to reason about where the above ideal order may be important: every header phi, which represents a cross-iteration dependence, must be handled by the vectorizer, according to one of the following vectorizable categories:
- FOR, acyclic: all users of the phi appear (or can move) below the instruction feeding the phi along the back-edge. Handled as Fixed Order Recurrence.
- Induction: cyclic non-wrapping addition chain with invariant addend step, aka AddRec by SCEV.
- Reduction: cyclic, non-induction (non-addition chain or addition chain with varying step). A {value(i)} sequence of values all of the same type (integer, floating point or boolean) is computed one per iteration i, independent of other iterations, and reduced to a single value of this type by repeatedly applying a binary operator to value(i) and the reduction phi.
  - Select Reduction: the reduction result may be an element of the sequence being reduced if this binary operator selects one of its two operands. This is the case for Min/Max reductions and arguably also for `AnyOf` - which can use a `select value(i) ? value(i) : phi` as its binary reduction operator. Note that if AnyOf returns false, all value(i)'s are false, so any value(i) can be considered selected.
  - Selected Index: the resulting value(i) of a select reduction can be complemented with its corresponding iteration i. This is the case for Min/Max-with-index and also for `FindLast` - corresponding to AnyOf-with-index, returning the last iteration i for which value(i) is true, if any.

There may be additional recurrences to consider?

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