LLVM  10.0.0svn
VPlanHCFGTransforms.cpp
Go to the documentation of this file.
1 //===-- VPlanHCFGTransforms.cpp - Utility VPlan to VPlan transforms -------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 ///
9 /// \file
10 /// This file implements a set of utility VPlan to VPlan transformations.
11 ///
12 //===----------------------------------------------------------------------===//
13 
14 #include "VPlanHCFGTransforms.h"
16 
17 using namespace llvm;
18 
20  VPlanPtr &Plan,
22  SmallPtrSetImpl<Instruction *> &DeadInstructions) {
23 
24  auto *TopRegion = cast<VPRegionBlock>(Plan->getEntry());
25  ReversePostOrderTraversal<VPBlockBase *> RPOT(TopRegion->getEntry());
26 
27  // Condition bit VPValues get deleted during transformation to VPRecipes.
28  // Create new VPValues and save away as condition bits. These will be deleted
29  // after finalizing the vector IR basic blocks.
30  for (VPBlockBase *Base : RPOT) {
31  VPBasicBlock *VPBB = Base->getEntryBasicBlock();
32  if (auto *CondBit = VPBB->getCondBit()) {
33  auto *NCondBit = new VPValue(CondBit->getUnderlyingValue());
34  VPBB->setCondBit(NCondBit);
35  Plan->addCBV(NCondBit);
36  }
37  }
38  for (VPBlockBase *Base : RPOT) {
39  // Do not widen instructions in pre-header and exit blocks.
40  if (Base->getNumPredecessors() == 0 || Base->getNumSuccessors() == 0)
41  continue;
42 
43  VPBasicBlock *VPBB = Base->getEntryBasicBlock();
44  VPRecipeBase *LastRecipe = nullptr;
45  // Introduce each ingredient into VPlan.
46  for (auto I = VPBB->begin(), E = VPBB->end(); I != E;) {
47  VPRecipeBase *Ingredient = &*I++;
48  // Can only handle VPInstructions.
49  VPInstruction *VPInst = cast<VPInstruction>(Ingredient);
50  Instruction *Inst = cast<Instruction>(VPInst->getUnderlyingValue());
51  if (DeadInstructions.count(Inst)) {
52  Ingredient->eraseFromParent();
53  continue;
54  }
55 
56  VPRecipeBase *NewRecipe = nullptr;
57  // Create VPWidenMemoryInstructionRecipe for loads and stores.
58  if (isa<LoadInst>(Inst) || isa<StoreInst>(Inst))
59  NewRecipe = new VPWidenMemoryInstructionRecipe(*Inst, nullptr /*Mask*/);
60  else if (PHINode *Phi = dyn_cast<PHINode>(Inst)) {
61  InductionDescriptor II = Inductions->lookup(Phi);
64  NewRecipe = new VPWidenIntOrFpInductionRecipe(Phi);
65  } else
66  NewRecipe = new VPWidenPHIRecipe(Phi);
67  } else {
68  // If the last recipe is a VPWidenRecipe, add Inst to it instead of
69  // creating a new recipe.
70  if (VPWidenRecipe *WidenRecipe =
71  dyn_cast_or_null<VPWidenRecipe>(LastRecipe)) {
72  WidenRecipe->appendInstruction(Inst);
73  Ingredient->eraseFromParent();
74  continue;
75  }
76  NewRecipe = new VPWidenRecipe(Inst);
77  }
78 
79  NewRecipe->insertBefore(Ingredient);
80  LastRecipe = NewRecipe;
81  Ingredient->eraseFromParent();
82  }
83  }
84 }
This class represents lattice values for constants.
Definition: AllocatorList.h:23
iplist< VPRecipeBase >::iterator eraseFromParent()
This method unlinks &#39;this&#39; from the containing basic block and deletes it.
Definition: VPlan.cpp:282
A Recipe for widening load/store operations.
Definition: VPlan.h:959
InductionKind getKind() const
VPRecipeBase is a base class modeling a sequence of one or more output IR instructions.
Definition: VPlan.h:568
A recipe for handling all phi nodes except for integer and FP inductions.
Definition: VPlan.h:769
void insertBefore(VPRecipeBase *InsertPos)
Insert an unlinked recipe into a basic block immediately before the specified recipe.
Definition: VPlan.cpp:277
This file provides utility VPlan to VPlan transformations.
iterator begin()
Recipe iterator methods.
Definition: VPlan.h:1012
Value * getUnderlyingValue()
Return the underlying Value attached to this VPValue.
Definition: VPlanValue.h:64
Integer induction variable. Step = C.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
std::unique_ptr< VPlan > VPlanPtr
Definition: VPlan.h:75
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:381
VPBasicBlock serves as the leaf of the Hierarchical Control-Flow Graph.
Definition: VPlan.h:986
A struct for saving information about induction variables.
VPBlockBase is the building block of the Hierarchical Control-Flow Graph.
Definition: VPlan.h:333
void setCondBit(VPValue *CV)
Definition: VPlan.h:494
VPValue * getCondBit()
Definition: VPlan.h:490
ValueT lookup(const KeyT &Key) const
Definition: MapVector.h:110
Floating point induction variable.
#define I(x, y, z)
Definition: MD5.cpp:58
A recipe for handling phi nodes of integer and floating-point inductions, producing their vector and ...
Definition: VPlan.h:745
iterator end()
Definition: VPlan.h:1014
VPWidenRecipe is a recipe for producing a copy of vector type for each Instruction in its ingredients...
Definition: VPlan.h:709
static void VPInstructionsToVPRecipes(VPlanPtr &Plan, LoopVectorizationLegality::InductionList *Inductions, SmallPtrSetImpl< Instruction *> &DeadInstructions)
Replaces the VPInstructions in Plan with corresponding widen recipes.
This is a concrete Recipe that models a single VPlan-level instruction.
Definition: VPlan.h:632