LLVM 17.0.0git
CSEInfo.h
Go to the documentation of this file.
1//===- llvm/CodeGen/GlobalISel/CSEInfo.h ------------------*- C++ -*-===//
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/// \file
9/// Provides analysis for continuously CSEing during GISel passes.
10///
11//===----------------------------------------------------------------------===//
12#ifndef LLVM_CODEGEN_GLOBALISEL_CSEINFO_H
13#define LLVM_CODEGEN_GLOBALISEL_CSEINFO_H
14
15#include "llvm/ADT/FoldingSet.h"
22
23namespace llvm {
24class MachineBasicBlock;
25
26/// A class that wraps MachineInstrs and derives from FoldingSetNode in order to
27/// be uniqued in a CSEMap. The tradeoff here is extra memory allocations for
28/// UniqueMachineInstr vs making MachineInstr bigger.
30 friend class GISelCSEInfo;
31 const MachineInstr *MI;
32 explicit UniqueMachineInstr(const MachineInstr *MI) : MI(MI) {}
33
34public:
36};
37
38// A CSE config for fully optimized builds.
40public:
41 virtual ~CSEConfigFull() = default;
42 bool shouldCSEOpc(unsigned Opc) override;
43};
44
45// Commonly used for O0 config.
47public:
48 virtual ~CSEConfigConstantOnly() = default;
49 bool shouldCSEOpc(unsigned Opc) override;
50};
51
52// Returns the standard expected CSEConfig for the given optimization level.
53// We have this logic here so targets can make use of it from their derived
54// TargetPassConfig, but can't put this logic into TargetPassConfig directly
55// because the CodeGen library can't depend on GlobalISel.
56std::unique_ptr<CSEConfigBase>
58
59/// The CSE Analysis object.
60/// This installs itself as a delegate to the MachineFunction to track
61/// new instructions as well as deletions. It however will not be able to
62/// track instruction mutations. In such cases, recordNewInstruction should be
63/// called (for eg inside MachineIRBuilder::recordInsertion).
64/// Also because of how just the instruction can be inserted without adding any
65/// operands to the instruction, instructions are uniqued and inserted lazily.
66/// CSEInfo should assert when trying to enter an incomplete instruction into
67/// the CSEMap. There is Opcode level granularity on which instructions can be
68/// CSE'd and for now, only Generic instructions are CSEable.
70 // Make it accessible only to CSEMIRBuilder.
71 friend class CSEMIRBuilder;
72
73 BumpPtrAllocator UniqueInstrAllocator;
75 MachineRegisterInfo *MRI = nullptr;
76 MachineFunction *MF = nullptr;
77 std::unique_ptr<CSEConfigBase> CSEOpt;
78 /// Keep a cache of UniqueInstrs for each MachineInstr. In GISel,
79 /// often instructions are mutated (while their ID has completely changed).
80 /// Whenever mutation happens, invalidate the UniqueMachineInstr for the
81 /// MachineInstr
83
84 /// Store instructions that are not fully formed in TemporaryInsts.
85 /// Also because CSE insertion happens lazily, we can remove insts from this
86 /// list and avoid inserting and then removing from the CSEMap.
87 GISelWorkList<8> TemporaryInsts;
88
89 // Only used in asserts.
90 DenseMap<unsigned, unsigned> OpcodeHitTable;
91
92 bool isUniqueMachineInstValid(const UniqueMachineInstr &UMI) const;
93
94 void invalidateUniqueMachineInstr(UniqueMachineInstr *UMI);
95
96 UniqueMachineInstr *getNodeIfExists(FoldingSetNodeID &ID,
97 MachineBasicBlock *MBB, void *&InsertPos);
98
99 /// Allocate and construct a new UniqueMachineInstr for MI and return.
100 UniqueMachineInstr *getUniqueInstrForMI(const MachineInstr *MI);
101
102 void insertNode(UniqueMachineInstr *UMI, void *InsertPos = nullptr);
103
104 /// Get the MachineInstr(Unique) if it exists already in the CSEMap and the
105 /// same MachineBasicBlock.
106 MachineInstr *getMachineInstrIfExists(FoldingSetNodeID &ID,
108 void *&InsertPos);
109
110 /// Use this method to allocate a new UniqueMachineInstr for MI and insert it
111 /// into the CSEMap. MI should return true for shouldCSE(MI->getOpcode())
112 void insertInstr(MachineInstr *MI, void *InsertPos = nullptr);
113
114public:
115 GISelCSEInfo() = default;
116
117 virtual ~GISelCSEInfo();
118
119 void setMF(MachineFunction &MF);
120
121 Error verify();
122
123 /// Records a newly created inst in a list and lazily insert it to the CSEMap.
124 /// Sometimes, this method might be called with a partially constructed
125 /// MachineInstr,
126 // (right after BuildMI without adding any operands) - and in such cases,
127 // defer the hashing of the instruction to a later stage.
129
130 /// Use this callback to inform CSE about a newly fully created instruction.
132
133 /// Use this callback to insert all the recorded instructions. At this point,
134 /// all of these insts need to be fully constructed and should not be missing
135 /// any operands.
136 void handleRecordedInsts();
137
138 /// Remove this inst from the CSE map. If this inst has not been inserted yet,
139 /// it will be removed from the Tempinsts list if it exists.
141
142 void releaseMemory();
143
144 void setCSEConfig(std::unique_ptr<CSEConfigBase> Opt) {
145 CSEOpt = std::move(Opt);
146 }
147
148 bool shouldCSE(unsigned Opc) const;
149
150 void analyze(MachineFunction &MF);
151
152 void countOpcodeHit(unsigned Opc);
153
154 void print();
155
156 // Observer API
157 void erasingInstr(MachineInstr &MI) override;
158 void createdInstr(MachineInstr &MI) override;
159 void changingInstr(MachineInstr &MI) override;
160 void changedInstr(MachineInstr &MI) override;
161};
162
163class TargetRegisterClass;
164class RegisterBank;
165
166// Simple builder class to easily profile properties about MIs.
169 const MachineRegisterInfo &MRI;
170
171public:
173 : ID(ID), MRI(MRI) {}
174 // Profiling methods.
175 const GISelInstProfileBuilder &addNodeIDOpcode(unsigned Opc) const;
176 const GISelInstProfileBuilder &addNodeIDRegType(const LLT Ty) const;
178
180 addNodeIDRegType(const TargetRegisterClass *RC) const;
182
184
186
187 const GISelInstProfileBuilder &addNodeIDImmediate(int64_t Imm) const;
189 addNodeIDMBB(const MachineBasicBlock *MBB) const;
190
193
194 const GISelInstProfileBuilder &addNodeIDFlag(unsigned Flag) const;
196};
197
198/// Simple wrapper that does the following.
199/// 1) Lazily evaluate the MachineFunction to compute CSEable instructions.
200/// 2) Allows configuration of which instructions are CSEd through CSEConfig
201/// object. Provides a method called get which takes a CSEConfig object.
203 GISelCSEInfo Info;
204 MachineFunction *MF = nullptr;
205 bool AlreadyComputed = false;
206
207public:
208 /// Takes a CSEConfigBase object that defines what opcodes get CSEd.
209 /// If CSEConfig is already set, and the CSE Analysis has been preserved,
210 /// it will not use the new CSEOpt(use Recompute to force using the new
211 /// CSEOpt).
212 GISelCSEInfo &get(std::unique_ptr<CSEConfigBase> CSEOpt,
213 bool ReCompute = false);
214 void setMF(MachineFunction &MFunc) { MF = &MFunc; }
215 void setComputed(bool Computed) { AlreadyComputed = Computed; }
216 void releaseMemory() { Info.releaseMemory(); }
217};
218
219/// The actual analysis pass wrapper.
222
223public:
224 static char ID;
226
227 void getAnalysisUsage(AnalysisUsage &AU) const override;
228
231
232 bool runOnMachineFunction(MachineFunction &MF) override;
233
234 void releaseMemory() override {
235 Wrapper.releaseMemory();
236 Wrapper.setComputed(false);
237 }
238};
239
240} // namespace llvm
241
242#endif
unsigned const MachineRegisterInfo * MRI
MachineBasicBlock & MBB
amdgpu aa AMDGPU Address space based Alias Analysis Wrapper
This file defines the BumpPtrAllocator interface.
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
This file defines a hash set that can be used to remove duplication of nodes in a graph.
This contains common code to allow clients to notify changes to machine instr.
IRTranslator LLVM IR MI
Load MIR Sample Profile
unsigned Reg
Represent the analysis usage information of a pass.
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:66
bool shouldCSEOpc(unsigned Opc) override
Definition: CSEInfo.cpp:73
virtual ~CSEConfigConstantOnly()=default
bool shouldCSEOpc(unsigned Opc) override
------— CSEConfigFull -------— ///
Definition: CSEInfo.cpp:37
virtual ~CSEConfigFull()=default
Defines a builder that does CSE of MachineInstructions using GISelCSEInfo.
Definition: CSEMIRBuilder.h:32
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
Node - This class is used to maintain the singly linked bucket list in a folding set.
Definition: FoldingSet.h:136
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
Definition: FoldingSet.h:318
FoldingSet - This template class is used to instantiate a specialized implementation of the folding s...
Definition: FoldingSet.h:520
The actual analysis pass wrapper.
Definition: CSEInfo.h:220
const GISelCSEAnalysisWrapper & getCSEWrapper() const
Definition: CSEInfo.h:229
void releaseMemory() override
releaseMemory() - This member can be implemented by a pass if it wants to be able to release its memo...
Definition: CSEInfo.h:234
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: CSEInfo.cpp:438
bool runOnMachineFunction(MachineFunction &MF) override
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
Definition: CSEInfo.cpp:443
GISelCSEAnalysisWrapper & getCSEWrapper()
Definition: CSEInfo.h:230
Simple wrapper that does the following.
Definition: CSEInfo.h:202
void setComputed(bool Computed)
Definition: CSEInfo.h:215
void setMF(MachineFunction &MFunc)
Definition: CSEInfo.h:214
GISelCSEInfo & get(std::unique_ptr< CSEConfigBase > CSEOpt, bool ReCompute=false)
Takes a CSEConfigBase object that defines what opcodes get CSEd.
Definition: CSEInfo.cpp:428
The CSE Analysis object.
Definition: CSEInfo.h:69
bool shouldCSE(unsigned Opc) const
Definition: CSEInfo.cpp:226
void changingInstr(MachineInstr &MI) override
This instruction is about to be mutated in some way.
Definition: CSEInfo.cpp:233
void analyze(MachineFunction &MF)
Definition: CSEInfo.cpp:240
void changedInstr(MachineInstr &MI) override
This instruction was mutated in some way.
Definition: CSEInfo.cpp:238
void recordNewInstruction(MachineInstr *MI)
Records a newly created inst in a list and lazily insert it to the CSEMap.
Definition: CSEInfo.cpp:182
void setMF(MachineFunction &MF)
-----— GISelCSEInfo ----------—//
Definition: CSEInfo.cpp:91
virtual ~GISelCSEInfo()
void erasingInstr(MachineInstr &MI) override
An instruction is about to be erased.
Definition: CSEInfo.cpp:231
void countOpcodeHit(unsigned Opc)
Definition: CSEInfo.cpp:172
void setCSEConfig(std::unique_ptr< CSEConfigBase > Opt)
Definition: CSEInfo.h:144
void handleRecordedInsts()
Use this callback to insert all the recorded instructions.
Definition: CSEInfo.cpp:219
void handleRecordedInst(MachineInstr *MI)
Use this callback to inform CSE about a newly fully created instruction.
Definition: CSEInfo.cpp:189
void handleRemoveInst(MachineInstr *MI)
Remove this inst from the CSE map.
Definition: CSEInfo.cpp:211
GISelCSEInfo()=default
void releaseMemory()
Definition: CSEInfo.cpp:254
void createdInstr(MachineInstr &MI) override
An instruction has been created and inserted into the function.
Definition: CSEInfo.cpp:232
Abstract class that contains various methods for clients to notify about changes.
const GISelInstProfileBuilder & addNodeIDOpcode(unsigned Opc) const
Definition: CSEInfo.cpp:333
const GISelInstProfileBuilder & addNodeIDRegNum(Register Reg) const
Definition: CSEInfo.cpp:364
const GISelInstProfileBuilder & addNodeIDFlag(unsigned Flag) const
Definition: CSEInfo.cpp:382
const GISelInstProfileBuilder & addNodeIDImmediate(int64_t Imm) const
Definition: CSEInfo.cpp:358
const GISelInstProfileBuilder & addNodeIDReg(Register Reg) const
Definition: CSEInfo.cpp:389
const GISelInstProfileBuilder & addNodeID(const MachineInstr *MI) const
Definition: CSEInfo.cpp:323
const GISelInstProfileBuilder & addNodeIDMBB(const MachineBasicBlock *MBB) const
Definition: CSEInfo.cpp:376
GISelInstProfileBuilder(FoldingSetNodeID &ID, const MachineRegisterInfo &MRI)
Definition: CSEInfo.h:172
const GISelInstProfileBuilder & addNodeIDRegType(const LLT Ty) const
Definition: CSEInfo.cpp:339
const GISelInstProfileBuilder & addNodeIDMachineOperand(const MachineOperand &MO) const
Definition: CSEInfo.cpp:403
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
Representation of each machine instruction.
Definition: MachineInstr.h:68
MachineOperand class - Representation of each machine instruction operand.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
This class implements the register bank concept.
Definition: RegisterBank.h:28
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
A class that wraps MachineInstrs and derives from FoldingSetNode in order to be uniqued in a CSEMap.
Definition: CSEInfo.h:29
Level
Code generation optimization level.
Definition: CodeGen.h:57
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
std::unique_ptr< CSEConfigBase > getStandardCSEConfigForOpt(CodeGenOpt::Level Level)
Definition: CSEInfo.cpp:79