PassManager.h Source File (original) (raw)

37#ifndef LLVM_IR_PASSMANAGER_H

38#define LLVM_IR_PASSMANAGER_H

48#include

49#include

50#include

51#include

52#include

53#include <type_traits>

54#include

55#include

57namespace llvm {

63template <typename IRUnitT, typename... ExtraArgTs> class AnalysisManager;

72 static_assert(std::is_base_of<PassInfoMixin, DerivedT>::value,

73 "Must pass the derived type as the template argument!");

75 Name.consume_front("llvm::");

76 return Name;

77 }

81 StringRef ClassName = DerivedT::name();

82 auto PassName = MapClassName2PassName(ClassName);

84 }

85};

91template

100

101

102

103

104

105

106

107

109 static_assert(std::is_base_of<AnalysisInfoMixin, DerivedT>::value,

110 "Must pass the derived type as the template argument!");

111 return &DerivedT::Key;

112 }

113};

114

116

117

118

119template <typename PassT, typename IRUnitT, typename AnalysisManagerT,

120 typename... ArgTs, size_t... Ns>

121typename PassT::Result

123 std::tuple<ArgTs...> Args,

124 std::index_sequence<Ns...>) {

125 (void)Args;

126 return AM.template getResult(IR, std::get(Args)...);

127}

128

129

130

131

132

133

134template <typename PassT, typename IRUnitT, typename... AnalysisArgTs,

135 typename... MainArgTs>

136typename PassT::Result

138 std::tuple<MainArgTs...> Args) {

140 PassT, IRUnitT>)(AM, IR, Args,

141 std::index_sequence_for<AnalysisArgTs...>{});

142}

143

144}

145

146

147

148

149

150

151

152

153

154

155

156

157

158template <typename IRUnitT,

159 typename AnalysisManagerT = AnalysisManager,

160 typename... ExtraArgTs>

162 PassManager<IRUnitT, AnalysisManagerT, ExtraArgTs...>> {

163public:

164

166

167

168

169

170

172

177

180 for (unsigned Idx = 0, Size = Passes.size(); Idx != Size; ++Idx) {

181 auto *P = Passes[Idx].get();

182 P->printPipeline(OS, MapClassName2PassName);

183 if (Idx + 1 < Size)

184 OS << ',';

185 }

186 }

187

188

189

191 ExtraArgTs... ExtraArgs);

192

193 template

196 using PassModelT =

197 detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;

198

199

200 Passes.push_back(std::unique_ptr(

201 new PassModelT(std::forward(Pass))));

202 }

203

204

205

206

207

208

209 template

212 for (auto &P : Pass.Passes)

213 Passes.push_back(std::move(P));

214 }

215

216

218

220

221protected:

224

225 std::vector<std::unique_ptr> Passes;

226};

227

228template

230

231template <>

234

236

237

239

240template <>

243

245

246

248

249

250

251

252

253

254template <typename IRUnitT, typename... ExtraArgTs> class AnalysisManager {

255public:

257

258private:

259

261 using PassConceptT =

263

264

265

266

267

268

269

270 using AnalysisResultListT =

271 std::list<std::pair<AnalysisKey *, std::unique_ptr>>;

272

273

275

276

277

278

279 using AnalysisResultMapT =

281 typename AnalysisResultListT::iterator>;

282

283public:

284

285

286

287

288

289

290

291

292

293 class Invalidator {

294 public:

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310 template

312 using ResultModelT =

314 Invalidator>;

315

316 return invalidateImpl(PassT::ID(), IR, PA);

317 }

318

319

320

321

322

323

324

326 return invalidateImpl<>(ID, IR, PA);

327 }

328

329 private:

331

332 template

335

336

337 auto IMapI = IsResultInvalidated.find(ID);

338 if (IMapI != IsResultInvalidated.end())

339 return IMapI->second;

340

341

342 auto RI = Results.find({ID, &IR});

344 "Trying to invalidate a dependent result that isn't in the "

345 "manager's cache is always an error, likely due to a stale result "

