LLVM 22.0.0git
RISCVPostLegalizerCombiner.cpp
Go to the documentation of this file.
1//=== RISCVPostLegalizerCombiner.cpp --------------------------*- 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/// \file
10/// Post-legalization combines on generic MachineInstrs.
11///
12/// The combines here must preserve instruction legality.
13///
14/// Combines which don't rely on instruction legality should go in the
15/// RISCVPreLegalizerCombiner.
16///
17//===----------------------------------------------------------------------===//
18
19#include "RISCVTargetMachine.h"
30
31#define GET_GICOMBINER_DEPS
32#include "RISCVGenPostLegalizeGICombiner.inc"
33#undef GET_GICOMBINER_DEPS
34
35#define DEBUG_TYPE "riscv-postlegalizer-combiner"
36
37using namespace llvm;
38
39namespace {
40
41#define GET_GICOMBINER_TYPES
42#include "RISCVGenPostLegalizeGICombiner.inc"
43#undef GET_GICOMBINER_TYPES
44
45class RISCVPostLegalizerCombinerImpl : public Combiner {
46protected:
47 const CombinerHelper Helper;
48 const RISCVPostLegalizerCombinerImplRuleConfig &RuleConfig;
49 const RISCVSubtarget &STI;
50
51public:
52 RISCVPostLegalizerCombinerImpl(
53 MachineFunction &MF, CombinerInfo &CInfo, const TargetPassConfig *TPC,
54 GISelValueTracking &VT, GISelCSEInfo *CSEInfo,
55 const RISCVPostLegalizerCombinerImplRuleConfig &RuleConfig,
56 const RISCVSubtarget &STI, MachineDominatorTree *MDT,
57 const LegalizerInfo *LI);
58
59 static const char *getName() { return "RISCVPostLegalizerCombiner"; }
60
61 bool tryCombineAll(MachineInstr &I) const override;
62
63private:
64#define GET_GICOMBINER_CLASS_MEMBERS
65#include "RISCVGenPostLegalizeGICombiner.inc"
66#undef GET_GICOMBINER_CLASS_MEMBERS
67};
68
69#define GET_GICOMBINER_IMPL
70#include "RISCVGenPostLegalizeGICombiner.inc"
71#undef GET_GICOMBINER_IMPL
72
73RISCVPostLegalizerCombinerImpl::RISCVPostLegalizerCombinerImpl(
74 MachineFunction &MF, CombinerInfo &CInfo, const TargetPassConfig *TPC,
75 GISelValueTracking &VT, GISelCSEInfo *CSEInfo,
76 const RISCVPostLegalizerCombinerImplRuleConfig &RuleConfig,
77 const RISCVSubtarget &STI, MachineDominatorTree *MDT,
78 const LegalizerInfo *LI)
79 : Combiner(MF, CInfo, TPC, &VT, CSEInfo),
80 Helper(Observer, B, /*IsPreLegalize*/ false, &VT, MDT, LI),
81 RuleConfig(RuleConfig), STI(STI),
83#include "RISCVGenPostLegalizeGICombiner.inc"
85{
86}
87
88class RISCVPostLegalizerCombiner : public MachineFunctionPass {
89public:
90 static char ID;
91
92 RISCVPostLegalizerCombiner();
93
94 StringRef getPassName() const override {
95 return "RISCVPostLegalizerCombiner";
96 }
97
98 bool runOnMachineFunction(MachineFunction &MF) override;
99 void getAnalysisUsage(AnalysisUsage &AU) const override;
100
101private:
102 RISCVPostLegalizerCombinerImplRuleConfig RuleConfig;
103};
104} // end anonymous namespace
105
106void RISCVPostLegalizerCombiner::getAnalysisUsage(AnalysisUsage &AU) const {
108 AU.setPreservesCFG();
117}
118
119RISCVPostLegalizerCombiner::RISCVPostLegalizerCombiner()
121 if (!RuleConfig.parseCommandLineOption())
122 report_fatal_error("Invalid rule identifier");
123}
124
125bool RISCVPostLegalizerCombiner::runOnMachineFunction(MachineFunction &MF) {
126 if (MF.getProperties().hasFailedISel())
127 return false;
128 assert(MF.getProperties().hasLegalized() && "Expected a legalized function?");
129 auto *TPC = &getAnalysis<TargetPassConfig>();
130 const Function &F = MF.getFunction();
131 bool EnableOpt =
132 MF.getTarget().getOptLevel() != CodeGenOptLevel::None && !skipFunction(F);
133
135 const auto *LI = ST.getLegalizerInfo();
136
138 &getAnalysis<GISelValueTrackingAnalysisLegacy>().get(MF);
140 &getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
142 getAnalysis<GISelCSEAnalysisWrapperPass>().getCSEWrapper();
143 auto *CSEInfo = &Wrapper.get(TPC->getCSEConfig());
144
145 CombinerInfo CInfo(/*AllowIllegalOps*/ true, /*ShouldLegalizeIllegal*/ false,
146 /*LegalizerInfo*/ nullptr, EnableOpt, F.hasOptSize(),
147 F.hasMinSize());
148 RISCVPostLegalizerCombinerImpl Impl(MF, CInfo, TPC, *VT, CSEInfo, RuleConfig,
149 ST, MDT, LI);
150 return Impl.combineMachineInstrs();
151}
152
153char RISCVPostLegalizerCombiner::ID = 0;
154INITIALIZE_PASS_BEGIN(RISCVPostLegalizerCombiner, DEBUG_TYPE,
155 "Combine RISC-V MachineInstrs after legalization", false,
156 false)
159INITIALIZE_PASS_END(RISCVPostLegalizerCombiner, DEBUG_TYPE,
160 "Combine RISC-V MachineInstrs after legalization", false,
161 false)
162
164 return new RISCVPostLegalizerCombiner();
165}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
amdgpu aa AMDGPU Address space based Alias Analysis Wrapper
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:42
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:44
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:39
static StringRef getName(Value *V)
#define GET_GICOMBINER_CONSTRUCTOR_INITS
Combine RISC V MachineInstrs after 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.
LLVM_ABI void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:270
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:314
The actual analysis pass wrapper.
Definition: CSEInfo.h:229
Simple wrapper that does the following.
Definition: CSEInfo.h:211
The CSE Analysis object.
Definition: CSEInfo.h:71
To use KnownBitsInfo analysis in a pass, KnownBitsInfo &Info = getAnalysis<GISelValueTrackingInfoAnal...
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...
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:72
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
Definition: Pass.cpp:85
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:55
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
FunctionPass * createRISCVPostLegalizerCombiner()
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
Definition: Error.cpp:167
LLVM_ABI void getSelectionDAGFallbackAnalysisUsage(AnalysisUsage &AU)
Modify analysis usage so it preserves passes required for the SelectionDAG fallback.
Definition: Utils.cpp:1185