[VPlan] Add VPValue::isDefinedOutsideVectorRegions helper (NFC).

[fhahn]

Summary

@Ayal suggested a better named helper than using !getDef() to check if
a value is invariant across all parts.

The property we are using here is that the VPValue is defined outside
any vector loop region. There's a TODO left to handle recipes defined in
pre-header blocks.

[reames]

llvm/lib/Transforms/Vectorize/VPlan.h

3058

With this placement, this is equivalent to return false. The interesting case is the return true below.

Maybe:

if (VPV->isDefinedOutsideVectorRegion())
  return true;
auto *Def = VPV->getDef();
assert(Def);  
...

[Ayal]

llvm/lib/Transforms/Vectorize/VPlanValue.h

205

Thanks for following up!
Perhaps something like "isaVPLiveIn()" analogous to isa<VPLiveOut>()? Both are saying it's a wrapper of an IR value/user outside the scope of VPlan rather than a recipe inside this scope.
More precise type information could be derived from the wrapped underlying IR, or implied assuming that VPlan is only fed-by and feeds scalars from/to IR.

[fhahn]

Reorder code as suggested, apologies for the delay

[fhahn]

llvm/lib/Transforms/Vectorize/VPlan.h

3058

Thanks, re-ordered the code!

llvm/lib/Transforms/Vectorize/VPlanValue.h

205

The helper is intended to go beyond pure live-ins in the future. In particular, the current definition could also return true for recipes defined in the pre-header, as in the code below. I wasn't able to come up with a test case to trigger this code though for now. Does that make sense?

+bool VPValue::isDefinedOutsideVectorRegions() const {
+  const VPRecipeBase *Def = getDef();
+  if (!Def)
+    return true;
+  const VPBasicBlock *DefBlock = Def->getParent();
+  const VPlan &Plan = *DefBlock->getPlan();
+  return Plan.getEntry() == DefBlock;
+}
+

[reames]

LGTM

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

if (State.Instance) { // Generate a single instance.
     }
     return;
   }
 
   if (IsUniform) {
     // If the recipe is uniform across all parts (instead of just per VF), only
     // generate a single instance.
     if ((isa<LoadInst>(UI) || isa<StoreInst>(UI)) &&
-        all_of(operands(), [](VPValue *Op) { return !Op->getDef(); })) {
+        all_of(operands(), [](VPValue *Op) {
+          return Op->isDefinedOutsideVectorRegions();
+        })) {
       State.ILV->scalarizeInstruction(UI, this, VPIteration(0, 0), IsPredicated,
                                       State);
       if (user_begin() != user_end()) {
         for (unsigned Part = 1; Part < State.UF; ++Part)
           State.set(this, State.get(this, VPIteration(0, 0)),
                     VPIteration(Part, 0));
       }
       return;

llvm/lib/Transforms/Vectorize/VPlan.h

 VPValue *getOrCreateVPValueForSCEVExpr(VPlan &Plan, const SCEV *Expr,
                                        ScalarEvolution &SE);
 
 /// Returns true if \p VPV is uniform after vectorization.
 inline bool isUniformAfterVectorization(VPValue *VPV) {
   if (auto *Def = VPV->getDef()) {
     if (auto Rep = dyn_cast<VPReplicateRecipe>(Def))
       return Rep->isUniform();
-    return false;
+    return VPV->isDefinedOutsideVectorRegions();
   }
   // A value without a def is external to vplan and thus uniform.
   return true;
 }
 } // end namespace vputils
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_VECTORIZE_VPLAN_H

llvm/lib/Transforms/Vectorize/VPlanValue.h

assert(!getDef() &&
            "VPValue is not a live-in; it is defined by a VPDef inside a VPlan");
     return getUnderlyingValue();
   }
   const Value *getLiveInIRValue() const {
     assert(!getDef() &&
            "VPValue is not a live-in; it is defined by a VPDef inside a VPlan");
     return getUnderlyingValue();
   }
+
+  /// Returns true if the VPValue is defined outside any vector regions, i.e. it
+  /// is a live-in value.
+  /// TODO: Also handle recipes defined in pre-header blocks.
+  bool isDefinedOutsideVectorRegions() const { return !getDef(); }
 };
 
 typedef DenseMap<Value *, VPValue *> Value2VPValueTy;
 typedef DenseMap<VPValue *, Value *> VPValue2ValueTy;
 
 raw_ostream &operator<<(raw_ostream &OS, const VPValue &V);
 
 /// This class augments VPValue with operands which provide the inverse def-use