346 "handle!");

347

348 auto &Result = static_cast<ResultT &>(*RI->second->second);

349

350

351

352

353

354 bool Inserted;

355 std::tie(IMapI, Inserted) =

356 IsResultInvalidated.insert({ID, Result.invalidate(IR, PA, *this)});

357 (void)Inserted;

358 assert(Inserted && "Should not have already inserted this ID, likely "

359 "indicates a dependency cycle!");

360 return IMapI->second;

361 }

362

363 Invalidator(SmallDenseMap<AnalysisKey *, bool, 8> &IsResultInvalidated,

364 const AnalysisResultMapT &Results)

365 : IsResultInvalidated(IsResultInvalidated), Results(Results) {}

366

367 SmallDenseMap<AnalysisKey *, bool, 8> &IsResultInvalidated;

368 const AnalysisResultMapT &Results;

369 };

370

371

375

376

378 assert(AnalysisResults.empty() == AnalysisResultLists.empty() &&

379 "The storage and index of analysis results disagree on how many "

380 "there are!");

381 return AnalysisResults.empty();

382 }

383

384

385

386

387

388

390

391

392

393

394

395

396

398 AnalysisResults.clear();

399 AnalysisResultLists.clear();

400 }

401

402

404 return AnalysisPasses.count(PassT::ID());

405 }

406

407

408

409

410 template

411 typename PassT::Result &getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs) {

412 assert(AnalysisPasses.count(PassT::ID()) &&

413 "This analysis pass was not registered prior to being queried");

414 ResultConceptT &ResultConcept =

415 getResultImpl(PassT::ID(), IR, ExtraArgs...);

416

417 using ResultModelT =

419 Invalidator>;

420

421 return static_cast<ResultModelT &>(ResultConcept).Result;

422 }

423

424

425

426

427

428

429 template

431 assert(AnalysisPasses.count(PassT::ID()) &&

432 "This analysis pass was not registered prior to being queried");

433

434 ResultConceptT *ResultConcept = getCachedResultImpl(PassT::ID(), IR);

435 if (!ResultConcept)

436 return nullptr;

437

438 using ResultModelT =

440 Invalidator>;

441

442 return &static_cast<ResultModelT *>(ResultConcept)->Result;

443 }

444

445

446 template

450 Invalidator Inv(IsResultInvalidated, AnalysisResults);

451 assert(!Result->invalidate(IR, PA, Inv) &&

452 "Cached result cannot be invalidated");

453 }

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471 template

474 using PassModelT =

476

477 auto &PassPtr = AnalysisPasses[PassT::ID()];

478 if (PassPtr)

479

480 return false;

481

482

483 PassPtr.reset(new PassModelT(PassBuilder()));

484 return true;

485 }

486

487

488

489

490

492

493

494

495

496

497

499 AnalysisResultListT &ResultsList = AnalysisResultLists[&IR];

501

502 auto I =

504 assert(I != ResultsList.end() && "Analysis must be available");

505 ResultsList.erase(I);

506 AnalysisResults.erase({ID, &IR});

507 }

508

509private:

510

512 typename AnalysisPassMapT::iterator PI = AnalysisPasses.find(ID);

513 assert(PI != AnalysisPasses.end() &&

514 "Analysis passes must be registered prior to being queried!");

515 return *PI->second;

516 }

517

518

519 const PassConceptT &lookUpPass(AnalysisKey *ID) const {

520 typename AnalysisPassMapT::const_iterator PI = AnalysisPasses.find(ID);

521 assert(PI != AnalysisPasses.end() &&

522 "Analysis passes must be registered prior to being queried!");

523 return *PI->second;

524 }

525

526

527 ResultConceptT &getResultImpl(AnalysisKey *ID, IRUnitT &IR,

528 ExtraArgTs... ExtraArgs);

529

530

531 ResultConceptT *getCachedResultImpl(AnalysisKey *ID, IRUnitT &IR) const {

532 typename AnalysisResultMapT::const_iterator RI =

533 AnalysisResults.find({ID, &IR});

534 return RI == AnalysisResults.end() ? nullptr : &*RI->second->second;

535 }

