[llvm] [VPlan] Move FOR splice cost into VPInstruction::FirstOrderRecurrenceSplice (PR #129645)

[Luke Lau via llvm-commits]

lukel97 wrote:

My gut feeling 

> > > The move makes sense. Curious if it would be easy to add a test where this leads to different VF to be picked?
> > 
> > 
> > I gave this a try there but I couldn't really find a way. Even by doubling the vector cost with `+tune-dlen-factor2`/adding predication the vector costs seem to outweigh the scalar. We also can't seem to EVL vectorize a first order recurrence of i64 yet either, which I thought might increase the vector cost, because it ends up creating a VPWidenIntOrFpInductionRecipe, which we can't handle yet without #115274 / #118638
> 
> I didn't get this point. Why would FOR be related to VPWidenIntOrFpInductionRecipe? Could you provide a more details or examples?

For this loop where `%for1` is i64:


```llvm
define void @first_order_recurrence(ptr noalias %A, ptr noalias %B, i64 %TC) {

entry:
  br label %for.body

for.body:
  %indvars = phi i64 [ 0, %entry ], [ %indvars.next, %for.body ]
  %for1 = phi i64 [ 33, %entry ], [ %0, %for.body ]
  %arrayidx = getelementptr inbounds nuw i64, ptr %A, i64 %indvars
  %0 = load i64, ptr %arrayidx, align 4
  %add = add nsw i64 %for1, %0
  %arrayidx2 = getelementptr inbounds nuw i64, ptr %B, i64 %indvars
  store i64 %add, ptr %arrayidx2, align 4
  %indvars.next = add nuw nsw i64 %indvars, 1
  %exitcond.not = icmp eq i64 %indvars.next, %TC
  br i1 %exitcond.not, label %for.end, label %for.body

for.end:
  ret void
}

```

The VPlan coming into `VPlanTransforms::tryAddExplicitVectorLength` seems to have a VPWidenIntOrFpInductionRecipe, used for predicating?

```
VPlan 'Initial VPlan for VF={vscale x 1,vscale x 2},UF>=1' {
Live-in vp<%0> = VF
Live-in vp<%1> = VF * UF
Live-in vp<%2> = vector-trip-count
Live-in vp<%3> = backedge-taken count
Live-in ir<%TC> = original trip-count

ir-bb<entry>:
Successor(s): vector.ph

vector.ph:
Successor(s): vector loop

<x1> vector loop: {
  vector.body:
    EMIT vp<%4> = CANONICAL-INDUCTION ir<0>, vp<%index.next>
    ir<%indvars> = WIDEN-INDUCTION  ir<0>, ir<1>, vp<%0>
    FIRST-ORDER-RECURRENCE-PHI ir<%for1> = phi ir<33>, vp<%6>
    EMIT vp<%5> = icmp ule ir<%indvars>, vp<%3>
    WIDEN-GEP Inv[Var] ir<%arrayidx> = getelementptr inbounds nuw ir<%A>, ir<%indvars>
  Successor(s): pred.load

  <xVFxUF> pred.load: {
    pred.load.entry:
      BRANCH-ON-MASK vp<%5>
    Successor(s): pred.load.if, pred.load.continue

    pred.load.if:
      REPLICATE ir<%0> = load ir<%arrayidx> (S->V)
    Successor(s): pred.load.continue

    pred.load.continue:
      PHI-PREDICATED-INSTRUCTION vp<%6> = ir<%0>
    No successors
  }
  Successor(s): for.body.0

  for.body.0:
    EMIT vp<%7> = first-order splice ir<%for1>, vp<%6>
    WIDEN ir<%add> = add nsw vp<%7>, vp<%6>
    WIDEN-GEP Inv[Var] ir<%arrayidx2> = getelementptr inbounds nuw ir<%B>, ir<%indvars>
  Successor(s): pred.store

  <xVFxUF> pred.store: {
    pred.store.entry:
      BRANCH-ON-MASK vp<%5>
    Successor(s): pred.store.if, pred.store.continue

    pred.store.if:
      REPLICATE store ir<%add>, ir<%arrayidx2>
    Successor(s): pred.store.continue

    pred.store.continue:
    No successors
  }
  Successor(s): for.body.1

  for.body.1:
    EMIT vp<%index.next> = add vp<%4>, vp<%1>
    EMIT branch-on-count vp<%index.next>, vp<%2>
  No successors
}
```

I'm not sure why we're predicating this anyway.

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