[VPlan] Support isa/dyn_cast from VPRecipeBase to VPIRMetadata (NFC).

[fhahn]

Implement CastInfo from VPRecipeBase to VPIRMetadata to support isa/dyn_Cast. This is similar to CastInfoVPPhiAccessors, supporting dyn_cast by down-casting to the concrete recipe types inheriting from VPIRMetadata.

Can be used for more generalized VPIRMetadata printing following #165825.

[llvmbot]

@llvm/pr-subscribers-vectorizers

@llvm/pr-subscribers-llvm-transforms

Author: Florian Hahn (fhahn)

Changes

Implement CastInfo from VPRecipeBase to VPIRMetadata to support isa/dyn_Cast. This is similar to CastInfoVPPhiAccessors, supporting dyn_cast by down-casting to the concrete recipe types inheriting from VPIRMetadata.

Can be used for more generalized VPIRMetadata printing following #165825.

---

Full diff: https://github.com/llvm/llvm-project/pull/166245.diff

1 Files Affected:

• (modified) llvm/lib/Transforms/Vectorize/VPlan.h (+70)

diff --git a/llvm/lib/Transforms/Vectorize/VPlan.h b/llvm/lib/Transforms/Vectorize/VPlan.h
index cfe1f1e9d7528..2c47aa3f35e02 100644
--- a/llvm/lib/Transforms/Vectorize/VPlan.h
+++ b/llvm/lib/Transforms/Vectorize/VPlan.h
@@ -3815,6 +3815,76 @@ template <>
 struct CastInfo<VPPhiAccessors, const VPRecipeBase *>
     : CastInfoVPPhiAccessors<const VPRecipeBase *> {};
 
+/// Casting from VPRecipeBase -> VPIRMetadata is supported for all recipe types
+/// implementing VPIRMetadata. Used by isa<> & co.
+template <> struct CastIsPossible<VPIRMetadata, const VPRecipeBase *> {
+  static inline bool isPossible(const VPRecipeBase *R) {
+    return isa<VPInstruction, VPWidenRecipe, VPWidenCastRecipe,
+               VPWidenIntrinsicRecipe, VPWidenCallRecipe, VPWidenSelectRecipe,
+               VPReplicateRecipe, VPInterleaveRecipe, VPInterleaveEVLRecipe,
+               VPWidenLoadRecipe, VPWidenLoadEVLRecipe, VPWidenStoreRecipe,
+               VPWidenStoreEVLRecipe>(R);
+  }
+};
+
+/// Support casting from VPRecipeBase -> VPIRMetadata, by down-casting to the
+/// recipe types implementing VPIRMetadata. Used by cast<>, dyn_cast<> & co.
+template <typename SrcTy>
+struct CastInfoVPIRMetadata : public CastIsPossible<VPIRMetadata, SrcTy> {
+
+  using Self = CastInfo<VPIRMetadata, SrcTy>;
+
+  /// doCast is used by cast<>.
+  static inline VPIRMetadata *doCast(SrcTy R) {
+    return const_cast<VPIRMetadata *>([R]() -> const VPIRMetadata * {
+      switch (R->getVPDefID()) {
+      case VPDef::VPInstructionSC:
+        return cast<VPInstruction>(R);
+      case VPDef::VPWidenSC:
+        return cast<VPWidenRecipe>(R);
+      case VPDef::VPWidenCastSC:
+        return cast<VPWidenCastRecipe>(R);
+      case VPDef::VPWidenIntrinsicSC:
+        return cast<VPWidenIntrinsicRecipe>(R);
+      case VPDef::VPWidenCallSC:
+        return cast<VPWidenCallRecipe>(R);
+      case VPDef::VPWidenSelectSC:
+        return cast<VPWidenSelectRecipe>(R);
+      case VPDef::VPReplicateSC:
+        return cast<VPReplicateRecipe>(R);
+      case VPDef::VPInterleaveSC:
+        return cast<VPInterleaveRecipe>(R);
+      case VPDef::VPInterleaveEVLSC:
+        return cast<VPInterleaveEVLRecipe>(R);
+      case VPDef::VPWidenLoadSC:
+        return cast<VPWidenLoadRecipe>(R);
+      case VPDef::VPWidenLoadEVLSC:
+        return cast<VPWidenLoadEVLRecipe>(R);
+      case VPDef::VPWidenStoreSC:
+        return cast<VPWidenStoreRecipe>(R);
+      case VPDef::VPWidenStoreEVLSC:
+        return cast<VPWidenStoreEVLRecipe>(R);
+      default:
+        llvm_unreachable("invalid recipe for VPIRMetadata cast");
+      }
+    }());
+  }
+
+  /// doCastIfPossible is used by dyn_cast<>.
+  static inline VPIRMetadata *doCastIfPossible(SrcTy f) {
+    if (!Self::isPossible(f))
+      return nullptr;
+    return doCast(f);
+  }
+};
+
+template <>
+struct CastInfo<VPIRMetadata, VPRecipeBase *>
+    : CastInfoVPIRMetadata<VPRecipeBase *> {};
+template <>
+struct CastInfo<VPIRMetadata, const VPRecipeBase *>
+    : CastInfoVPIRMetadata<const VPRecipeBase *> {};
+
 /// VPBasicBlock serves as the leaf of the Hierarchical Control-Flow Graph. It
 /// holds a sequence of zero or more VPRecipe's each representing a sequence of
 /// output IR instructions. All PHI-like recipes must come before any non-PHI recipes.

[david-arm]

Aren't we casting from a const to a non-const pointer here - is this safe?

[david-arm]

This looks a bit odd. We potentially take a non-const SrcTy, cast it to a non-const VPInstruction, etc., then return const VPIRMetadata * from the lambda function, which then returns VPIRMetadata *. Why not just do

  return cast<VPIRMetadata *> ([R]() -> VPIRMetadata * {
    ...

?