536

537

538 using AnalysisPassMapT =

539 DenseMap<AnalysisKey *, std::unique_ptr>;

540

541

542 AnalysisPassMapT AnalysisPasses;

543

544

545

546

547

548 AnalysisResultListMapT AnalysisResultLists;

549

550

551

552 AnalysisResultMapT AnalysisResults;

553};

554

556

557

559

561

562

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

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

584 InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT>> {

585public:

587 public:

588 explicit Result(AnalysisManagerT &InnerAM) : InnerAM(&InnerAM) {}

589

591

592

593

594 Arg.InnerAM = nullptr;

595 }

596

598

599 if (!InnerAM)

600 return;

601

602

603

604 InnerAM->clear();

605 }

606

608 InnerAM = RHS.InnerAM;

609

610

611

612 RHS.InnerAM = nullptr;

613 return *this;

614 }

615

616

617 AnalysisManagerT &getManager() { return *InnerAM; }

618

619

620

621

622

623

624

625

626

627

628

632

633 private:

634 AnalysisManagerT *InnerAM;

635 };

636

638 : InnerAM(&InnerAM) {}

639

640

641

642

643

644

646 ExtraArgTs...) {

647 return Result(*InnerAM);

648 }

649

650private:

653

655

656 AnalysisManagerT *InnerAM;

657};

658

659

660

661

662

663

664

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

668

669

672

673

674

675template <>

676LLVM_ABI bool FunctionAnalysisManagerModuleProxy::Result::invalidate(

678 ModuleAnalysisManager::Invalidator &Inv);

679

680

681

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

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

715 OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>> {

716public:

717

719 public:

720 explicit Result(const AnalysisManagerT &OuterAM) : OuterAM(&OuterAM) {}

721

722

723

724 template <typename PassT, typename IRUnitTParam>

726 typename PassT::Result *Res =

728 if (Res)

729 OuterAM->template verifyNotInvalidated(IR, Res);

730 return Res;

731 }

732

733

734 template <typename PassT, typename IRUnitTParam>

736 typename PassT::Result *Res =

738 return Res != nullptr;

739 }

740

741

745

746

748 for (auto &KeyValuePair : OuterAnalysisInvalidationMap) {

749 AnalysisKey *OuterID = KeyValuePair.first;

750 auto &InnerIDs = KeyValuePair.second;

752 return Inv.invalidate(InnerID, IRUnit, PA);

753 });

754 if (InnerIDs.empty())

756 }

757

758 for (auto *OuterID : DeadKeys)

759 OuterAnalysisInvalidationMap.erase(OuterID);

760

761

762 return false;

763 }

764

765

766

767 template <typename OuterAnalysisT, typename InvalidatedAnalysisT>

769 AnalysisKey *OuterID = OuterAnalysisT::ID();

770 AnalysisKey *InvalidatedID = InvalidatedAnalysisT::ID();

771

772 auto &InvalidatedIDList = OuterAnalysisInvalidationMap[OuterID];

773

774

775

776

778 InvalidatedIDList.push_back(InvalidatedID);

779 }

780

781

782

785 return OuterAnalysisInvalidationMap;

786 }

787

788 private:

789 const AnalysisManagerT *OuterAM;

790

791

792

794 OuterAnalysisInvalidationMap;

795 };

796

798 : OuterAM(&OuterAM) {}

799

800

801

802

804 ExtraArgTs...) {

805 return Result(*OuterAM);

806 }

807

808private:

811

813

814 const AnalysisManagerT *OuterAM;

815};

816

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

818AnalysisKey

820

823

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

852public:

854

856 bool EagerlyInvalidate)

857 : Pass(std::move(Pass)), EagerlyInvalidate(EagerlyInvalidate) {}

858

859

864

866

867private:

868 std::unique_ptr Pass;

869 bool EagerlyInvalidate;

870};

871

872

873

874template

875ModuleToFunctionPassAdaptor

