Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/CodeGen/GlobalISel/CSEInfo.h
Line
Count
Source (jump to first uncovered line)
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
//
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"
16
#include "llvm/CodeGen/CSEConfigBase.h"
17
#include "llvm/CodeGen/GlobalISel/GISelChangeObserver.h"
18
#include "llvm/CodeGen/GlobalISel/GISelWorkList.h"
19
#include "llvm/CodeGen/GlobalISel/Utils.h"
20
#include "llvm/CodeGen/MachineBasicBlock.h"
21
#include "llvm/CodeGen/MachineFunctionPass.h"
22
#include "llvm/IR/PassManager.h"
23
#include "llvm/Pass.h"
24
#include "llvm/Support/Allocator.h"
25
26
namespace llvm {
27
28
/// A class that wraps MachineInstrs and derives from FoldingSetNode in order to
29
/// be uniqued in a CSEMap. The tradeoff here is extra memory allocations for
30
/// UniqueMachineInstr vs making MachineInstr bigger.
31
class UniqueMachineInstr : public FoldingSetNode {
32
  friend class GISelCSEInfo;
33
  const MachineInstr *MI;
34
10.2M
  explicit UniqueMachineInstr(const MachineInstr *MI) : MI(MI) {}
35
36
public:
37
  void Profile(FoldingSetNodeID &ID);
38
};
39
40
// A CSE config for fully optimized builds.
41
class CSEConfigFull : public CSEConfigBase {
42
public:
43
474k
  virtual ~CSEConfigFull() = default;
44
  virtual bool shouldCSEOpc(unsigned Opc) override;
45
};
46
47
// Commonly used for O0 config.
48
class CSEConfigConstantOnly : public CSEConfigBase {
49
public:
50
3.38k
  virtual ~CSEConfigConstantOnly() = default;
51
  virtual bool shouldCSEOpc(unsigned Opc) override;
52
};
53
54
// Returns the standard expected CSEConfig for the given optimization level.
55
// We have this logic here so targets can make use of it from their derived
56
// TargetPassConfig, but can't put this logic into TargetPassConfig directly
57
// because the CodeGen library can't depend on GlobalISel.
58
std::unique_ptr<CSEConfigBase>
59
getStandardCSEConfigForOpt(CodeGenOpt::Level Level);
60
61
/// The CSE Analysis object.
62
/// This installs itself as a delegate to the MachineFunction to track
63
/// new instructions as well as deletions. It however will not be able to
64
/// track instruction mutations. In such cases, recordNewInstruction should be
65
/// called (for eg inside MachineIRBuilder::recordInsertion).
66
/// Also because of how just the instruction can be inserted without adding any
67
/// operands to the instruction, instructions are uniqued and inserted lazily.
68
/// CSEInfo should assert when trying to enter an incomplete instruction into
69
/// the CSEMap. There is Opcode level granularity on which instructions can be
70
/// CSE'd and for now, only Generic instructions are CSEable.
71
class GISelCSEInfo : public GISelChangeObserver {
72
  // Make it accessible only to CSEMIRBuilder.
73
  friend class CSEMIRBuilder;
74
75
  BumpPtrAllocator UniqueInstrAllocator;
76
  FoldingSet<UniqueMachineInstr> CSEMap;
77
  MachineRegisterInfo *MRI = nullptr;
78
  MachineFunction *MF = nullptr;
79
  std::unique_ptr<CSEConfigBase> CSEOpt;
80
  /// Keep a cache of UniqueInstrs for each MachineInstr. In GISel,
81
  /// often instructions are mutated (while their ID has completely changed).
82
  /// Whenever mutation happens, invalidate the UniqueMachineInstr for the
83
  /// MachineInstr
84
  DenseMap<const MachineInstr *, UniqueMachineInstr *> InstrMapping;
85
86
  /// Store instructions that are not fully formed in TemporaryInsts.
87
  /// Also because CSE insertion happens lazily, we can remove insts from this
88
  /// list and avoid inserting and then removing from the CSEMap.
89
  GISelWorkList<8> TemporaryInsts;
90
91
  // Only used in asserts.
92
  DenseMap<unsigned, unsigned> OpcodeHitTable;
93
94
  bool isUniqueMachineInstValid(const UniqueMachineInstr &UMI) const;
95
96
  void invalidateUniqueMachineInstr(UniqueMachineInstr *UMI);
97
98
  UniqueMachineInstr *getNodeIfExists(FoldingSetNodeID &ID,
99
                                      MachineBasicBlock *MBB, void *&InsertPos);
100
101
  /// Allocate and construct a new UniqueMachineInstr for MI and return.
102
  UniqueMachineInstr *getUniqueInstrForMI(const MachineInstr *MI);
103
104
  void insertNode(UniqueMachineInstr *UMI, void *InsertPos = nullptr);
105
106
  /// Get the MachineInstr(Unique) if it exists already in the CSEMap and the
107
  /// same MachineBasicBlock.
108
  MachineInstr *getMachineInstrIfExists(FoldingSetNodeID &ID,
109
                                        MachineBasicBlock *MBB,
110
                                        void *&InsertPos);
111
112
  /// Use this method to allocate a new UniqueMachineInstr for MI and insert it
113
  /// into the CSEMap. MI should return true for shouldCSE(MI->getOpcode())
114
  void insertInstr(MachineInstr *MI, void *InsertPos = nullptr);
115
116
public:
117
14.3k
  GISelCSEInfo() = default;
118
119
  virtual ~GISelCSEInfo();
120
121
  void setMF(MachineFunction &MF);
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.
128
  void recordNewInstruction(MachineInstr *MI);
129
130
  /// Use this callback to inform CSE about a newly fully created instruction.
131
  void handleRecordedInst(MachineInstr *MI);
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.
140
  void handleRemoveInst(MachineInstr *MI);
141
142
  void releaseMemory();
143
144
477k
  void setCSEConfig(std::unique_ptr<CSEConfigBase> Opt) {
145
477k
    CSEOpt = std::move(Opt);
146
477k
  }
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
163
class TargetRegisterClass;
164
class RegisterBank;
165
166
// Simple builder class to easily profile properties about MIs.
167
class GISelInstProfileBuilder {
168
  FoldingSetNodeID &ID;
169
  const MachineRegisterInfo &MRI;
170
171
public:
172
  GISelInstProfileBuilder(FoldingSetNodeID &ID, const MachineRegisterInfo &MRI)
173
18.6M
      : ID(ID), MRI(MRI) {}
174
  // Profiling methods.
175
  const GISelInstProfileBuilder &addNodeIDOpcode(unsigned Opc) const;
176
  const GISelInstProfileBuilder &addNodeIDRegType(const LLT &Ty) const;
177
  const GISelInstProfileBuilder &addNodeIDRegType(const unsigned) const;
178
179
  const GISelInstProfileBuilder &
180
  addNodeIDRegType(const TargetRegisterClass *RC) const;
181
  const GISelInstProfileBuilder &addNodeIDRegType(const RegisterBank *RB) const;
182
183
  const GISelInstProfileBuilder &addNodeIDRegNum(unsigned Reg) const;
184
185
  const GISelInstProfileBuilder &addNodeIDImmediate(int64_t Imm) const;
186
  const GISelInstProfileBuilder &
187
  addNodeIDMBB(const MachineBasicBlock *MBB) const;
188
189
  const GISelInstProfileBuilder &
190
  addNodeIDMachineOperand(const MachineOperand &MO) const;
191
192
  const GISelInstProfileBuilder &addNodeIDFlag(unsigned Flag) const;
193
  const GISelInstProfileBuilder &addNodeID(const MachineInstr *MI) const;
194
};
195
196
/// Simple wrapper that does the following.
197
/// 1) Lazily evaluate the MachineFunction to compute CSEable instructions.
198
/// 2) Allows configuration of which instructions are CSEd through CSEConfig
199
/// object. Provides a method called get which takes a CSEConfig object.
200
class GISelCSEAnalysisWrapper {
201
  GISelCSEInfo Info;
202
  MachineFunction *MF = nullptr;
203
  bool AlreadyComputed = false;
204
205
public:
206
  /// Takes a CSEConfigBase object that defines what opcodes get CSEd.
207
  /// If CSEConfig is already set, and the CSE Analysis has been preserved,
208
  /// it will not use the new CSEOpt(use Recompute to force using the new
209
  /// CSEOpt).
210
  GISelCSEInfo &get(std::unique_ptr<CSEConfigBase> CSEOpt,
211
                    bool ReCompute = false);
212
477k
  void setMF(MachineFunction &MFunc) { MF = &MFunc; }
213
955k
  void setComputed(bool Computed) { AlreadyComputed = Computed; }
214
955k
  void releaseMemory() { Info.releaseMemory(); }
215
};
216
217
/// The actual analysis pass wrapper.
218
class GISelCSEAnalysisWrapperPass : public MachineFunctionPass {
219
  GISelCSEAnalysisWrapper Wrapper;
220
221
public:
222
  static char ID;
223
14.3k
  GISelCSEAnalysisWrapperPass() : MachineFunctionPass(ID) {
224
14.3k
    initializeGISelCSEAnalysisWrapperPassPass(*PassRegistry::getPassRegistry());
225
14.3k
  }
226
227
  void getAnalysisUsage(AnalysisUsage &AU) const override;
228
229
0
  const GISelCSEAnalysisWrapper &getCSEWrapper() const { return Wrapper; }
230
477k
  GISelCSEAnalysisWrapper &getCSEWrapper() { return Wrapper; }
231
232
  bool runOnMachineFunction(MachineFunction &MF) override;
233
234
955k
  void releaseMemory() override {
235
955k
    Wrapper.releaseMemory();
236
955k
    Wrapper.setComputed(false);
237
955k
  }
238
};
239
240
} // namespace llvm
241
242
#endif