LLVM 20.0.0git
RISCVPreLegalizerCombiner.cpp
Go to the documentation of this file.
1//=== RISCVPreLegalizerCombiner.cpp ---------------------------------------===//
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 does combining of machine instructions at the generic MI level,
10// before the legalizer.
11//
12//===----------------------------------------------------------------------===//
13
14#include "RISCVSubtarget.h"
26
27#define GET_GICOMBINER_DEPS
28#include "RISCVGenPreLegalizeGICombiner.inc"
29#undef GET_GICOMBINER_DEPS
30
31#define DEBUG_TYPE "riscv-prelegalizer-combiner"
32
33using namespace llvm;
34
35namespace {
36
37#define GET_GICOMBINER_TYPES
38#include "RISCVGenPreLegalizeGICombiner.inc"
39#undef GET_GICOMBINER_TYPES
40
41class RISCVPreLegalizerCombinerImpl : public Combiner {
42protected:
43 const CombinerHelper Helper;
44 const RISCVPreLegalizerCombinerImplRuleConfig &RuleConfig;
45 const RISCVSubtarget &STI;
46
47public:
48 RISCVPreLegalizerCombinerImpl(
49 MachineFunction &MF, CombinerInfo &CInfo, const TargetPassConfig *TPC,
50 GISelKnownBits &KB, GISelCSEInfo *CSEInfo,
51 const RISCVPreLegalizerCombinerImplRuleConfig &RuleConfig,
52 const RISCVSubtarget &STI, MachineDominatorTree *MDT,
53 const LegalizerInfo *LI);
54
55 static const char *getName() { return "RISCV00PreLegalizerCombiner"; }
56
57 bool tryCombineAll(MachineInstr &I) const override;
58
59private:
60#define GET_GICOMBINER_CLASS_MEMBERS
61#include "RISCVGenPreLegalizeGICombiner.inc"
62#undef GET_GICOMBINER_CLASS_MEMBERS
63};
64
65#define GET_GICOMBINER_IMPL
66#include "RISCVGenPreLegalizeGICombiner.inc"
67#undef GET_GICOMBINER_IMPL
68
69RISCVPreLegalizerCombinerImpl::RISCVPreLegalizerCombinerImpl(
70 MachineFunction &MF, CombinerInfo &CInfo, const TargetPassConfig *TPC,
71 GISelKnownBits &KB, GISelCSEInfo *CSEInfo,
72 const RISCVPreLegalizerCombinerImplRuleConfig &RuleConfig,
73 const RISCVSubtarget &STI, MachineDominatorTree *MDT,
74 const LegalizerInfo *LI)
75 : Combiner(MF, CInfo, TPC, &KB, CSEInfo),
76 Helper(Observer, B, /*IsPreLegalize*/ true, &KB, MDT, LI),
77 RuleConfig(RuleConfig), STI(STI),
79#include "RISCVGenPreLegalizeGICombiner.inc"
81{
82}
83
84// Pass boilerplate
85// ================
86
87class RISCVPreLegalizerCombiner : public MachineFunctionPass {
88public:
89 static char ID;
90
91 RISCVPreLegalizerCombiner();
92
93 StringRef getPassName() const override { return "RISCVPreLegalizerCombiner"; }
94
95 bool runOnMachineFunction(MachineFunction &MF) override;
96
97 void getAnalysisUsage(AnalysisUsage &AU) const override;
98
99private:
100 RISCVPreLegalizerCombinerImplRuleConfig RuleConfig;
101};
102} // end anonymous namespace
103
104void RISCVPreLegalizerCombiner::getAnalysisUsage(AnalysisUsage &AU) const {
106 AU.setPreservesCFG();
115}
116
117RISCVPreLegalizerCombiner::RISCVPreLegalizerCombiner()
120
121 if (!RuleConfig.parseCommandLineOption())
122 report_fatal_error("Invalid rule identifier");
123}
124
125bool RISCVPreLegalizerCombiner::runOnMachineFunction(MachineFunction &MF) {
126 if (MF.getProperties().hasProperty(
127 MachineFunctionProperties::Property::FailedISel))
128 return false;
129 auto &TPC = getAnalysis<TargetPassConfig>();
130
131 // Enable CSE.
133 getAnalysis<GISelCSEAnalysisWrapperPass>().getCSEWrapper();
134 auto *CSEInfo = &Wrapper.get(TPC.getCSEConfig());
135
137 const auto *LI = ST.getLegalizerInfo();
138
139 const Function &F = MF.getFunction();
140 bool EnableOpt =
141 MF.getTarget().getOptLevel() != CodeGenOptLevel::None && !skipFunction(F);
142 GISelKnownBits *KB = &getAnalysis<GISelKnownBitsAnalysis>().get(MF);
144 &getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
145 CombinerInfo CInfo(/*AllowIllegalOps*/ true, /*ShouldLegalizeIllegal*/ false,
146 /*LegalizerInfo*/ nullptr, EnableOpt, F.hasOptSize(),
147 F.hasMinSize());
148 // Disable fixed-point iteration to reduce compile-time
149 CInfo.MaxIterations = 1;
150 CInfo.ObserverLvl = CombinerInfo::ObserverLevel::SinglePass;
151 // This is the first Combiner, so the input IR might contain dead
152 // instructions.
153 CInfo.EnableFullDCE = true;
154 RISCVPreLegalizerCombinerImpl Impl(MF, CInfo, &TPC, *KB, CSEInfo, RuleConfig,
155 ST, MDT, LI);
156 return Impl.combineMachineInstrs();
157}
158
159char RISCVPreLegalizerCombiner::ID = 0;
160INITIALIZE_PASS_BEGIN(RISCVPreLegalizerCombiner, DEBUG_TYPE,
161 "Combine RISC-V machine instrs before legalization", false,
162 false)
166INITIALIZE_PASS_END(RISCVPreLegalizerCombiner, DEBUG_TYPE,
167 "Combine RISC-V machine instrs before legalization", false,
168 false)
169
170namespace llvm {
172 return new RISCVPreLegalizerCombiner();
173}
174} // end namespace llvm
amdgpu aa AMDGPU Address space based Alias Analysis Wrapper
basic Basic Alias true
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
Provides analysis for continuously CSEing during GISel passes.
This contains common combine transformations that may be used in a combine pass,or by the target else...
Option class for Targets to specify which operations are combined how and when.
This contains the base class for all Combiners generated by TableGen.
Provides analysis for querying information about KnownBits during GISel passes.
Hexagon Vector Combine
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
This file declares the MachineIRBuilder class.
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:55
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:57
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:52
static StringRef getName(Value *V)
#define GET_GICOMBINER_CONSTRUCTOR_INITS
Combine RISC V machine instrs before legalization
#define DEBUG_TYPE
Target-Independent Code Generator Pass Configuration Options pass.
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:256
Combiner implementation.
Definition: Combiner.h:34
virtual bool tryCombineAll(MachineInstr &I) const =0
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:310
The actual analysis pass wrapper.
Definition: CSEInfo.h:225
Simple wrapper that does the following.
Definition: CSEInfo.h:207
The CSE Analysis object.
Definition: CSEInfo.h:70
To use KnownBitsInfo analysis in a pass, KnownBitsInfo &Info = getAnalysis<GISelKnownBitsInfoAnalysis...
Analysis pass which computes a MachineDominatorTree.
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
virtual bool runOnMachineFunction(MachineFunction &MF)=0
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
bool hasProperty(Property P) const
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
Function & getFunction()
Return the LLVM function that this machine code represents.
const MachineFunctionProperties & getProperties() const
Get the function properties.
const TargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
Representation of each machine instruction.
Definition: MachineInstr.h:69
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
Definition: Pass.cpp:81
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:51
CodeGenOptLevel getOptLevel() const
Returns the optimization level: None, Less, Default, or Aggressive.
Target-Independent Code Generator Pass Configuration Options.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void initializeRISCVPreLegalizerCombinerPass(PassRegistry &)
FunctionPass * createRISCVPreLegalizerCombiner()
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:167
void getSelectionDAGFallbackAnalysisUsage(AnalysisUsage &AU)
Modify analysis usage so it preserves passes required for the SelectionDAG fallback.
Definition: Utils.cpp:1153
auto instrs(const MachineBasicBlock &BB)