877 bool EagerlyInvalidate = false) {

878 using PassModelT =

880

881

883 std::unique_ptrModuleToFunctionPassAdaptor::PassConceptT(

884 new PassModelT(std::forward(Pass))),

885 EagerlyInvalidate);

886}

887

888

889

890

891

892

893

894

895

896

897template <typename AnalysisT, typename IRUnitT,

898 typename AnalysisManagerT = AnalysisManager,

899 typename... ExtraArgTs>

901 : PassInfoMixin<RequireAnalysisPass<AnalysisT, IRUnitT, AnalysisManagerT,

902 ExtraArgTs...>> {

903

904

905

906

907

908

910 ExtraArgTs &&... Args) {

911 (void)AM.template getResult(Arg,

912 std::forward(Args)...);

913

915 }

918 auto ClassName = AnalysisT::name();

919 auto PassName = MapClassName2PassName(ClassName);

920 OS << "require<" << PassName << '>';

921 }

923};

924

925

926

927template

929 : PassInfoMixin<InvalidateAnalysisPass> {

930

931

932

933

934

935

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

944 auto ClassName = AnalysisT::name();

945 auto PassName = MapClassName2PassName(ClassName);

946 OS << "invalidate<" << PassName << '>';

947 }

948};

949

950

951

952

953

955

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

960};

961

962}

963

964#endif

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

Function Alias Analysis Results

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

#define LLVM_TEMPLATE_ABI

#define LLVM_ATTRIBUTE_MINSIZE

#define LLVM_ATTRIBUTE_VISIBILITY_DEFAULT

This file defines the DenseMap class.

Legalize the Machine IR a function s Machine IR

This header provides internal APIs and implementation details used by the pass management interfaces ...

static const char PassName[]

API to communicate dependencies between analyses during invalidation.

Definition PassManager.h:293

bool invalidate(AnalysisKey *ID, IRUnitT &IR, const PreservedAnalyses &PA)

A type-erased variant of the above invalidate method with the same core API other than passing an ana...

Definition PassManager.h:325

bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA)

Trigger the invalidation of some other analysis pass if not already handled and return whether it was...

Definition PassManager.h:311

friend class AnalysisManager

Definition PassManager.h:330

A container for analyses that lazily runs them and caches their results.

Definition PassManager.h:254

bool isPassRegistered() const

Returns true if the specified analysis pass is registered.

Definition PassManager.h:403

AnalysisManager()

Construct an empty analysis manager.

void clear()

Clear all analysis results cached by this AnalysisManager.

Definition PassManager.h:397

AnalysisManager(AnalysisManager &&)

void verifyNotInvalidated(IRUnitT &IR, typename PassT::Result *Result) const

Verify that the given Result cannot be invalidated, assert otherwise.

Definition PassManager.h:447

AnalysisManager & operator=(AnalysisManager &&)

void clear(IRUnitT &IR, llvm::StringRef Name)

Clear any cached analysis results for a single unit of IR.

void invalidate(IRUnitT &IR, const PreservedAnalyses &PA)

Invalidate cached analyses for an IR unit.

void clearAnalysis(IRUnitT &IR)

Directly clear a cached analysis for an IR unit.

Definition PassManager.h:498

PassT::Result * getCachedResult(IRUnitT &IR) const

Get the cached result of an analysis pass for a given IR unit.

Definition PassManager.h:430

bool registerPass(PassBuilderT &&PassBuilder)

Definition PassManager.h:472

bool empty() const

Returns true if the analysis manager has an empty results cache.

Definition PassManager.h:377

PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)

Get the result of an analysis pass for a given IR unit.

Definition PassManager.h:411

Result(Result &&Arg)

Definition PassManager.h:590

bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA, typename AnalysisManager< IRUnitT, ExtraArgTs... >::Invalidator &Inv)

Handler for invalidation of the outer IR unit, IRUnitT.

Result(AnalysisManagerT &InnerAM)

Definition PassManager.h:588

Result & operator=(Result &&RHS)

Definition PassManager.h:607

