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
14#include "AArch64GlobalISelUtils.h"
15#include "AArch64TargetMachine.h"
16#include "llvm/CodeGen/GlobalISel/Combiner.h"
17#include "llvm/CodeGen/GlobalISel/CombinerHelper.h"
18#include "llvm/CodeGen/GlobalISel/CombinerInfo.h"
19#include "llvm/CodeGen/GlobalISel/GIMatchTableExecutorImpl.h"
20#include "llvm/CodeGen/GlobalISel/GISelValueTracking.h"
21#include "llvm/CodeGen/GlobalISel/MIPatternMatch.h"
22#include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
23#include "llvm/CodeGen/MachineDominators.h"
24#include "llvm/CodeGen/MachineFunction.h"
25#include "llvm/CodeGen/MachineFunctionPass.h"
26#include "llvm/CodeGen/TargetPassConfig.h"
27#include "llvm/IR/Instructions.h"
28
29#define GET_GICOMBINER_DEPS
30#include "AArch64GenO0PreLegalizeGICombiner.inc"
31#undef GET_GICOMBINER_DEPS
32
33#define DEBUG_TYPE "aarch64-O0-prelegalizer-combiner"
34
35using namespace llvm;
36using namespace MIPatternMatch;
37namespace {
38#define GET_GICOMBINER_TYPES
39#include "AArch64GenO0PreLegalizeGICombiner.inc"
40#undef GET_GICOMBINER_TYPES
41
42class AArch64O0PreLegalizerCombinerImpl : public Combiner {
43protected:
44 const CombinerHelper Helper;
45 const AArch64O0PreLegalizerCombinerImplRuleConfig &RuleConfig;
46 const AArch64Subtarget &STI;
47 const LibcallLoweringInfo &Libcalls;
48
49public:
50 AArch64O0PreLegalizerCombinerImpl(
51 MachineFunction &MF, CombinerInfo &CInfo, const TargetPassConfig *TPC,
52 GISelValueTracking &VT, GISelCSEInfo *CSEInfo,
53 const AArch64O0PreLegalizerCombinerImplRuleConfig &RuleConfig,
54 const AArch64Subtarget &STI, const LibcallLoweringInfo &Libcalls);
55
56 static const char *getName() { return "AArch64O0PreLegalizerCombiner"; }
57
58 bool tryCombineAll(MachineInstr &I) const override;
59
60 bool tryCombineAllImpl(MachineInstr &I) const;
61
62private:
63#define GET_GICOMBINER_CLASS_MEMBERS
64#include "AArch64GenO0PreLegalizeGICombiner.inc"
65#undef GET_GICOMBINER_CLASS_MEMBERS
66};
67
68#define GET_GICOMBINER_IMPL
69#include "AArch64GenO0PreLegalizeGICombiner.inc"
70#undef GET_GICOMBINER_IMPL
71
72AArch64O0PreLegalizerCombinerImpl::AArch64O0PreLegalizerCombinerImpl(
73 MachineFunction &MF, CombinerInfo &CInfo, const TargetPassConfig *TPC,
74 GISelValueTracking &VT, GISelCSEInfo *CSEInfo,
75 const AArch64O0PreLegalizerCombinerImplRuleConfig &RuleConfig,
76 const AArch64Subtarget &STI, const LibcallLoweringInfo &Libcalls)
77 : Combiner(MF, CInfo, TPC, &VT, CSEInfo),
78 Helper(Observer, B, /*IsPreLegalize*/ true, &VT), RuleConfig(RuleConfig),
79 STI(STI), Libcalls(Libcalls),
80#define GET_GICOMBINER_CONSTRUCTOR_INITS
81#include "AArch64GenO0PreLegalizeGICombiner.inc"
82#undef GET_GICOMBINER_CONSTRUCTOR_INITS
83{
84}
85
86bool AArch64O0PreLegalizerCombinerImpl::tryCombineAll(MachineInstr &MI) const {
87 if (tryCombineAllImpl(I&: MI))
88 return true;
89
90 unsigned Opc = MI.getOpcode();
91 switch (Opc) {
92 case TargetOpcode::G_SHUFFLE_VECTOR:
93 return Helper.tryCombineShuffleVector(MI);
94 case TargetOpcode::G_MEMCPY_INLINE:
95 return Helper.tryEmitMemcpyInline(MI);
96 case TargetOpcode::G_MEMCPY:
97 case TargetOpcode::G_MEMMOVE:
98 case TargetOpcode::G_MEMSET: {
99 // At -O0 set a maxlen of 32 to inline;
100 unsigned MaxLen = 32;
101 // Try to inline memcpy type calls if optimizations are enabled.
102 if (Helper.tryCombineMemCpyFamily(MI, MaxLen))
103 return true;
104 if (Opc == TargetOpcode::G_MEMSET)
105 return llvm::AArch64GISelUtils::tryEmitBZero(MI, MIRBuilder&: B, Libcalls,
106 MinSize: CInfo.EnableMinSize);
107 return false;
108 }
109 }
110
111 return false;
112}
113
114// Pass boilerplate
115// ================
116
117class AArch64O0PreLegalizerCombiner : public MachineFunctionPass {
118public:
119 static char ID;
120
121 AArch64O0PreLegalizerCombiner();
122
123 StringRef getPassName() const override {
124 return "AArch64O0PreLegalizerCombiner";
125 }
126
127 bool runOnMachineFunction(MachineFunction &MF) override;
128
129 void getAnalysisUsage(AnalysisUsage &AU) const override;
130
131private:
132 AArch64O0PreLegalizerCombinerImplRuleConfig RuleConfig;
133};
134} // end anonymous namespace
135
136void AArch64O0PreLegalizerCombiner::getAnalysisUsage(AnalysisUsage &AU) const {
137 AU.addRequired<TargetPassConfig>();
138 AU.setPreservesCFG();
139 getSelectionDAGFallbackAnalysisUsage(AU);
140 AU.addRequired<GISelValueTrackingAnalysisLegacy>();
141 AU.addPreserved<GISelValueTrackingAnalysisLegacy>();
142 AU.addRequired<LibcallLoweringInfoWrapper>();
143 MachineFunctionPass::getAnalysisUsage(AU);
144}
145
146AArch64O0PreLegalizerCombiner::AArch64O0PreLegalizerCombiner()
147 : MachineFunctionPass(ID) {
148 if (!RuleConfig.parseCommandLineOption())
149 report_fatal_error(reason: "Invalid rule identifier");
150}
151
152bool AArch64O0PreLegalizerCombiner::runOnMachineFunction(MachineFunction &MF) {
153 if (MF.getProperties().hasFailedISel())
154 return false;
155 auto &TPC = getAnalysis<TargetPassConfig>();
156
157 const Function &F = MF.getFunction();
158 GISelValueTracking *VT =
159 &getAnalysis<GISelValueTrackingAnalysisLegacy>().get(MF);
160
161 const AArch64Subtarget &ST = MF.getSubtarget<AArch64Subtarget>();
162 const LibcallLoweringInfo &Libcalls =
163 getAnalysis<LibcallLoweringInfoWrapper>().getLibcallLowering(
164 M: *F.getParent(), Subtarget: ST);
165
166 CombinerInfo CInfo(/*AllowIllegalOps*/ true, /*ShouldLegalizeIllegal*/ false,
167 /*LegalizerInfo*/ nullptr, /*EnableOpt*/ false,
168 F.hasOptSize(), F.hasMinSize());
169 // Disable fixed-point iteration in the Combiner. This improves compile-time
170 // at the cost of possibly missing optimizations. See PR#94291 for details.
171 CInfo.MaxIterations = 1;
172
173 AArch64O0PreLegalizerCombinerImpl Impl(MF, CInfo, &TPC, *VT,
174 /*CSEInfo*/ nullptr, RuleConfig, ST,
175 Libcalls);
176 return Impl.combineMachineInstrs();
177}
178
179char AArch64O0PreLegalizerCombiner::ID = 0;
180INITIALIZE_PASS_BEGIN(AArch64O0PreLegalizerCombiner, DEBUG_TYPE,
181 "Combine AArch64 machine instrs before legalization",
182 false, false)
183INITIALIZE_PASS_DEPENDENCY(TargetPassConfig)
184INITIALIZE_PASS_DEPENDENCY(GISelValueTrackingAnalysisLegacy)
185INITIALIZE_PASS_DEPENDENCY(GISelCSEAnalysisWrapperPass)
186INITIALIZE_PASS_DEPENDENCY(LibcallLoweringInfoWrapper)
187INITIALIZE_PASS_END(AArch64O0PreLegalizerCombiner, DEBUG_TYPE,
188 "Combine AArch64 machine instrs before legalization", false,
189 false)
190
191namespace llvm {
192FunctionPass *createAArch64O0PreLegalizerCombiner() {
193 return new AArch64O0PreLegalizerCombiner();
194}
195} // end namespace llvm
196