38376dee92
Use HCFGBuilder to build an initial VPlan 0, which wraps all input instructions in VPInstructions and update tryToBuildVPlanWithVPRecipes to replace the VPInstructions with widened recipes. At the moment, widened recipes are created based on the underlying instruction of the VPInstruction. Masks are also still created based on the input IR basic blocks and the loop CFG is flattened in the main loop processing the VPInstructions. This patch also incldues support for Switch instructions in HCFGBuilder using just a VPInstruction with Instruction::Switch opcode. There are multiple follow-ups planned: * Perform predication on the VPlan directly, * Unify code constructing VPlan 0 to be shared by both inner and outer loop code paths. * Construct VPlan 0 once, clone subsequent ones for VFs PR: https://github.com/llvm/llvm-project/pull/124432
81 lines
2.8 KiB
C++
81 lines
2.8 KiB
C++
//===-- VPlanHCFGBuilder.h --------------------------------------*- C++ -*-===//
|
|
//
|
|
// 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 defines the VPlanHCFGBuilder class which contains the public
|
|
/// interface (buildHierarchicalCFG) to build a VPlan-based Hierarchical CFG
|
|
/// (H-CFG) for an incoming IR.
|
|
///
|
|
/// A H-CFG in VPlan is a control-flow graph whose nodes are VPBasicBlocks
|
|
/// and/or VPRegionBlocks (i.e., other H-CFGs). The outermost H-CFG of a VPlan
|
|
/// consists of a VPRegionBlock, denoted Top Region, which encloses any other
|
|
/// VPBlockBase in the H-CFG. This guarantees that any VPBlockBase in the H-CFG
|
|
/// other than the Top Region will have a parent VPRegionBlock and allows us
|
|
/// to easily add more nodes before/after the main vector loop (such as the
|
|
/// reduction epilogue).
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_TRANSFORMS_VECTORIZE_VPLAN_VPLANHCFGBUILDER_H
|
|
#define LLVM_TRANSFORMS_VECTORIZE_VPLAN_VPLANHCFGBUILDER_H
|
|
|
|
#include "VPlanDominatorTree.h"
|
|
|
|
namespace llvm {
|
|
|
|
class Loop;
|
|
class LoopInfo;
|
|
class VPRegionBlock;
|
|
class VPlan;
|
|
class VPlanTestIRBase;
|
|
|
|
/// Main class to build the VPlan H-CFG for an incoming IR.
|
|
class VPlanHCFGBuilder {
|
|
friend VPlanTestIRBase;
|
|
|
|
private:
|
|
// The outermost loop of the input loop nest considered for vectorization.
|
|
Loop *TheLoop;
|
|
|
|
// Loop Info analysis.
|
|
LoopInfo *LI;
|
|
|
|
// The VPlan that will contain the H-CFG we are building.
|
|
VPlan &Plan;
|
|
|
|
// Dominator analysis for VPlan plain CFG to be used in the
|
|
// construction of the H-CFG. This analysis is no longer valid once regions
|
|
// are introduced.
|
|
VPDominatorTree VPDomTree;
|
|
|
|
/// Map of create VP blocks to their input IR basic blocks, if they have been
|
|
/// created for a input IR basic block.
|
|
DenseMap<VPBlockBase *, BasicBlock *> VPB2IRBB;
|
|
|
|
/// Build plain CFG for TheLoop and connects it to Plan's entry.
|
|
void buildPlainCFG();
|
|
|
|
public:
|
|
VPlanHCFGBuilder(Loop *Lp, LoopInfo *LI, VPlan &P)
|
|
: TheLoop(Lp), LI(LI), Plan(P) {}
|
|
|
|
/// Build H-CFG for TheLoop and update Plan accordingly.
|
|
void buildHierarchicalCFG();
|
|
|
|
/// Return the input IR BasicBlock corresponding to \p VPB. Returns nullptr if
|
|
/// there is no such corresponding block.
|
|
/// FIXME: This is a temporary workaround to drive the createBlockInMask.
|
|
/// Remove once mask creation is done on VPlan.
|
|
BasicBlock *getIRBBForVPB(const VPBlockBase *VPB) const {
|
|
return VPB2IRBB.lookup(VPB);
|
|
}
|
|
};
|
|
} // namespace llvm
|
|
|
|
#endif // LLVM_TRANSFORMS_VECTORIZE_VPLAN_VPLANHCFGBUILDER_H
|