~Result()

Definition PassManager.h:597

AnalysisManagerT & getManager()

Accessor for the analysis manager.

Definition PassManager.h:617

An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...

Definition PassManager.h:584

Result run(IRUnitT &IR, AnalysisManager< IRUnitT, ExtraArgTs... > &AM, ExtraArgTs...)

Run the analysis pass and create our proxy result object.

Definition PassManager.h:645

InnerAnalysisManagerProxy(AnalysisManagerT &InnerAM)

Definition PassManager.h:637

Trivial adaptor that maps from a module to its functions.

Definition PassManager.h:851

detail::PassConcept< Function, FunctionAnalysisManager > PassConceptT

Definition PassManager.h:853

ModuleToFunctionPassAdaptor(std::unique_ptr< PassConceptT > Pass, bool EagerlyInvalidate)

Definition PassManager.h:855

static bool isRequired()

Definition PassManager.h:865

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

Result(const AnalysisManagerT &OuterAM)

Definition PassManager.h:720

PassT::Result * getCachedResult(IRUnitTParam &IR) const

Get a cached analysis.

Definition PassManager.h:725

bool invalidate(IRUnitT &IRUnit, const PreservedAnalyses &PA, typename AnalysisManager< IRUnitT, ExtraArgTs... >::Invalidator &Inv)

When invalidation occurs, remove any registered invalidation events.

Definition PassManager.h:742

bool cachedResultExists(IRUnitTParam &IR) const

Method provided for unit testing, not intended for general use.

Definition PassManager.h:735

const SmallDenseMap< AnalysisKey *, TinyPtrVector< AnalysisKey * >, 2 > & getOuterInvalidations() const

Access the map from outer analyses to deferred invalidation requiring analyses.

Definition PassManager.h:784

void registerOuterAnalysisInvalidation()

Definition PassManager.h:768

An analysis over an "inner" IR unit that provides access to an analysis manager over a "outer" IR uni...

Definition PassManager.h:715

Result run(IRUnitT &, AnalysisManager< IRUnitT, ExtraArgTs... > &, ExtraArgTs...)

Run the analysis pass and create our proxy result object.

Definition PassManager.h:803

OuterAnalysisManagerProxy(const AnalysisManagerT &OuterAM)

Definition PassManager.h:797

This class provides access to building LLVM's passes.

Manages a sequence of passes over a particular unit of IR.

Definition PassManager.h:162

PassManager(PassManager &&Arg)

Definition PassManager.h:171

PassManager & operator=(PassManager &&RHS)

Definition PassManager.h:173

LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v< PassT, PassManager > > addPass(PassT &&Pass)

Definition PassManager.h:195

void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)

Definition PassManager.h:178

std::vector< std::unique_ptr< PassConceptT > > Passes

Definition PassManager.h:225

PassManager()=default

Construct a pass manager.

detail::PassConcept< LazyCallGraph::SCC, CGSCCAnalysisManager, ExtraArgTs... > PassConceptT

Definition PassManager.h:222

LLVM_ATTRIBUTE_MINSIZE std::enable_if_t< std::is_same_v< PassT, PassManager > > addPass(PassT &&Pass)

When adding a pass manager pass that has the same type as this pass manager, simply move the passes o...

Definition PassManager.h:211

static bool isRequired()

Definition PassManager.h:219

PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs)

Run all of the passes in this manager over the given unit of IR.

bool isEmpty() const

Returns if the pass manager contains any passes.

Definition PassManager.h:217

Pass interface - Implemented by all 'passes'.

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

static PreservedAnalyses none()

Convenience factory function for the empty preserved set.

static PreservedAnalyses all()

Construct a special preserved set that preserves all passes.

PreservedAnalyses & abandon()

Mark an analysis as abandoned.

iterator erase(const_iterator CI)

void push_back(const T &Elt)

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.

An efficient, type-erasing, non-owning reference to a callable.

This class implements an extremely fast bulk output stream that can only output to a stream.

Pass manager infrastructure for declaring and invalidating analyses.

