LLVM 17.0.0git
MipsPreLegalizerCombiner.cpp
Go to the documentation of this file.
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 "MipsTargetMachine.h"
22
23#define DEBUG_TYPE "mips-prelegalizer-combiner"
24
25using namespace llvm;
26
27namespace {
28class MipsPreLegalizerCombinerInfo : public CombinerInfo {
29public:
30 MipsPreLegalizerCombinerInfo()
31 : CombinerInfo(/*AllowIllegalOps*/ true, /*ShouldLegalizeIllegal*/ false,
32 /*LegalizerInfo*/ nullptr, /*EnableOpt*/ false,
33 /*EnableOptSize*/ false, /*EnableMinSize*/ false) {}
35 MachineIRBuilder &B) const override;
36};
37
38bool MipsPreLegalizerCombinerInfo::combine(GISelChangeObserver &Observer,
40 MachineIRBuilder &B) const {
41 CombinerHelper Helper(Observer, B, /*IsPreLegalize*/ true);
42
43 switch (MI.getOpcode()) {
44 default:
45 return false;
46 case TargetOpcode::G_MEMCPY_INLINE:
47 return Helper.tryEmitMemcpyInline(MI);
48 case TargetOpcode::G_LOAD:
49 case TargetOpcode::G_SEXTLOAD:
50 case TargetOpcode::G_ZEXTLOAD: {
51 // Don't attempt to combine non power of 2 loads or unaligned loads when
52 // subtarget doesn't support them.
53 auto MMO = *MI.memoperands_begin();
54 const MipsSubtarget &STI = MI.getMF()->getSubtarget<MipsSubtarget>();
55 if (!isPowerOf2_64(MMO->getSize()))
56 return false;
57 bool isUnaligned = MMO->getAlign() < MMO->getSize();
58 if (!STI.systemSupportsUnalignedAccess() && isUnaligned)
59 return false;
60
61 return Helper.tryCombineExtendingLoads(MI);
62 }
63 }
64
65 return false;
66}
67
68// Pass boilerplate
69// ================
70
71class MipsPreLegalizerCombiner : public MachineFunctionPass {
72public:
73 static char ID;
74
75 MipsPreLegalizerCombiner();
76
77 StringRef getPassName() const override { return "MipsPreLegalizerCombiner"; }
78
79 bool runOnMachineFunction(MachineFunction &MF) override;
80
81 void getAnalysisUsage(AnalysisUsage &AU) const override;
82};
83} // end anonymous namespace
84
85void MipsPreLegalizerCombiner::getAnalysisUsage(AnalysisUsage &AU) const {
87 AU.setPreservesCFG();
90}
91
92MipsPreLegalizerCombiner::MipsPreLegalizerCombiner() : MachineFunctionPass(ID) {
94}
95
96bool MipsPreLegalizerCombiner::runOnMachineFunction(MachineFunction &MF) {
98 MachineFunctionProperties::Property::FailedISel))
99 return false;
100 auto *TPC = &getAnalysis<TargetPassConfig>();
101 MipsPreLegalizerCombinerInfo PCInfo;
102 Combiner C(PCInfo, TPC);
103 return C.combineMachineInstrs(MF, nullptr);
104}
105
106char MipsPreLegalizerCombiner::ID = 0;
107INITIALIZE_PASS_BEGIN(MipsPreLegalizerCombiner, DEBUG_TYPE,
108 "Combine Mips machine instrs before legalization", false,
109 false)
111INITIALIZE_PASS_END(MipsPreLegalizerCombiner, DEBUG_TYPE,
112 "Combine Mips machine instrs before legalization", false,
113 false)
114
115namespace llvm {
117 return new MipsPreLegalizerCombiner();
118}
119} // 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...
Interface for Targets to specify which operations are combined how and when.
This contains common code to drive combines.
Hexagon Vector Combine
IRTranslator LLVM IR MI
Contains matchers for matching SSA Machine Instructions.
Combine Mips machine instrs before 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
Target-Independent Code Generator Pass Configuration Options pass.
vector combine
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:265
bool tryCombineExtendingLoads(MachineInstr &MI)
If MI is extend that consumes the result of a load, try to combine it.
bool tryEmitMemcpyInline(MachineInstr &MI)
Emit loads and stores that perform the given memcpy.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:308
Abstract class that contains various methods for clients to notify about changes.
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 MachineFunctionProperties & getProperties() const
Get the function properties.
Helper class to build MachineInstr.
Representation of each machine instruction.
Definition: MachineInstr.h:68
bool systemSupportsUnalignedAccess() const
Does the system support unaligned memory access.
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.
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
void initializeMipsPreLegalizerCombinerPass(PassRegistry &)
constexpr bool isPowerOf2_64(uint64_t Value)
Return true if the argument is a power of two > 0 (64 bit edition.)
Definition: MathExtras.h:293
FunctionPass * createMipsPreLegalizeCombiner()
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)