LLVM 19.0.0git
MipsPostLegalizerCombiner.cpp
Go to the documentation of this file.
1//=== lib/CodeGen/GlobalISel/MipsPostLegalizerCombiner.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// after the legalizer.
11//
12//===----------------------------------------------------------------------===//
13
15#include "Mips.h"
16#include "MipsLegalizerInfo.h"
17#include "MipsSubtarget.h"
27
28#define GET_GICOMBINER_DEPS
29#include "MipsGenPostLegalizeGICombiner.inc"
30#undef GET_GICOMBINER_DEPS
31
32#define DEBUG_TYPE "mips-postlegalizer-combiner"
33
34using namespace llvm;
35using namespace MIPatternMatch;
36
37namespace {
38#define GET_GICOMBINER_TYPES
39#include "MipsGenPostLegalizeGICombiner.inc"
40#undef GET_GICOMBINER_TYPES
41
42class MipsPostLegalizerCombinerImpl : public Combiner {
43protected:
44 const MipsPostLegalizerCombinerImplRuleConfig &RuleConfig;
45 const MipsSubtarget &STI;
46 // TODO: Make CombinerHelper methods const.
47 mutable CombinerHelper Helper;
48
49public:
50 MipsPostLegalizerCombinerImpl(
51 MachineFunction &MF, CombinerInfo &CInfo, const TargetPassConfig *TPC,
52 GISelKnownBits &KB, GISelCSEInfo *CSEInfo,
53 const MipsPostLegalizerCombinerImplRuleConfig &RuleConfig,
54 const MipsSubtarget &STI, MachineDominatorTree *MDT,
55 const LegalizerInfo *LI);
56
57 static const char *getName() { return "MipsPostLegalizerCombiner"; }
58
59 bool tryCombineAll(MachineInstr &I) const override;
60
61private:
62#define GET_GICOMBINER_CLASS_MEMBERS
63#include "MipsGenPostLegalizeGICombiner.inc"
64#undef GET_GICOMBINER_CLASS_MEMBERS
65};
66
67#define GET_GICOMBINER_IMPL
68#include "MipsGenPostLegalizeGICombiner.inc"
69#undef GET_GICOMBINER_IMPL
70
71MipsPostLegalizerCombinerImpl::MipsPostLegalizerCombinerImpl(
72 MachineFunction &MF, CombinerInfo &CInfo, const TargetPassConfig *TPC,
73 GISelKnownBits &KB, GISelCSEInfo *CSEInfo,
74 const MipsPostLegalizerCombinerImplRuleConfig &RuleConfig,
75 const MipsSubtarget &STI, MachineDominatorTree *MDT,
76 const LegalizerInfo *LI)
77 : Combiner(MF, CInfo, TPC, &KB, CSEInfo), RuleConfig(RuleConfig), STI(STI),
78 Helper(Observer, B, /*IsPreLegalize*/ false, &KB, MDT, LI),
80#include "MipsGenPostLegalizeGICombiner.inc"
82{
83}
84
85// Pass boilerplate
86// ================
87
88class MipsPostLegalizerCombiner : public MachineFunctionPass {
89public:
90 static char ID;
91
92 MipsPostLegalizerCombiner(bool IsOptNone = false);
93
94 StringRef getPassName() const override { return "MipsPostLegalizerCombiner"; }
95
96 bool runOnMachineFunction(MachineFunction &MF) override;
97
98 void getAnalysisUsage(AnalysisUsage &AU) const override;
99
100private:
101 bool IsOptNone;
102 MipsPostLegalizerCombinerImplRuleConfig RuleConfig;
103};
104} // end anonymous namespace
105
106void MipsPostLegalizerCombiner::getAnalysisUsage(AnalysisUsage &AU) const {
108 AU.setPreservesCFG();
112 if (!IsOptNone) {
115 }
117}
118
119MipsPostLegalizerCombiner::MipsPostLegalizerCombiner(bool IsOptNone)
120 : MachineFunctionPass(ID), IsOptNone(IsOptNone) {
122
123 if (!RuleConfig.parseCommandLineOption())
124 report_fatal_error("Invalid rule identifier");
125}
126
127bool MipsPostLegalizerCombiner::runOnMachineFunction(MachineFunction &MF) {
128 if (MF.getProperties().hasProperty(
129 MachineFunctionProperties::Property::FailedISel))
130 return false;
131 auto *TPC = &getAnalysis<TargetPassConfig>();
132 const Function &F = MF.getFunction();
133 bool EnableOpt =
134 MF.getTarget().getOptLevel() != CodeGenOptLevel::None && !skipFunction(F);
135
137 const MipsLegalizerInfo *LI =
138 static_cast<const MipsLegalizerInfo *>(ST.getLegalizerInfo());
139
140 GISelKnownBits *KB = &getAnalysis<GISelKnownBitsAnalysis>().get(MF);
142 IsOptNone ? nullptr : &getAnalysis<MachineDominatorTree>();
143 CombinerInfo CInfo(/*AllowIllegalOps*/ false, /*ShouldLegalizeIllegal*/ true,
144 LI, EnableOpt, F.hasOptSize(), F.hasMinSize());
145 MipsPostLegalizerCombinerImpl Impl(MF, CInfo, TPC, *KB, /*CSEInfo*/ nullptr,
146 RuleConfig, ST, MDT, LI);
147 return Impl.combineMachineInstrs();
148}
149
150char MipsPostLegalizerCombiner::ID = 0;
151INITIALIZE_PASS_BEGIN(MipsPostLegalizerCombiner, DEBUG_TYPE,
152 "Combine Mips machine instrs after legalization", false,
153 false)
156INITIALIZE_PASS_END(MipsPostLegalizerCombiner, DEBUG_TYPE,
157 "Combine Mips machine instrs after legalization", false,
158 false)
159
160namespace llvm {
162 return new MipsPostLegalizerCombiner(IsOptNone);
163}
164} // end namespace llvm
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
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
Contains matchers for matching SSA Machine Instructions.
This file declares the targeting of the Machinelegalizer class for Mips.
#define GET_GICOMBINER_CONSTRUCTOR_INITS
Combine Mips machine instrs after legalization
#define DEBUG_TYPE
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:55
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:59
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:52
static StringRef getName(Value *V)
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:269
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:311
The CSE Analysis object.
Definition: CSEInfo.h:69
To use KnownBitsInfo analysis in a pass, KnownBitsInfo &Info = getAnalysis<GISelKnownBitsInfoAnalysis...
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 LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
const MachineFunctionProperties & getProperties() const
Get the function properties.
Representation of each machine instruction.
Definition: MachineInstr.h:69
This class provides legalization strategies.
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:50
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 report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:156
void initializeMipsPostLegalizerCombinerPass(PassRegistry &)
void getSelectionDAGFallbackAnalysisUsage(AnalysisUsage &AU)
Modify analysis usage so it preserves passes required for the SelectionDAG fallback.
Definition: Utils.cpp:1072
auto instrs(const MachineBasicBlock &BB)
FunctionPass * createMipsPostLegalizeCombiner(bool IsOptNone)