LLVM  10.0.0svn
VPRecipeBuilder.h
Go to the documentation of this file.
1 //===- VPRecipeBuilder.h - Helper class to build recipes --------*- C++ -*-===//
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 #ifndef LLVM_TRANSFORMS_VECTORIZE_VPRECIPEBUILDER_H
10 #define LLVM_TRANSFORMS_VECTORIZE_VPRECIPEBUILDER_H
11 
13 #include "VPlan.h"
14 #include "llvm/ADT/DenseMap.h"
15 #include "llvm/IR/IRBuilder.h"
16 
17 namespace llvm {
18 
19 class LoopVectorizationLegality;
20 class LoopVectorizationCostModel;
21 class TargetTransformInfo;
22 class TargetLibraryInfo;
23 
24 /// Helper class to create VPRecipies from IR instructions.
26  /// The loop that we evaluate.
27  Loop *OrigLoop;
28 
29  /// Target Library Info.
30  const TargetLibraryInfo *TLI;
31 
32  /// The legality analysis.
34 
35  /// The profitablity analysis.
37 
38  VPBuilder &Builder;
39 
40  /// When we if-convert we need to create edge masks. We have to cache values
41  /// so that we don't end up with exponential recursion/IR. Note that
42  /// if-conversion currently takes place during VPlan-construction, so these
43  /// caches are only used at that stage.
44  using EdgeMaskCacheTy =
47  EdgeMaskCacheTy EdgeMaskCache;
48  BlockMaskCacheTy BlockMaskCache;
49 
50 public:
51  /// A helper function that computes the predicate of the block BB, assuming
52  /// that the header block of the loop is set to True. It returns the *entry*
53  /// mask for the block BB.
54  VPValue *createBlockInMask(BasicBlock *BB, VPlanPtr &Plan);
55 
56  /// A helper function that computes the predicate of the edge between SRC
57  /// and DST.
58  VPValue *createEdgeMask(BasicBlock *Src, BasicBlock *Dst, VPlanPtr &Plan);
59 
60  /// Check if \I belongs to an Interleave Group within the given VF \p Range,
61  /// \return true in the first returned value if so and false otherwise.
62  /// Build a new VPInterleaveGroup Recipe if \I is the primary member of an IG
63  /// for \p Range.Start, and provide it as the second returned value.
64  /// Note that if \I is an adjunct member of an IG for \p Range.Start, the
65  /// \return value is <true, nullptr>, as it is handled by another recipe.
66  /// \p Range.End may be decreased to ensure same decision from \p Range.Start
67  /// to \p Range.End.
69  VPlanPtr &Plan);
70 
71  /// Check if \I is a memory instruction to be widened for \p Range.Start and
72  /// potentially masked. Such instructions are handled by a recipe that takes
73  /// an additional VPInstruction for the mask.
75  tryToWidenMemory(Instruction *I, VFRange &Range, VPlanPtr &Plan);
76 
77  /// Check if an induction recipe should be constructed for \I within the given
78  /// VF \p Range. If so build and return it. If not, return null. \p Range.End
79  /// may be decreased to ensure same decision from \p Range.Start to
80  /// \p Range.End.
82  VFRange &Range);
83 
84  /// Handle non-loop phi nodes. Currently all such phi nodes are turned into
85  /// a sequence of select instructions as the vectorizer currently performs
86  /// full if-conversion.
88 
89  /// Check if \p I can be widened within the given VF \p Range. If \p I can be
90  /// widened for \p Range.Start, check if the last recipe of \p VPBB can be
91  /// extended to include \p I or else build a new VPWidenRecipe for it and
92  /// append it to \p VPBB. Return true if \p I can be widened for Range.Start,
93  /// false otherwise. Range.End may be decreased to ensure same decision from
94  /// \p Range.Start to \p Range.End.
95  bool tryToWiden(Instruction *I, VPBasicBlock *VPBB, VFRange &Range);
96 
97  /// Create a replicating region for instruction \p I that requires
98  /// predication. \p PredRecipe is a VPReplicateRecipe holding \p I.
100  VPlanPtr &Plan);
101 
102 public:
103  VPRecipeBuilder(Loop *OrigLoop, const TargetLibraryInfo *TLI,
106  : OrigLoop(OrigLoop), TLI(TLI), Legal(Legal), CM(CM), Builder(Builder) {}
107 
108  /// Check if a recipe can be create for \p I withing the given VF \p Range.
109  /// If a recipe can be created, it adds it to \p VPBB.
110  bool tryToCreateRecipe(Instruction *Instr, VFRange &Range, VPlanPtr &Plan,
111  VPBasicBlock *VPBB);
112 
113  /// Build a VPReplicationRecipe for \p I and enclose it within a Region if it
114  /// is predicated. \return \p VPBB augmented with this new recipe if \p I is
115  /// not predicated, otherwise \return a new VPBasicBlock that succeeds the new
116  /// Region. Update the packing decision of predicated instructions if they
117  /// feed \p I. Range.End may be decreased to ensure same recipe behavior from
118  /// \p Range.Start to \p Range.End.
120  Instruction *I, VFRange &Range, VPBasicBlock *VPBB,
122  VPlanPtr &Plan);
123 };
124 } // end namespace llvm
125 
126 #endif // LLVM_TRANSFORMS_VECTORIZE_VPRECIPEBUILDER_H
VPInterleaveRecipe * tryToInterleaveMemory(Instruction *I, VFRange &Range, VPlanPtr &Plan)
Check if belongs to an Interleave Group within the given VF Range,.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
VPRegionBlock represents a collection of VPBasicBlocks and VPRegionBlocks which form a Single-Entry-S...
Definition: VPlan.h:1067
VPWidenMemoryInstructionRecipe * tryToWidenMemory(Instruction *I, VFRange &Range, VPlanPtr &Plan)
Check if is a memory instruction to be widened for Range.Start and potentially masked.
Helper class to create VPRecipies from IR instructions.
LoopVectorizationLegality checks if it is legal to vectorize a loop, and to what vectorization factor...
bool tryToCreateRecipe(Instruction *Instr, VFRange &Range, VPlanPtr &Plan, VPBasicBlock *VPBB)
Check if a recipe can be create for I withing the given VF Range.
A Recipe for widening load/store operations.
Definition: VPlan.h:955
VPRecipeBase is a base class modeling a sequence of one or more output IR instructions.
Definition: VPlan.h:568
VPValue * createBlockInMask(BasicBlock *BB, VPlanPtr &Plan)
A helper function that computes the predicate of the block BB, assuming that the header block of the ...
bool tryToWiden(Instruction *I, VPBasicBlock *VPBB, VFRange &Range)
Check if I can be widened within the given VF Range.
VPBlendRecipe * tryToBlend(Instruction *I, VPlanPtr &Plan)
Handle non-loop phi nodes.
VPRegionBlock * createReplicateRegion(Instruction *I, VPRecipeBase *PredRecipe, VPlanPtr &Plan)
Create a replicating region for instruction I that requires predication.
This file provides a LoopVectorizationPlanner class.
VPlan-based builder utility analogous to IRBuilder.
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
This file contains the declarations of the Vectorization Plan base classes:
std::unique_ptr< VPlan > VPlanPtr
Definition: VPlan.h:75
VPBasicBlock serves as the leaf of the Hierarchical Control-Flow Graph.
Definition: VPlan.h:982
A range of powers-of-2 vectorization factors with fixed start and adjustable end. ...
Definition: VPlan.h:67
Provides information about what library functions are available for the current target.
VPValue * createEdgeMask(BasicBlock *Src, BasicBlock *Dst, VPlanPtr &Plan)
A helper function that computes the predicate of the edge between SRC and DST.
VPRecipeBuilder(Loop *OrigLoop, const TargetLibraryInfo *TLI, LoopVectorizationLegality *Legal, LoopVectorizationCostModel &CM, VPBuilder &Builder)
VPInterleaveRecipe is a recipe for transforming an interleave group of load or stores into one wide l...
Definition: VPlan.h:818
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:509
VPBasicBlock * handleReplication(Instruction *I, VFRange &Range, VPBasicBlock *VPBB, DenseMap< Instruction *, VPReplicateRecipe *> &PredInst2Recipe, VPlanPtr &Plan)
Build a VPReplicationRecipe for I and enclose it within a Region if it is predicated.
#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:741
LoopVectorizationCostModel - estimates the expected speedups due to vectorization.
A recipe for vectorizing a phi-node as a sequence of mask-based select instructions.
Definition: VPlan.h:787
VPWidenIntOrFpInductionRecipe * tryToOptimizeInduction(Instruction *I, VFRange &Range)
Check if an induction recipe should be constructed for within the given VF Range.