mirror of
https://github.com/RPCS3/llvm.git
synced 2025-05-22 05:15:57 +00:00
a858f4fe0b
Summary: [VPlan] Implement vector code generation support for simple outer loops. Context: Patch Series #1 for outer loop vectorization support in LV using VPlan. (RFC: http://lists.llvm.org/pipermail/llvm-dev/2017-December/119523.html). This patch introduces vector code generation support for simple outer loops that are currently supported in the VPlanNativePath. Changes here essentially do the following: - force vector code generation using explicit vectorize_width - add conservative early returns in cost model and other places for VPlanNativePath - add code for setting up outer loop inductions - support for widening non-induction PHIs that can result from inner loops and uniform conditional branches - support for generating uniform inner branches We plan to add a handful C outer loop executable tests once the initial code generation support is committed. This patch is expected to be NFC for the inner loop vectorizer path. Since we are moving in the direction of supporting outer loop vectorization in LV, it may also be time to rename classes such as InnerLoopVectorizer. Reviewers: fhahn, rengolin, hsaito, dcaballe, mkuper, hfinkel, Ayal Reviewed By: fhahn, hsaito Subscribers: dmgreen, bollu, tschuett, rkruppe, rogfer01, llvm-commits Differential Revision: https://reviews.llvm.org/D50820 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@342197 91177308-0d34-0410-b5e6-96231b3b80d8
85 lines
3.2 KiB
C++
85 lines
3.2 KiB
C++
//===-- VPlanHCFGTransforms.cpp - Utility VPlan to VPlan transforms -------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \file
|
|
/// This file implements a set of utility VPlan to VPlan transformations.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "VPlanHCFGTransforms.h"
|
|
#include "llvm/ADT/PostOrderIterator.h"
|
|
|
|
using namespace llvm;
|
|
|
|
void VPlanHCFGTransforms::VPInstructionsToVPRecipes(
|
|
VPlanPtr &Plan,
|
|
LoopVectorizationLegality::InductionList *Inductions,
|
|
SmallPtrSetImpl<Instruction *> &DeadInstructions) {
|
|
|
|
VPRegionBlock *TopRegion = dyn_cast<VPRegionBlock>(Plan->getEntry());
|
|
ReversePostOrderTraversal<VPBlockBase *> RPOT(TopRegion->getEntry());
|
|
|
|
// Condition bit VPValues get deleted during transformation to VPRecipes.
|
|
// Create new VPValues and save away as condition bits. These will be deleted
|
|
// after finalizing the vector IR basic blocks.
|
|
for (VPBlockBase *Base : RPOT) {
|
|
VPBasicBlock *VPBB = Base->getEntryBasicBlock();
|
|
if (auto *CondBit = VPBB->getCondBit()) {
|
|
auto *NCondBit = new VPValue(CondBit->getUnderlyingValue());
|
|
VPBB->setCondBit(NCondBit);
|
|
}
|
|
}
|
|
for (VPBlockBase *Base : RPOT) {
|
|
// Do not widen instructions in pre-header and exit blocks.
|
|
if (Base->getNumPredecessors() == 0 || Base->getNumSuccessors() == 0)
|
|
continue;
|
|
|
|
VPBasicBlock *VPBB = Base->getEntryBasicBlock();
|
|
VPRecipeBase *LastRecipe = nullptr;
|
|
// Introduce each ingredient into VPlan.
|
|
for (auto I = VPBB->begin(), E = VPBB->end(); I != E;) {
|
|
VPRecipeBase *Ingredient = &*I++;
|
|
// Can only handle VPInstructions.
|
|
VPInstruction *VPInst = cast<VPInstruction>(Ingredient);
|
|
Instruction *Inst = cast<Instruction>(VPInst->getUnderlyingValue());
|
|
if (DeadInstructions.count(Inst)) {
|
|
Ingredient->eraseFromParent();
|
|
continue;
|
|
}
|
|
|
|
VPRecipeBase *NewRecipe = nullptr;
|
|
// Create VPWidenMemoryInstructionRecipe for loads and stores.
|
|
if (isa<LoadInst>(Inst) || isa<StoreInst>(Inst))
|
|
NewRecipe = new VPWidenMemoryInstructionRecipe(*Inst, nullptr /*Mask*/);
|
|
else if (PHINode *Phi = dyn_cast<PHINode>(Inst)) {
|
|
InductionDescriptor II = Inductions->lookup(Phi);
|
|
if (II.getKind() == InductionDescriptor::IK_IntInduction ||
|
|
II.getKind() == InductionDescriptor::IK_FpInduction) {
|
|
NewRecipe = new VPWidenIntOrFpInductionRecipe(Phi);
|
|
} else
|
|
NewRecipe = new VPWidenPHIRecipe(Phi);
|
|
} else {
|
|
// If the last recipe is a VPWidenRecipe, add Inst to it instead of
|
|
// creating a new recipe.
|
|
if (VPWidenRecipe *WidenRecipe =
|
|
dyn_cast_or_null<VPWidenRecipe>(LastRecipe)) {
|
|
WidenRecipe->appendInstruction(Inst);
|
|
Ingredient->eraseFromParent();
|
|
continue;
|
|
}
|
|
NewRecipe = new VPWidenRecipe(Inst);
|
|
}
|
|
|
|
NewRecipe->insertBefore(Ingredient);
|
|
LastRecipe = NewRecipe;
|
|
Ingredient->eraseFromParent();
|
|
}
|
|
}
|
|
}
|