PassInstrumentation.h Source File (original) (raw)

49#ifndef LLVM_IR_PASSINSTRUMENTATION_H

50#define LLVM_IR_PASSINSTRUMENTATION_H

58#include

60namespace llvm {

68extern template struct LLVM_TEMPLATE_ABI Any::TypeId<const Module *>;

69extern template struct LLVM_TEMPLATE_ABI Any::TypeId<const Function *>;

70extern template struct LLVM_TEMPLATE_ABI Any::TypeId<const Loop *>;

75public:

96public:

102

103 template

105 ShouldRunOptionalPassCallbacks.emplace_back(std::move(C));

106 }

107

108 template

110 BeforeSkippedPassCallbacks.emplace_back(std::move(C));

111 }

112

113 template

115 BeforeNonSkippedPassCallbacks.emplace_back(std::move(C));

116 }

117

118 template

120 if (ToFront)

121 AfterPassCallbacks.insert(AfterPassCallbacks.begin(), std::move(C));

122 else

123 AfterPassCallbacks.emplace_back(std::move(C));

124 }

125

126 template

128 if (ToFront)

129 AfterPassInvalidatedCallbacks.insert(

130 AfterPassInvalidatedCallbacks.begin(), std::move(C));

131 else

132 AfterPassInvalidatedCallbacks.emplace_back(std::move(C));

133 }

134

135 template

137 BeforeAnalysisCallbacks.emplace_back(std::move(C));

138 }

139

140 template

142 if (ToFront)

143 AfterAnalysisCallbacks.insert(AfterAnalysisCallbacks.begin(),

144 std::move(C));

145 else

146 AfterAnalysisCallbacks.emplace_back(std::move(C));

147 }

148

149 template

151 AnalysisInvalidatedCallbacks.emplace_back(std::move(C));

152 }

153

154 template

156 AnalysesClearedCallbacks.emplace_back(std::move(C));

157 }

158

159 template

161 ClassToPassNameCallbacks.emplace_back(std::move(C));

162 }

163

164

166

168

169private:

171

172

173

175 ShouldRunOptionalPassCallbacks;

176

178 BeforeSkippedPassCallbacks;

179

181 BeforeNonSkippedPassCallbacks;

182

184

186 AfterPassInvalidatedCallbacks;

187

189 BeforeAnalysisCallbacks;

190

192 AfterAnalysisCallbacks;

193

195 AnalysisInvalidatedCallbacks;

196

198 AnalysesClearedCallbacks;

199

202};

203

204

205

208

209

210

211

212

213

214

215 template

216 using has_required_t = decltype(std::declval<PassT &>().isRequired());

217

218 template static bool isRequired(const PassT &Pass) {

220 return Pass.isRequired();

221 return false;

222 }

223

224public:

225

226

227

228

231

232

233

234

235

236

237 template <typename IRUnitT, typename PassT>

239 if (!Callbacks)

240 return true;

241

242 bool ShouldRun = true;

243 if (!isRequired(Pass)) {

244 for (auto &C : Callbacks->ShouldRunOptionalPassCallbacks)

246 }

247

248 if (ShouldRun) {

249 for (auto &C : Callbacks->BeforeNonSkippedPassCallbacks)

251 } else {

252 for (auto &C : Callbacks->BeforeSkippedPassCallbacks)

254 }

255

256 return ShouldRun;

257 }

258

259

260

261

262 template <typename IRUnitT, typename PassT>

265 if (Callbacks)

266 for (auto &C : Callbacks->AfterPassCallbacks)

268 }

269

270

271

272

273 template <typename IRUnitT, typename PassT>

276 if (Callbacks)

277 for (auto &C : Callbacks->AfterPassInvalidatedCallbacks)

278 C(Pass.name(), PA);

279 }

280

281

282

283 template <typename IRUnitT, typename PassT>

285 if (Callbacks)

286 for (auto &C : Callbacks->BeforeAnalysisCallbacks)

288 }

289

290

291

292 template <typename IRUnitT, typename PassT>

294 if (Callbacks)

295 for (auto &C : Callbacks->AfterAnalysisCallbacks)

297 }

298

299

300

301

302 template <typename IRUnitT, typename PassT>

304 if (Callbacks)

305 for (auto &C : Callbacks->AnalysisInvalidatedCallbacks)

307 }

308

309

310

312 if (Callbacks)

313 for (auto &C : Callbacks->AnalysesClearedCallbacks)

314 C(Name);

315 }

316

317

318

319

320

321

322 template <typename IRUnitT, typename... ExtraArgsT>

324 ExtraArgsT...) {

325 return false;

326 }

327

328 template

330 if (Callbacks)

331 Callbacks->BeforeNonSkippedPassCallbacks.emplace_back(std::move(C));

332 }

334 if (Callbacks)

335 Callbacks->BeforeNonSkippedPassCallbacks.pop_back();

336 }

337

338

340 if (Callbacks)

341 return Callbacks->getPassNameForClassName(ClassName);

342 return {};

343 }

344};

345

347 const std::vector &Specials);

348

349

350

355

357

358public:

359

360

362 : Callbacks(Callbacks) {}

363

365

366 template <typename IRUnitT, typename AnalysisManagerT, typename... ExtraArgTs>

367 Result run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...) {

369 }

370};

371

372

373}

374

375#endif

This file provides Any, a non-template class modeled in the spirit of std::any.

block Block Frequency Analysis

#define LLVM_TEMPLATE_ABI

This file defines the DenseMap class.

This header defines various interfaces for pass management in LLVM.

Legalize the Machine IR a function s Machine IR

This file defines the SmallVector class.

static const char PassName[]

Represents a single loop in the control flow graph.

A Module instance is used to store all the information related to an LLVM module.

