LLVM 17.0.0git
LoopUnrollPass.h
Go to the documentation of this file.
1//===- LoopUnrollPass.h -----------------------------------------*- 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_SCALAR_LOOPUNROLLPASS_H
10#define LLVM_TRANSFORMS_SCALAR_LOOPUNROLLPASS_H
11
13#include "llvm/IR/PassManager.h"
15#include <optional>
16
17namespace llvm {
18
19extern cl::opt<bool> ForgetSCEVInLoopUnroll;
20
21class Function;
22class Loop;
23class LPMUpdater;
24
25/// Loop unroll pass that only does full loop unrolling and peeling.
26class LoopFullUnrollPass : public PassInfoMixin<LoopFullUnrollPass> {
27 const int OptLevel;
28
29 /// If false, use a cost model to determine whether unrolling of a loop is
30 /// profitable. If true, only loops that explicitly request unrolling via
31 /// metadata are considered. All other loops are skipped.
32 const bool OnlyWhenForced;
33
34 /// If true, forget all loops when unrolling. If false, forget top-most loop
35 /// of the currently processed loops, which removes one entry at a time from
36 /// the internal SCEV records. For large loops, the former is faster.
37 const bool ForgetSCEV;
38
39public:
40 explicit LoopFullUnrollPass(int OptLevel = 2, bool OnlyWhenForced = false,
41 bool ForgetSCEV = false)
42 : OptLevel(OptLevel), OnlyWhenForced(OnlyWhenForced),
43 ForgetSCEV(ForgetSCEV) {}
44
47};
48
49/// A set of parameters used to control various transforms performed by the
50/// LoopUnroll pass. Each of the boolean parameters can be set to:
51/// true - enabling the transformation.
52/// false - disabling the transformation.
53/// None - relying on a global default.
54///
55/// There is also OptLevel parameter, which is used for additional loop unroll
56/// tuning.
57///
58/// Intended use is to create a default object, modify parameters with
59/// additional setters and then pass it to LoopUnrollPass.
60///
62 std::optional<bool> AllowPartial;
63 std::optional<bool> AllowPeeling;
64 std::optional<bool> AllowRuntime;
65 std::optional<bool> AllowUpperBound;
66 std::optional<bool> AllowProfileBasedPeeling;
67 std::optional<unsigned> FullUnrollMaxCount;
69
70 /// If false, use a cost model to determine whether unrolling of a loop is
71 /// profitable. If true, only loops that explicitly request unrolling via
72 /// metadata are considered. All other loops are skipped.
74
75 /// If true, forget all loops when unrolling. If false, forget top-most loop
76 /// of the currently processed loops, which removes one entry at a time from
77 /// the internal SCEV records. For large loops, the former is faster.
78 const bool ForgetSCEV;
79
81 bool ForgetSCEV = false)
84
85 /// Enables or disables partial unrolling. When disabled only full unrolling
86 /// is allowed.
88 AllowPartial = Partial;
89 return *this;
90 }
91
92 /// Enables or disables unrolling of loops with runtime trip count.
95 return *this;
96 }
97
98 /// Enables or disables loop peeling.
100 AllowPeeling = Peeling;
101 return *this;
102 }
103
104 /// Enables or disables the use of trip count upper bound
105 /// in loop unrolling.
107 AllowUpperBound = UpperBound;
108 return *this;
109 }
110
111 // Sets "optimization level" tuning parameter for loop unrolling.
113 OptLevel = O;
114 return *this;
115 }
116
117 // Enables or disables loop peeling basing on profile.
120 return *this;
121 }
122
123 // Sets the max full unroll count.
126 return *this;
127 }
128};
129
130/// Loop unroll pass that will support both full and partial unrolling.
131/// It is a function pass to have access to function and module analyses.
132/// It will also put loops into canonical form (simplified and LCSSA).
133class LoopUnrollPass : public PassInfoMixin<LoopUnrollPass> {
134 LoopUnrollOptions UnrollOpts;
135
136public:
137 /// This uses the target information (or flags) to control the thresholds for
138 /// different unrolling stategies but supports all of them.
139 explicit LoopUnrollPass(LoopUnrollOptions UnrollOpts = {})
140 : UnrollOpts(UnrollOpts) {}
141
142 PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
143 void printPipeline(raw_ostream &OS,
144 function_ref<StringRef(StringRef)> MapClassName2PassName);
145};
146
147} // end namespace llvm
148
149#endif // LLVM_TRANSFORMS_SCALAR_LOOPUNROLLPASS_H
This header provides classes for managing per-loop analyses.
#define F(x, y, z)
Definition: MD5.cpp:55
This header defines various interfaces for pass management in LLVM.
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:620
This class provides an interface for updating the loop pass manager based on mutations to the loop ne...
Loop unroll pass that only does full loop unrolling and peeling.
LoopFullUnrollPass(int OptLevel=2, bool OnlyWhenForced=false, bool ForgetSCEV=false)
PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM, LoopStandardAnalysisResults &AR, LPMUpdater &U)
Loop unroll pass that will support both full and partial unrolling.
LoopUnrollPass(LoopUnrollOptions UnrollOpts={})
This uses the target information (or flags) to control the thresholds for different unrolling stategi...
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:547
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:152
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Runtime
Detect stack use after return if not disabled runtime with (ASAN_OPTIONS=detect_stack_use_after_retur...
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
Definition: PassManager.h:912
cl::opt< bool > ForgetSCEVInLoopUnroll
The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...
A set of parameters used to control various transforms performed by the LoopUnroll pass.
LoopUnrollOptions & setPeeling(bool Peeling)
Enables or disables loop peeling.
bool OnlyWhenForced
If false, use a cost model to determine whether unrolling of a loop is profitable.
LoopUnrollOptions & setOptLevel(int O)
const bool ForgetSCEV
If true, forget all loops when unrolling.
std::optional< unsigned > FullUnrollMaxCount
std::optional< bool > AllowPartial
std::optional< bool > AllowRuntime
LoopUnrollOptions(int OptLevel=2, bool OnlyWhenForced=false, bool ForgetSCEV=false)
LoopUnrollOptions & setPartial(bool Partial)
Enables or disables partial unrolling.
std::optional< bool > AllowProfileBasedPeeling
std::optional< bool > AllowPeeling
LoopUnrollOptions & setFullUnrollMaxCount(unsigned O)
LoopUnrollOptions & setUpperBound(bool UpperBound)
Enables or disables the use of trip count upper bound in loop unrolling.
std::optional< bool > AllowUpperBound
LoopUnrollOptions & setRuntime(bool Runtime)
Enables or disables unrolling of loops with runtime trip count.
LoopUnrollOptions & setProfileBasedPeeling(int O)
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:371