LLVM 17.0.0git
LICM.h
Go to the documentation of this file.
1//===- LICM.h - Loop Invariant Code Motion Pass -------*- 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// This pass performs loop invariant code motion, attempting to remove as much
10// code from the body of a loop as possible. It does this by either hoisting
11// code into the preheader block, or by sinking code to the exit blocks if it is
12// safe. This pass also promotes must-aliased memory locations in the loop to
13// live in registers, thus hoisting and sinking "invariant" loads and stores.
14//
15// This pass uses alias analysis for two purposes:
16//
17// 1. Moving loop invariant loads and calls out of loops. If we can determine
18// that a load or call inside of a loop never aliases anything stored to,
19// we can hoist it or sink it like any other instruction.
20// 2. Scalar Promotion of Memory - If there is a store instruction inside of
21// the loop, we try to move the store to happen AFTER the loop instead of
22// inside of the loop. This can only happen if a few conditions are true:
23// A. The pointer stored through is loop invariant
24// B. There are no stores or loads in the loop which _may_ alias the
25// pointer. There are no calls in the loop which mod/ref the pointer.
26// If these conditions are true, we can promote the loads and stores in the
27// loop of the pointer to use a temporary alloca'd variable. We then use
28// the SSAUpdater to construct the appropriate SSA form for the value.
29//
30//===----------------------------------------------------------------------===//
31
32#ifndef LLVM_TRANSFORMS_SCALAR_LICM_H
33#define LLVM_TRANSFORMS_SCALAR_LICM_H
34
36#include "llvm/IR/PassManager.h"
38
39namespace llvm {
40
41class LPMUpdater;
42class Loop;
43class LoopNest;
44
45extern cl::opt<unsigned> SetLicmMssaOptCap;
46extern cl::opt<unsigned> SetLicmMssaNoAccForPromotionCap;
47
49 unsigned MssaOptCap;
52
57
63};
64
65/// Performs Loop Invariant Code Motion Pass.
66class LICMPass : public PassInfoMixin<LICMPass> {
67 LICMOptions Opts;
68
69public:
70 LICMPass(unsigned MssaOptCap, unsigned MssaNoAccForPromotionCap,
71 bool AllowSpeculation)
72 : LICMPass(LICMOptions(MssaOptCap, MssaNoAccForPromotionCap,
73 AllowSpeculation)) {}
74 LICMPass(LICMOptions Opts) : Opts(Opts) {}
75
78
80 function_ref<StringRef(StringRef)> MapClassName2PassName);
81};
82
83/// Performs LoopNest Invariant Code Motion Pass.
84class LNICMPass : public PassInfoMixin<LNICMPass> {
85 LICMOptions Opts;
86
87public:
88 LNICMPass(unsigned MssaOptCap, unsigned MssaNoAccForPromotionCap,
89 bool AllowSpeculation)
90 : LNICMPass(LICMOptions(MssaOptCap, MssaNoAccForPromotionCap,
91 AllowSpeculation)) {}
92 LNICMPass(LICMOptions Opts) : Opts(Opts) {}
93
96
98 function_ref<StringRef(StringRef)> MapClassName2PassName);
99};
100} // end namespace llvm
101
102#endif // LLVM_TRANSFORMS_SCALAR_LICM_H
basic Basic Alias true
This header provides classes for managing per-loop analyses.
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
Performs Loop Invariant Code Motion Pass.
Definition: LICM.h:66
LICMPass(unsigned MssaOptCap, unsigned MssaNoAccForPromotionCap, bool AllowSpeculation)
Definition: LICM.h:70
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
Definition: LICM.cpp:291
LICMPass(LICMOptions Opts)
Definition: LICM.h:74
PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM, LoopStandardAnalysisResults &AR, LPMUpdater &U)
Definition: LICM.cpp:265
Performs LoopNest Invariant Code Motion Pass.
Definition: LICM.h:84
PreservedAnalyses run(LoopNest &L, LoopAnalysisManager &AM, LoopStandardAnalysisResults &AR, LPMUpdater &U)
Definition: LICM.cpp:301
LNICMPass(LICMOptions Opts)
Definition: LICM.h:92
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
Definition: LICM.cpp:332
LNICMPass(unsigned MssaOptCap, unsigned MssaNoAccForPromotionCap, bool AllowSpeculation)
Definition: LICM.h:88
This class provides an interface for updating the loop pass manager based on mutations to the loop ne...
This class represents a loop nest and can be used to query its properties.
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
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
An efficient, type-erasing, non-owning reference to a callable.
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
cl::opt< unsigned > SetLicmMssaNoAccForPromotionCap
cl::opt< unsigned > SetLicmMssaOptCap
unsigned MssaOptCap
Definition: LICM.h:49
unsigned MssaNoAccForPromotionCap
Definition: LICM.h:50
bool AllowSpeculation
Definition: LICM.h:51
LICMOptions(unsigned MssaOptCap, unsigned MssaNoAccForPromotionCap, bool AllowSpeculation)
Definition: LICM.h:58
The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:371