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
12#include "LoopVectorizationPlanner.h"
13#include "VPlan.h"
14#include "llvm/ADT/DenseMap.h"
15#include "llvm/Analysis/ScalarEvolutionExpressions.h"
16
17namespace llvm {
18
19class LoopVectorizationLegality;
20class LoopVectorizationCostModel;
21class TargetLibraryInfo;
22struct HistogramInfo;
23struct VFRange;
24
25/// Helper class to create VPRecipies from IR instructions.
26class VPRecipeBuilder {
27 /// The VPlan new recipes are added to.
28 VPlan &Plan;
29
30 /// Target Library Info.
31 const TargetLibraryInfo *TLI;
32
33 /// The legality analysis.
34 LoopVectorizationLegality *Legal;
35
36 /// The profitablity analysis.
37 LoopVectorizationCostModel &CM;
38
39 VPBuilder &Builder;
40
41 // VPlan construction support: Hold a mapping from ingredients to
42 // their recipe.
43 DenseMap<Instruction *, VPRecipeBase *> Ingredient2Recipe;
44
45 /// Cross-iteration reduction & first-order recurrence phis for which we need
46 /// to add the incoming value from the backedge after all recipes have been
47 /// created.
48 SmallVector<VPHeaderPHIRecipe *, 4> PhisToFix;
49
50 /// Check if \p I can be widened at the start of \p Range and possibly
51 /// decrease the range such that the returned value holds for the entire \p
52 /// Range. The function should not be called for memory instructions or calls.
53 bool shouldWiden(Instruction *I, VFRange &Range) const;
54
55 /// Check if the load or store instruction \p VPI should widened for \p
56 /// Range.Start and potentially masked. Such instructions are handled by a
57 /// recipe that takes an additional VPInstruction for the mask.
58 VPRecipeBase *tryToWidenMemory(VPInstruction *VPI, VFRange &Range);
59
60 /// Optimize the special case where the operand of \p VPI is a constant
61 /// integer induction variable.
62 VPWidenIntOrFpInductionRecipe *
63 tryToOptimizeInductionTruncate(VPInstruction *VPI, VFRange &Range);
64
65 /// Handle call instructions. If \p VPI can be widened for \p Range.Start,
66 /// return a new VPWidenCallRecipe or VPWidenIntrinsicRecipe. Range.End may be
67 /// decreased to ensure same decision from \p Range.Start to \p Range.End.
68 VPSingleDefRecipe *tryToWidenCall(VPInstruction *VPI, VFRange &Range);
69
70 /// Check if \p VPI has an opcode that can be widened and return a
71 /// VPWidenRecipe if it can. The function should only be called if the
72 /// cost-model indicates that widening should be performed.
73 VPWidenRecipe *tryToWiden(VPInstruction *VPI);
74
75 /// Makes Histogram count operations safe for vectorization, by emitting a
76 /// llvm.experimental.vector.histogram.add intrinsic in place of the
77 /// Load + Add|Sub + Store operations that perform the histogram in the
78 /// original scalar loop.
79 VPHistogramRecipe *tryToWidenHistogram(const HistogramInfo *HI,
80 VPInstruction *VPI);
81
82public:
83 VPRecipeBuilder(VPlan &Plan, const TargetLibraryInfo *TLI,
84 LoopVectorizationLegality *Legal,
85 LoopVectorizationCostModel &CM, VPBuilder &Builder)
86 : Plan(Plan), TLI(TLI), Legal(Legal), CM(CM), Builder(Builder) {}
87
88 /// Create and return a widened recipe for a non-phi recipe \p R if one can be
89 /// created within the given VF \p Range.
90 VPRecipeBase *tryToCreateWidenNonPhiRecipe(VPSingleDefRecipe *R,
91 VFRange &Range);
92
93 /// Set the recipe created for given ingredient.
94 void setRecipe(Instruction *I, VPRecipeBase *R) {
95 assert(!Ingredient2Recipe.contains(I) &&
96 "Cannot reset recipe for instruction.");
97 Ingredient2Recipe[I] = R;
98 }
99
100 /// Return the recipe created for given ingredient.
101 VPRecipeBase *getRecipe(Instruction *I) {
102 assert(Ingredient2Recipe.count(I) &&
103 "Recording this ingredients recipe was not requested");
104 assert(Ingredient2Recipe[I] != nullptr &&
105 "Ingredient doesn't have a recipe");
106 return Ingredient2Recipe[I];
107 }
108
109 /// Build a VPReplicationRecipe for \p VPI. If it is predicated, add the mask
110 /// as last operand. Range.End may be decreased to ensure same recipe behavior
111 /// from \p Range.Start to \p Range.End.
112 VPReplicateRecipe *handleReplication(VPInstruction *VPI, VFRange &Range);
113
114 VPValue *getVPValueOrAddLiveIn(Value *V) {
115 if (auto *I = dyn_cast<Instruction>(Val: V)) {
116 if (auto *R = Ingredient2Recipe.lookup(Val: I))
117 return R->getVPSingleValue();
118 }
119 return Plan.getOrAddLiveIn(V);
120 }
121};
122} // end namespace llvm
123
124#endif // LLVM_TRANSFORMS_VECTORIZE_VPRECIPEBUILDER_H
125