[llvm] [VPlan] Move predication to VPlanTransform (NFC). (PR #128420)
Florian Hahn via llvm-commits
llvm-commits at lists.llvm.org
Fri May 16 03:31:04 PDT 2025
================
@@ -0,0 +1,298 @@
+//===-- VPlanPredicator.cpp - VPlan predicator ----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file implements predication for VPlans.
+///
+//===----------------------------------------------------------------------===//
+
+#include "VPRecipeBuilder.h"
+#include "VPlan.h"
+#include "VPlanCFG.h"
+#include "VPlanTransforms.h"
+#include "VPlanUtils.h"
+#include "llvm/ADT/PostOrderIterator.h"
+
+using namespace llvm;
+
+namespace {
+struct VPPredicator {
+ using BlockMaskCacheTy = DenseMap<VPBasicBlock *, VPValue *>;
+ VPPredicator(BlockMaskCacheTy &BlockMaskCache)
+ : BlockMaskCache(BlockMaskCache) {}
+
+ /// Builder to construct recipes to compute masks.
+ VPBuilder Builder;
+
+ /// When we if-convert we need to create edge masks. We have to cache values
+ /// so that we don't end up with exponential recursion/IR.
+ using EdgeMaskCacheTy =
+ DenseMap<std::pair<const VPBasicBlock *, const VPBasicBlock *>,
+ VPValue *>;
+ EdgeMaskCacheTy EdgeMaskCache;
+
+ BlockMaskCacheTy &BlockMaskCache;
+
+ /// Returns the previously computed predicate of the edge between \p Src and
+ /// \p Dst.
+ VPValue *getEdgeMask(const VPBasicBlock *Src, const VPBasicBlock *Dst) const {
+ return EdgeMaskCache.lookup({Src, Dst});
+ }
+
+ /// Returns the *entry* mask for \p VPBB.
+ VPValue *getBlockInMask(VPBasicBlock *VPBB) const {
+ return BlockMaskCache.lookup(VPBB);
+ }
+ void setBlockInMask(VPBasicBlock *VPBB, VPValue *Mask) {
+ // TODO: Include the masks as operands in the predicated VPlan directly to
+ // remove the need to keep a map of masks beyond the predication transform.
+ assert(!BlockMaskCache.contains(VPBB) && "Mask already set");
+ BlockMaskCache[VPBB] = Mask;
+ }
+
+ /// Compute and return the mask for the vector loop header block.
+ void createHeaderMask(VPBasicBlock *HeaderVPBB, bool FoldTail);
+
+ /// Compute and return the predicate of \p VPBB, assuming that the header
+ /// block of the loop is set to True or the loop mask when tail folding.
+ VPValue *createBlockInMask(VPBasicBlock *VPBB);
+
+ /// Computes and return the predicate of the edge between \p Src and \p Dst.
+ VPValue *createEdgeMask(VPBasicBlock *Src, VPBasicBlock *Dst);
+
+ /// Create an edge mask for every destination of cases and/or default.
+ void createSwitchEdgeMasks(VPInstruction *SI);
+};
+} // namespace
+
+VPValue *VPPredicator::createEdgeMask(VPBasicBlock *Src, VPBasicBlock *Dst) {
+ assert(is_contained(Dst->getPredecessors(), Src) && "Invalid edge");
+
+ // Look for cached value.
+ VPValue *EdgeMask = getEdgeMask(Src, Dst);
+ if (EdgeMask)
+ return EdgeMask;
+
+ VPValue *SrcMask = getBlockInMask(Src);
+
+ // The terminator has to be a branch inst!
+ if (Src->empty() || Src->getNumSuccessors() == 1) {
+ EdgeMaskCache[{Src, Dst}] = SrcMask;
+ return SrcMask;
+ }
+
+ auto *Term = cast<VPInstruction>(Src->getTerminator());
+ if (Term->getOpcode() == Instruction::Switch) {
+ createSwitchEdgeMasks(Term);
+ return getEdgeMask(Src, Dst);
+ }
+
+ auto *BI = cast<VPInstruction>(Src->getTerminator());
+ assert(BI->getOpcode() == VPInstruction::BranchOnCond);
+ if (Src->getSuccessors()[0] == Src->getSuccessors()[1]) {
----------------
fhahn wrote:
Will look into that separately, will probably warrant a generalization of removeBranchOnTrue, as we need to take care of updating the phi nodes
https://github.com/llvm/llvm-project/pull/128420
More information about the llvm-commits
mailing list