LLVM  14.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 
14 #include "AArch64GlobalISelUtils.h"
15 #include "AArch64TargetMachine.h"
27 #include "llvm/IR/Instructions.h"
28 #include "llvm/Support/Debug.h"
29 
30 #define DEBUG_TYPE "aarch64-O0-prelegalizer-combiner"
31 
32 using namespace llvm;
33 using namespace MIPatternMatch;
34 
36 protected:
38 
39 public:
41  : Helper(Helper) {}
42 };
43 
44 #define AARCH64O0PRELEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_DEPS
45 #include "AArch64GenO0PreLegalizeGICombiner.inc"
46 #undef AARCH64O0PRELEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_DEPS
47 
48 namespace {
49 #define AARCH64O0PRELEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_H
50 #include "AArch64GenO0PreLegalizeGICombiner.inc"
51 #undef AARCH64O0PRELEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_H
52 
53 class AArch64O0PreLegalizerCombinerInfo : public CombinerInfo {
54  GISelKnownBits *KB;
56  AArch64GenO0PreLegalizerCombinerHelperRuleConfig GeneratedRuleCfg;
57 
58 public:
59  AArch64O0PreLegalizerCombinerInfo(bool EnableOpt, bool OptSize, bool MinSize,
60  GISelKnownBits *KB,
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 
69  virtual bool combine(GISelChangeObserver &Observer, MachineInstr &MI,
70  MachineIRBuilder &B) const override;
71 };
72 
75  MachineIRBuilder &B) const {
76  CombinerHelper Helper(Observer, B, 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 
114 class AArch64O0PreLegalizerCombiner : public MachineFunctionPass {
115 public:
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 
130 void AArch64O0PreLegalizerCombiner::getAnalysisUsage(AnalysisUsage &AU) const {
132  AU.setPreservesCFG();
137 }
138 
139 AArch64O0PreLegalizerCombiner::AArch64O0PreLegalizerCombiner()
141  initializeAArch64O0PreLegalizerCombinerPass(*PassRegistry::getPassRegistry());
142 }
143 
144 bool 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 
159 INITIALIZE_PASS_BEGIN(AArch64O0PreLegalizerCombiner, DEBUG_TYPE,
160  "Combine AArch64 machine instrs before legalization",
161  false, false)
165 INITIALIZE_PASS_END(AArch64O0PreLegalizerCombiner, DEBUG_TYPE,
166  "Combine AArch64 machine instrs before legalization", false,
167  false)
168 
169 namespace llvm {
171  return new AArch64O0PreLegalizerCombiner();
172 }
173 } // end namespace llvm
MIPatternMatch.h
CombinerInfo.h
llvm::MachineFunctionProperties::hasProperty
bool hasProperty(Property P) const
Definition: MachineFunction.h:169
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:105
llvm
This file implements support for optimizing divisions by a constant.
Definition: AllocatorList.h:23
llvm::GISelCSEAnalysisWrapperPass
The actual analysis pass wrapper.
Definition: CSEInfo.h:220
DEBUG_TYPE
#define DEBUG_TYPE
Definition: AArch64O0PreLegalizerCombiner.cpp:30
llvm::GISelKnownBits
Definition: GISelKnownBits.h:29
llvm::initializeAArch64O0PreLegalizerCombinerPass
void initializeAArch64O0PreLegalizerCombinerPass(PassRegistry &)
llvm::Function
Definition: Function.h:62
GISelKnownBits.h
llvm::MachineFunctionPass
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
Definition: MachineFunctionPass.h:30
llvm::getSelectionDAGFallbackAnalysisUsage
void getSelectionDAGFallbackAnalysisUsage(AnalysisUsage &AU)
Modify analysis usage so it preserves passes required for the SelectionDAG fallback.
Definition: Utils.cpp:863
MachineIRBuilder.h
llvm::CombinerInfo
Definition: CombinerInfo.h:27
llvm::MachineFunctionPass::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
Definition: MachineFunctionPass.cpp:102
F
#define F(x, y, z)
Definition: MD5.cpp:56
MachineRegisterInfo.h
AArch64TargetMachine.h
llvm::GISelKnownBitsAnalysis
To use KnownBitsInfo analysis in a pass, KnownBitsInfo &Info = getAnalysis<GISelKnownBitsInfoAnalysis...
Definition: GISelKnownBits.h:113
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
llvm::MachineFunction::getProperties
const MachineFunctionProperties & getProperties() const
Get the function properties.
Definition: MachineFunction.h:725
INITIALIZE_PASS_BEGIN
INITIALIZE_PASS_BEGIN(AArch64O0PreLegalizerCombiner, DEBUG_TYPE, "Combine AArch64 machine instrs before legalization", false, false) INITIALIZE_PASS_END(AArch64O0PreLegalizerCombiner
false
Definition: StackSlotColoring.cpp:142
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::report_fatal_error
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:140
llvm::CombinerHelper
Definition: CombinerHelper.h:104
INITIALIZE_PASS_END
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:58
llvm::TargetPassConfig
Target-Independent Code Generator Pass Configuration Options.
Definition: TargetPassConfig.h:84
llvm::AArch64GISelUtils::tryEmitBZero
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 ...
Definition: AArch64GlobalISelUtils.cpp:63
AArch64GlobalISelUtils.h
Combine
Hexagon Vector Combine
Definition: HexagonVectorCombine.cpp:1525
llvm::MachineIRBuilder
Helper class to build MachineInstr.
Definition: MachineIRBuilder.h:212
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
llvm::Combiner
Definition: Combiner.h:27
INITIALIZE_PASS_DEPENDENCY
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
legalization
Combine AArch64 machine instrs before legalization
Definition: AArch64O0PreLegalizerCombiner.cpp:166
AArch64O0PreLegalizerCombinerHelperState
Definition: AArch64O0PreLegalizerCombiner.cpp:35
TargetPassConfig.h
MachineFunctionPass.h
llvm::MachineFunction
Definition: MachineFunction.h:234
CombinerHelper.h
llvm::AnalysisUsage::setPreservesCFG
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:253
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::AnalysisUsage::addPreserved
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
Definition: PassAnalysisSupport.h:98
Combiner.h
AArch64O0PreLegalizerCombinerHelperState::Helper
CombinerHelper & Helper
Definition: AArch64O0PreLegalizerCombiner.cpp:37
llvm::GISelChangeObserver
Abstract class that contains various methods for clients to notify about changes.
Definition: GISelChangeObserver.h:29
llvm::MachineFunction::getFunction
Function & getFunction()
Return the LLVM function that this machine code represents.
Definition: MachineFunction.h:600
llvm::createAArch64O0PreLegalizerCombiner
FunctionPass * createAArch64O0PreLegalizerCombiner()
Definition: AArch64O0PreLegalizerCombiner.cpp:170
Instructions.h
llvm::FunctionPass
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
llvm::AnalysisUsage::addRequired
AnalysisUsage & addRequired()
Definition: PassAnalysisSupport.h:75
llvm::MachineDominatorTree
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
Definition: MachineDominators.h:45
MachineFunction.h
combine
vector combine
Definition: VectorCombine.cpp:1217
Debug.h
AArch64O0PreLegalizerCombinerHelperState::AArch64O0PreLegalizerCombinerHelperState
AArch64O0PreLegalizerCombinerHelperState(CombinerHelper &Helper)
Definition: AArch64O0PreLegalizerCombiner.cpp:40
machine
coro Split coroutine into a set of functions driving its state machine
Definition: CoroSplit.cpp:2277
MachineDominators.h
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37