1//=== lib/CodeGen/GlobalISel/MipsPreLegalizerCombiner.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 "Mips.h"
15#include "MipsLegalizerInfo.h"
16#include "MipsTargetMachine.h"
17#include "llvm/CodeGen/GlobalISel/Combiner.h"
18#include "llvm/CodeGen/GlobalISel/CombinerHelper.h"
19#include "llvm/CodeGen/GlobalISel/CombinerInfo.h"
20#include "llvm/CodeGen/GlobalISel/GISelValueTracking.h"
21#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
22#include "llvm/CodeGen/MachineFunctionPass.h"
23#include "llvm/CodeGen/MachinePassManager.h"
24#include "llvm/IR/Analysis.h"
25
26#define DEBUG_TYPE "mips-prelegalizer-combiner"
27
28using namespace llvm;
29
30namespace {
31struct MipsPreLegalizerCombinerInfo : public CombinerInfo {
32public:
33 MipsPreLegalizerCombinerInfo()
34 : CombinerInfo(/*AllowIllegalOps*/ true, /*ShouldLegalizeIllegal*/ false,
35 /*LegalizerInfo*/ nullptr, /*EnableOpt*/ false,
36 /*EnableOptSize*/ false, /*EnableMinSize*/ false) {}
37};
38
39class MipsPreLegalizerCombinerImpl : public Combiner {
40protected:
41 const MipsSubtarget &STI;
42 const CombinerHelper Helper;
43
44public:
45 MipsPreLegalizerCombinerImpl(MachineFunction &MF, CombinerInfo &CInfo,
46 GISelValueTracking &VT, GISelCSEInfo *CSEInfo,
47 const MipsSubtarget &STI,
48 MachineDominatorTree *MDT,
49 const LegalizerInfo *LI)
50 : Combiner(MF, CInfo, &VT, CSEInfo), STI(STI),
51 Helper(Observer, B, /*IsPreLegalize*/ true, &VT, MDT, LI) {}
52
53 static const char *getName() { return "MipsPreLegalizerCombiner"; }
54
55 void setupGeneratedPerFunctionState(MachineFunction &MF) override {
56 // TODO: TableGen-erate this class' impl.
57 }
58
59 bool tryCombineAll(MachineInstr &MI) const override {
60 switch (MI.getOpcode()) {
61 default:
62 return false;
63 case TargetOpcode::G_MEMCPY_INLINE:
64 case TargetOpcode::G_MEMSET_INLINE:
65 return Helper.tryCombineMemCpyFamily(MI);
66 case TargetOpcode::G_LOAD:
67 case TargetOpcode::G_SEXTLOAD:
68 case TargetOpcode::G_ZEXTLOAD: {
69 // Don't attempt to combine non power of 2 loads or unaligned loads when
70 // subtarget doesn't support them.
71 auto MMO = *MI.memoperands_begin();
72 const MipsSubtarget &STI = MI.getMF()->getSubtarget<MipsSubtarget>();
73 if (!MMO->getSize().hasValue() ||
74 !isPowerOf2_64(Value: MMO->getSize().getValue()))
75 return false;
76 bool isUnaligned = MMO->getAlign() < MMO->getSize().getValue();
77 if (!STI.systemSupportsUnalignedAccess() && isUnaligned)
78 return false;
79
80 return Helper.tryCombineExtendingLoads(MI);
81 }
82 }
83
84 return false;
85 }
86};
87
88// Pass boilerplate
89// ================
90
91class MipsPreLegalizerCombinerLegacy : public MachineFunctionPass {
92public:
93 static char ID;
94
95 MipsPreLegalizerCombinerLegacy();
96
97 StringRef getPassName() const override { return "MipsPreLegalizerCombiner"; }
98
99 bool runOnMachineFunction(MachineFunction &MF) override;
100
101 void getAnalysisUsage(AnalysisUsage &AU) const override;
102};
103} // end anonymous namespace
104
105void MipsPreLegalizerCombinerLegacy::getAnalysisUsage(AnalysisUsage &AU) const {
106 AU.addRequired<GISelValueTrackingAnalysisLegacy>();
107 AU.addPreserved<GISelValueTrackingAnalysisLegacy>();
108 AU.setPreservesCFG();
109 getSelectionDAGFallbackAnalysisUsage(AU);
110 MachineFunctionPass::getAnalysisUsage(AU);
111}
112
113MipsPreLegalizerCombinerLegacy::MipsPreLegalizerCombinerLegacy()
114 : MachineFunctionPass(ID) {}
115
116static bool
117runPreLegalizerCombinerOnMF(MachineFunction &MF,
118 function_ref<GISelValueTracking *()> GetVT) {
119 if (MF.getProperties().hasFailedISel())
120 return false;
121
122 const MipsSubtarget &ST = MF.getSubtarget<MipsSubtarget>();
123 const MipsLegalizerInfo *LI =
124 static_cast<const MipsLegalizerInfo *>(ST.getLegalizerInfo());
125
126 GISelValueTracking *VT = GetVT();
127 MipsPreLegalizerCombinerInfo PCInfo;
128 MipsPreLegalizerCombinerImpl Impl(MF, PCInfo, *VT, /*CSEInfo*/ nullptr, ST,
129 /*MDT*/ nullptr, LI);
130 return Impl.combineMachineInstrs();
131}
132
133char MipsPreLegalizerCombinerLegacy::ID = 0;
134INITIALIZE_PASS_BEGIN(MipsPreLegalizerCombinerLegacy, DEBUG_TYPE,
135 "Combine Mips machine instrs before legalization", false,
136 false)
137INITIALIZE_PASS_DEPENDENCY(GISelValueTrackingAnalysisLegacy)
138INITIALIZE_PASS_END(MipsPreLegalizerCombinerLegacy, DEBUG_TYPE,
139 "Combine Mips machine instrs before legalization", false,
140 false)
141
142FunctionPass *llvm::createMipsPreLegalizeCombinerLegacyPass() {
143 return new MipsPreLegalizerCombinerLegacy();
144}
145
146bool MipsPreLegalizerCombinerLegacy::runOnMachineFunction(MachineFunction &MF) {
147 return runPreLegalizerCombinerOnMF(MF, GetVT: [&]() {
148 return &getAnalysis<GISelValueTrackingAnalysisLegacy>().get(MF);
149 });
150}
151
152PreservedAnalyses
153MipsPreLegalizerCombinerPass::run(MachineFunction &MF,
154 MachineFunctionAnalysisManager &MFAM) {
155 bool Changed = runPreLegalizerCombinerOnMF(
156 MF, GetVT: [&]() { return &MFAM.getResult<GISelValueTrackingAnalysis>(IR&: MF); });
157 if (!Changed)
158 return PreservedAnalyses::all();
159 return getMachineFunctionPassPreservedAnalyses()
160 .preserveSet<CFGAnalyses>()
161 .preserve<GISelValueTrackingAnalysis>();
162}
163