Result run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...)

Definition PassInstrumentation.h:367

PassInstrumentation Result

Definition PassInstrumentation.h:364

PassInstrumentationAnalysis(PassInstrumentationCallbacks *Callbacks=nullptr)

PassInstrumentationCallbacks object is shared, owned by something else, not this analysis.

Definition PassInstrumentation.h:361

This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...

Definition PassInstrumentation.h:74

void registerAnalysesClearedCallback(CallableT C)

Definition PassInstrumentation.h:155

void registerBeforeAnalysisCallback(CallableT C)

Definition PassInstrumentation.h:136

void registerAfterPassInvalidatedCallback(CallableT C, bool ToFront=false)

Definition PassInstrumentation.h:127

void registerAnalysisInvalidatedCallback(CallableT C)

Definition PassInstrumentation.h:150

void registerAfterAnalysisCallback(CallableT C, bool ToFront=false)

Definition PassInstrumentation.h:141

friend class PassInstrumentation

Definition PassInstrumentation.h:170

void(StringRef, const PreservedAnalyses &) AfterPassInvalidatedFunc

Definition PassInstrumentation.h:90

void(StringRef, Any) BeforeNonSkippedPassFunc

Definition PassInstrumentation.h:88

void registerBeforeNonSkippedPassCallback(CallableT C)

Definition PassInstrumentation.h:114

void registerClassToPassNameCallback(CallableT C)

Definition PassInstrumentation.h:160

void registerBeforeSkippedPassCallback(CallableT C)

Definition PassInstrumentation.h:109

PassInstrumentationCallbacks(const PassInstrumentationCallbacks &)=delete

Copying PassInstrumentationCallbacks is not intended.

PassInstrumentationCallbacks()=default

bool(StringRef, Any) BeforePassFunc

Definition PassInstrumentation.h:86

void(StringRef) AnalysesClearedFunc

Definition PassInstrumentation.h:94

void registerShouldRunOptionalPassCallback(CallableT C)

Definition PassInstrumentation.h:104

void(StringRef, Any) BeforeSkippedPassFunc

Definition PassInstrumentation.h:87

void operator=(const PassInstrumentationCallbacks &)=delete

void(StringRef, Any) AfterAnalysisFunc

Definition PassInstrumentation.h:92

void(StringRef, Any) BeforeAnalysisFunc

Definition PassInstrumentation.h:91

void(StringRef, Any) AnalysisInvalidatedFunc

Definition PassInstrumentation.h:93

void(StringRef, Any, const PreservedAnalyses &) AfterPassFunc

Definition PassInstrumentation.h:89

void registerAfterPassCallback(CallableT C, bool ToFront=false)

Definition PassInstrumentation.h:119

This class provides instrumentation entry points for the Pass Manager, doing calls to callbacks regis...

Definition PassInstrumentation.h:206

void runAfterPassInvalidated(const PassT &Pass, const PreservedAnalyses &PA) const

AfterPassInvalidated instrumentation point - takes Pass instance that has just been executed.

Definition PassInstrumentation.h:274

void pushBeforeNonSkippedPassCallback(CallableT C)

Definition PassInstrumentation.h:329

PassInstrumentation(PassInstrumentationCallbacks *CB=nullptr)

Callbacks object is not owned by PassInstrumentation, its life-time should at least match the life-ti...

Definition PassInstrumentation.h:229

bool invalidate(IRUnitT &, const class llvm::PreservedAnalyses &, ExtraArgsT...)

Handle invalidation from the pass manager when PassInstrumentation is used as the result of PassInstr...

Definition PassInstrumentation.h:323

void runBeforeAnalysis(const PassT &Analysis, const IRUnitT &IR) const

BeforeAnalysis instrumentation point - takes Analysis instance to be executed and constant reference ...

Definition PassInstrumentation.h:284

void runAnalysisInvalidated(const PassT &Analysis, const IRUnitT &IR) const

AnalysisInvalidated instrumentation point - takes Analysis instance that has just been invalidated an...

Definition PassInstrumentation.h:303

void runAnalysesCleared(StringRef Name) const

AnalysesCleared instrumentation point - takes name of IR that analyses operated on.

Definition PassInstrumentation.h:311

StringRef getPassNameForClassName(StringRef ClassName) const

Get the pass name for a given pass class name.

Definition PassInstrumentation.h:339

void popBeforeNonSkippedPassCallback()

Definition PassInstrumentation.h:333

void runAfterPass(const PassT &Pass, const IRUnitT &IR, const PreservedAnalyses &PA) const

AfterPass instrumentation point - takes Pass instance that has just been executed and constant refere...

Definition PassInstrumentation.h:263

void runAfterAnalysis(const PassT &Analysis, const IRUnitT &IR) const

AfterAnalysis instrumentation point - takes Analysis instance that has just been executed and constan...

Definition PassInstrumentation.h:293

bool runBeforePass(const PassT &Pass, const IRUnitT &IR) const

BeforePass instrumentation point - takes Pass instance to be executed and constant reference to IR it...

Definition PassInstrumentation.h:238

Pass interface - Implemented by all 'passes'.

A set of analyses that are preserved following a run of a transformation pass.

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

StringRef - Represent a constant reference to a string, i.e.

unique_function is a type-erasing functor similar to std::function.

@ C

The default llvm calling convention, compatible with C.

This is an optimization pass for GlobalISel generic memory operations.

LLVM_ABI bool isSpecialPass(StringRef PassID, const std::vector< StringRef > &Specials)

typename detail::detector< void, Op, Args... >::value_t is_detected

Detects if a given trait holds for some set of arguments 'Args'.

A CRTP mix-in that provides informational APIs needed for analysis passes.

A special type used by analysis passes to provide an address that identifies that particular analysis...