LLVM 17.0.0git
AArch64O0PreLegalizerCombiner.cpp
Go to the documentation of this file.
1//=== lib/CodeGen/GlobalISel/AArch64O0PreLegalizerCombiner.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
28#include "llvm/Support/Debug.h"
29
30#define DEBUG_TYPE "aarch64-O0-prelegalizer-combiner"
31
32using namespace llvm;
33using namespace MIPatternMatch;
34
36protected:
38
39public:
41 : Helper(Helper) {}
42};
43
44#define AARCH64O0PRELEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_DEPS
45#include "AArch64GenO0PreLegalizeGICombiner.inc"
46#undef AARCH64O0PRELEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_DEPS
47
48namespace {
49#define AARCH64O0PRELEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_H
50#include "AArch64GenO0PreLegalizeGICombiner.inc"
51#undef AARCH64O0PRELEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_H
52
53class AArch64O0PreLegalizerCombinerInfo : public CombinerInfo {
56 AArch64GenO0PreLegalizerCombinerHelperRuleConfig GeneratedRuleCfg;
57
58public:
59 AArch64O0PreLegalizerCombinerInfo(bool EnableOpt, bool OptSize, bool MinSize,
62 : CombinerInfo(/*AllowIllegalOps*/ true, /*ShouldLegalizeIllegal*/ false,
63 /*LegalizerInfo*/ nullptr, EnableOpt, OptSize, MinSize),
64 KB(KB), MDT(MDT) {
65 if (!GeneratedRuleCfg.parseCommandLineOption())
66 report_fatal_error("Invalid rule identifier");
67 }
68
70 MachineIRBuilder &B) const override;
71};
72
73bool AArch64O0PreLegalizerCombinerInfo::combine(GISelChangeObserver &Observer,
75 MachineIRBuilder &B) const {
76 CombinerHelper Helper(Observer, B, /*IsPreLegalize*/ true, KB, MDT);
77 AArch64GenO0PreLegalizerCombinerHelper Generated(GeneratedRuleCfg, Helper);
78
79 if (Generated.tryCombineAll(Observer, MI, B))
80 return true;
81
82 unsigned Opc = MI.getOpcode();
83 switch (Opc) {
84 case TargetOpcode::G_CONCAT_VECTORS:
85 return Helper.tryCombineConcatVectors(MI);
86 case TargetOpcode::G_SHUFFLE_VECTOR:
87 return Helper.tryCombineShuffleVector(MI);
88 case TargetOpcode::G_MEMCPY_INLINE:
89 return Helper.tryEmitMemcpyInline(MI);
90 case TargetOpcode::G_MEMCPY:
91 case TargetOpcode::G_MEMMOVE:
92 case TargetOpcode::G_MEMSET: {
93 // At -O0 set a maxlen of 32 to inline;
94 unsigned MaxLen = 32;
95 // Try to inline memcpy type calls if optimizations are enabled.
96 if (Helper.tryCombineMemCpyFamily(MI, MaxLen))
97 return true;
98 if (Opc == TargetOpcode::G_MEMSET)
99 return llvm::AArch64GISelUtils::tryEmitBZero(MI, B, EnableMinSize);
100 return false;
101 }
102 }
103
104 return false;
105}
106
107#define AARCH64O0PRELEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_CPP
108#include "AArch64GenO0PreLegalizeGICombiner.inc"
109#undef AARCH64O0PRELEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_CPP
110
111// Pass boilerplate
112// ================
113
114class AArch64O0PreLegalizerCombiner : public MachineFunctionPass {
115public:
116 static char ID;
117
118 AArch64O0PreLegalizerCombiner();
119
120 StringRef getPassName() const override {
121 return "AArch64O0PreLegalizerCombiner";
122 }
123
124 bool runOnMachineFunction(MachineFunction &MF) override;
125
126 void getAnalysisUsage(AnalysisUsage &AU) const override;
127};
128} // end anonymous namespace
129
130void AArch64O0PreLegalizerCombiner::getAnalysisUsage(AnalysisUsage &AU) const {
132 AU.setPreservesCFG();
137}
138
139AArch64O0PreLegalizerCombiner::AArch64O0PreLegalizerCombiner()
142}
143
144bool AArch64O0PreLegalizerCombiner::runOnMachineFunction(MachineFunction &MF) {
145 if (MF.getProperties().hasProperty(
146 MachineFunctionProperties::Property::FailedISel))
147 return false;
148 auto &TPC = getAnalysis<TargetPassConfig>();
149
150 const Function &F = MF.getFunction();
151 GISelKnownBits *KB = &getAnalysis<GISelKnownBitsAnalysis>().get(MF);
152 AArch64O0PreLegalizerCombinerInfo PCInfo(
153 false, F.hasOptSize(), F.hasMinSize(), KB, nullptr /* MDT */);
154 Combiner C(PCInfo, &TPC);
155 return C.combineMachineInstrs(MF, nullptr /* CSEInfo */);
156}
157
158char AArch64O0PreLegalizerCombiner::ID = 0;
159INITIALIZE_PASS_BEGIN(AArch64O0PreLegalizerCombiner, DEBUG_TYPE,
160 "Combine AArch64 machine instrs before legalization",
161 false, false)
165INITIALIZE_PASS_END(AArch64O0PreLegalizerCombiner, DEBUG_TYPE,
166 "Combine AArch64 machine instrs before legalization", false,
167 false)
168
169namespace llvm {
171 return new AArch64O0PreLegalizerCombiner();
172}
173} // end namespace llvm
Combine AArch64 machine instrs before legalization
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...
Interface for Targets to specify which operations are combined how and when.
This contains common code to drive combines.
Provides analysis for querying information about KnownBits during GISel passes.
Hexagon Vector Combine
IRTranslator LLVM IR MI
#define F(x, y, z)
Definition: MD5.cpp:55
Contains matchers for matching SSA Machine Instructions.
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:59
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:52
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:265
virtual bool combine(GISelChangeObserver &Observer, MachineInstr &MI, MachineIRBuilder &B) const =0
Attempt to combine instructions using MI as the root.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:308
The actual analysis pass wrapper.
Definition: CSEInfo.h:222
Abstract class that contains various methods for clients to notify about changes.
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
Function & getFunction()
Return the LLVM function that this machine code represents.
const MachineFunctionProperties & getProperties() const
Get the function properties.
Helper class to build MachineInstr.
Representation of each machine instruction.
Definition: MachineInstr.h:68
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
Target-Independent Code Generator Pass Configuration Options.
bool tryEmitBZero(MachineInstr &MI, MachineIRBuilder &MIRBuilder, bool MinSize)
Replace a G_MEMSET with a value of 0 with a G_BZERO instruction if it is supported and beneficial to ...
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
FunctionPass * createAArch64O0PreLegalizerCombiner()
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:145
void getSelectionDAGFallbackAnalysisUsage(AnalysisUsage &AU)
Modify analysis usage so it preserves passes required for the SelectionDAG fallback.
Definition: Utils.cpp:895
auto instrs(const MachineBasicBlock &BB)
void initializeAArch64O0PreLegalizerCombinerPass(PassRegistry &)