unsigned ID

LLVM IR allows to use arbitrary numbers as calling convention identifiers.

PassT::Result getAnalysisResultUnpackTuple(AnalysisManagerT &AM, IRUnitT &IR, std::tuple< ArgTs... > Args, std::index_sequence< Ns... >)

Actual unpacker of extra arguments in getAnalysisResult, passes only those tuple arguments that are m...

Definition PassManager.h:122

PassT::Result getAnalysisResult(AnalysisManager< IRUnitT, AnalysisArgTs... > &AM, IRUnitT &IR, std::tuple< MainArgTs... > Args)

Helper for partial unpacking of extra arguments in getAnalysisResult.

Definition PassManager.h:137

This is an optimization pass for GlobalISel generic memory operations.

ModuleToFunctionPassAdaptor createModuleToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false)

A function to deduce a function pass type and wrap it in the templated adaptor.

Definition PassManager.h:876

OuterAnalysisManagerProxy< ModuleAnalysisManager, Function > ModuleAnalysisManagerFunctionProxy

Provide the ModuleAnalysisManager to Function proxy.

Definition PassManager.h:824

LLVM_GET_TYPE_NAME_CONSTEXPR StringRef getTypeName()

We provide a function which tries to compute the (demangled) name of a type statically.

LLVM_ABI void printIRUnitNameForStackTrace< Function >(raw_ostream &OS, const Function &IR)

void printIRUnitNameForStackTrace(raw_ostream &OS, const IRUnitT &IR)

InnerAnalysisManagerProxy< FunctionAnalysisManager, Module > FunctionAnalysisManagerModuleProxy

Provide the FunctionAnalysisManager to Module proxy.

Definition PassManager.h:670

LLVM_ABI void printIRUnitNameForStackTrace< Module >(raw_ostream &OS, const Module &IR)

PassManager< Module > ModulePassManager

Convenience typedef for a pass manager over modules.

Definition PassManager.h:238

LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key

Definition PassManager.h:667

PassManager< Function > FunctionPassManager

Convenience typedef for a pass manager over functions.

Definition PassManager.h:247

OutputIt move(R &&Range, OutputIt Out)

Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.

auto find_if(R &&Range, UnaryPredicate P)

Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.

void erase_if(Container &C, UnaryPredicate P)

Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...

bool is_contained(R &&Range, const E &Element)

Returns true if Element is found in Range.

AnalysisManager< Function > FunctionAnalysisManager

Convenience typedef for the Function analysis manager.

Definition PassManager.h:563

AnalysisManager< Module > ModuleAnalysisManager

Convenience typedef for the Module analysis manager.

Implement std::hash so that hash_code can be used in STL containers.

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

Definition PassManager.h:92

static AnalysisKey * ID()

Returns an opaque, unique ID for this analysis type.

Definition PassManager.h:108

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

A utility pass that does nothing, but preserves no analyses.

Definition PassManager.h:954

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

Run this pass over some unit of IR.

Definition PassManager.h:957

A no-op pass template which simply forces a specific analysis result to be invalidated.

Definition PassManager.h:929

void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)

Definition PassManager.h:942

PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM, ExtraArgTs &&...)

Run this pass over some unit of IR.

Definition PassManager.h:937

A CRTP mix-in to automatically provide informational APIs needed for passes.

Definition PassManager.h:69

static StringRef name()

Gets the name of the pass we are mixed into.

Definition PassManager.h:71

void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)

Definition PassManager.h:79

A utility pass template to force an analysis result to be available.

Definition PassManager.h:902

void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)

Definition PassManager.h:916

static bool isRequired()

Definition PassManager.h:922

PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM, ExtraArgTs &&... Args)

Run this pass over some unit of IR.

Definition PassManager.h:909

Abstract concept of an analysis pass.

Wrapper to model the analysis pass concept.

Abstract concept of an analysis result.

Wrapper to model the analysis result concept.

Template for the abstract base class used to dispatch polymorphically over pass objects.

A template wrapper used to implement the polymorphic API.