PassBuilder.h Source File (original) (raw)

15#ifndef LLVM_PASSES_PASSBUILDER_H

16#define LLVM_PASSES_PASSBUILDER_H

31#include

32#include

34namespace llvm {

42public:

100

102

103

104

106};

107

108

109

110

111

112

113

117 std::optional PGOOpt;

120

121public:

122

123

124

125

126

127

128

129

134

138 std::optional PGOOpt = std::nullopt,

141

142

143

144

145

150

151

152

153

154

155

156

158

159

160

161

162

163

164

166

167

168

169

170

171

172

174

175

176

177

178

179

181

182

183

184

185

186

187

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

225

226

227

230

231

232

235

236

237

238

239

240

241

242

243

244

245

246

247

248

251

252

253

254

255

256

257

261

262

263

264

265

266

268 bool ThinLTO,

269 bool EmitSummary);

270

271

272

273

274

275

276

277

280

281

282

283

284

285

286

289

290

291

292

293

294

295

296

299

300

301

302

303

304

305

308

309

310

311

315

316

317

318

319

320

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

365

366

367

368

369

370

371

372

379

380

381

382

383

384

385

386

387

388

389

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

409

410

411 LLVM_ABI std::optional

413

414

416

417

418

419

420

421

422

425 PeepholeEPCallbacks.push_back(C);

426 }

427

428

429

430

431

432

433

434

435

436

439 LateLoopOptimizationsEPCallbacks.push_back(C);

440 }

441

442

443

444

445

446

449 LoopOptimizerEndEPCallbacks.push_back(C);

450 }

451

452

453

454

455

456

459 ScalarOptimizerLateEPCallbacks.push_back(C);

460 }

461

462

463

464

465

466

467

470 CGSCCOptimizerLateEPCallbacks.push_back(C);

471 }

472

473

474

475

476

477

478

481 VectorizerStartEPCallbacks.push_back(C);

482 }

483

484

485

486

487

488

489

492 VectorizerEndEPCallbacks.push_back(C);

493 }

494

495

496

497

498

499

502 PipelineStartEPCallbacks.push_back(C);

503 }

504

505

506

507

508

512 PipelineEarlySimplificationEPCallbacks.push_back(C);

513 }

514

515

516

517

518

522 OptimizerEarlyEPCallbacks.push_back(C);

523 }

524

525

526

527

528

532 OptimizerLastEPCallbacks.push_back(C);

533 }

534

535

536

537

538

541 FullLinkTimeOptimizationEarlyEPCallbacks.push_back(C);

542 }

543

544

545

546

547

550 FullLinkTimeOptimizationLastEPCallbacks.push_back(C);

551 }

552

553

554

557 AAParsingCallbacks.push_back(C);

558 }

559

560

561

562

565 CGSCCAnalysisRegistrationCallbacks.push_back(C);

566 }

569 FunctionAnalysisRegistrationCallbacks.push_back(C);

570 }

573 LoopAnalysisRegistrationCallbacks.push_back(C);

574 }

577 ModuleAnalysisRegistrationCallbacks.push_back(C);

578 }

581 MachineFunctionAnalysisRegistrationCallbacks.push_back(C);

582 }

583

584

585

586

587

588

592 CGSCCPipelineParsingCallbacks.push_back(C);

593 }

597 FunctionPipelineParsingCallbacks.push_back(C);

598 }

602 LoopPipelineParsingCallbacks.push_back(C);

603 }

607 ModulePipelineParsingCallbacks.push_back(C);

608 }

612 MachineFunctionPipelineParsingCallbacks.push_back(C);

613 }

614

615

616

617

618

621 RegClassFilterParsingCallbacks.push_back(C);

622 }

623

624

625

626

627

628

631 &C);

632

633

635 bool RunProfileGen, bool IsCS,

636 bool AtomicCounterUpdate,

637 std::string ProfileFile,

638 std::string ProfileRemappingFile);

639

640

641

645

646

650

651

652

653

686

688 if (!Name.consume_front(PassName))

689 return false;

690

691 if (Name.empty())

692 return true;

693 return Name.starts_with("<") && Name.ends_with(">");

694 }

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711 template

714 -> decltype(Parser(StringRef{})) {

715 using ParametersT = typename decltype(Parser(StringRef{}))::value_type;

716

717 StringRef Params = Name;

718 if (!Params.consume_front(PassName)) {

720 "unable to strip pass name from parametrized pass specification");

721 }

722 if (!Params.empty() &&

723 (!Params.consume_front("<") || !Params.consume_back(">"))) {

724 llvm_unreachable("invalid format for parametrized pass name");

725 }

726

727 Expected Result = Parser(Params);

728 assert((Result || Result.template errorIsA()) &&

729 "Pass parameter parser can only return StringErrors.");

731 }

732

733

734

735

737 StringRef OptionName,

739

740private:

741

743 buildO1FunctionSimplificationPipeline(OptimizationLevel Level,

745

747

750

751 static std::optional<std::vector>

752 parsePipelineText(StringRef Text);

753

760 bool parseAAPassName(AAManager &AA, StringRef Name);

761

772

773

774

775

776 void addPreInlinerPasses(ModulePassManager &MPM, OptimizationLevel Level,

778

779 void addPGOInstrPasses(ModulePassManager &MPM, OptimizationLevel Level,

780 bool RunProfileGen, bool IsCS,

781 bool AtomicCounterUpdate, std::string ProfileFile,

782 std::string ProfileRemappingFile);

783 void addPostPGOLoopRotation(ModulePassManager &MPM, OptimizationLevel Level);

784

785 bool isInstrumentedPGOUse() const;

786

787

789 PeepholeEPCallbacks;

791 LateLoopOptimizationsEPCallbacks;

793 LoopOptimizerEndEPCallbacks;

795 ScalarOptimizerLateEPCallbacks;

797 CGSCCOptimizerLateEPCallbacks;

799 VectorizerStartEPCallbacks;

801 VectorizerEndEPCallbacks;

802

805 2>

806 OptimizerEarlyEPCallbacks;

809 2>

810 OptimizerLastEPCallbacks;

812 FullLinkTimeOptimizationEarlyEPCallbacks;

814 FullLinkTimeOptimizationLastEPCallbacks;

816 PipelineStartEPCallbacks;

819 2>

820 PipelineEarlySimplificationEPCallbacks;

821

823 ModuleAnalysisRegistrationCallbacks;

826 2>

827 ModulePipelineParsingCallbacks;

830 TopLevelPipelineParsingCallbacks;

831

833 CGSCCAnalysisRegistrationCallbacks;

836 2>

837 CGSCCPipelineParsingCallbacks;

838

840 FunctionAnalysisRegistrationCallbacks;

843 2>

844 FunctionPipelineParsingCallbacks;

845

847 LoopAnalysisRegistrationCallbacks;

850 2>

851 LoopPipelineParsingCallbacks;

852

853 SmallVector<std::function<bool(StringRef Name, AAManager &AA)>, 2>

854 AAParsingCallbacks;

855

857 MachineFunctionAnalysisRegistrationCallbacks;

860 2>

861 MachineFunctionPipelineParsingCallbacks;

862

864 RegClassFilterParsingCallbacks;

865};

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881template <typename AnalysisT, typename IRUnitT, typename AnalysisManagerT,

882 typename... ExtraArgTs>

886 if (!PipelineName.ends_with(">"))

887 return false;

888

889 if (PipelineName.starts_with("invalidate<")) {

890 PipelineName = PipelineName.substr(11, PipelineName.size() - 12);

891 if (PipelineName != AnalysisName)

892 return false;

894 return true;

895 }

896

897

898 if (PipelineName.starts_with("require<")) {

899 PipelineName = PipelineName.substr(8, PipelineName.size() - 9);

900 if (PipelineName != AnalysisName)

901 return false;

903 ExtraArgTs...>());

904 return true;

905 }

906

907 return false;

908}

909

910

911

912

918

919

928

929

936

937

948

949

955

956

965

966

973

974

981

982

988

989

1000

1001

1003}

1004

1005#endif

aarch64 falkor hwpf fix Falkor HW Prefetch Fix Late Phase

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

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

This header provides classes for managing passes over SCCs of the call graph.

This header defines various interfaces for pass management in LLVM.

This header provides classes for managing a pipeline of passes over loops in LLVM IR.

This header enumerates the LLVM-provided high-level optimization levels.

Define option tunables for PGO.

CGSCCAnalysisManager CGAM

FunctionAnalysisManager FAM

ModuleAnalysisManager MAM

Defines the virtual file system interface vfs::FileSystem.

static const char PassName[]

A manager for alias analyses.

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

Lightweight error class with error context and mandatory checking.

A smart pointer to a reference-counted object that inherits from RefCountedBase or ThreadSafeRefCount...

This class provides an interface for updating the loop pass manager based on mutations to the loop ne...

An SCC of the call graph.

A lazily constructed view of the call graph of a module.

This class represents a loop nest and can be used to query its properties.

Represents a single loop in the control flow graph.

Module pass, wrapping the inliner pass.

Class to hold module path string table and global value map, and encapsulate methods for operating on...

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

No-op CGSCC analysis.

Definition PassBuilder.h:938

Result run(LazyCallGraph::SCC &, CGSCCAnalysisManager &, LazyCallGraph &G)

Definition PassBuilder.h:944

No-op function analysis.

Definition PassBuilder.h:957

Result run(Function &, FunctionAnalysisManager &)

Definition PassBuilder.h:963

No-op loop analysis.

Definition PassBuilder.h:990

Result run(Loop &, LoopAnalysisManager &, LoopStandardAnalysisResults &)

Definition PassBuilder.h:996

No-op module analysis.

Definition PassBuilder.h:920

Result run(Module &, ModuleAnalysisManager &)

Definition PassBuilder.h:926

LLVM_ABI void invokeFullLinkTimeOptimizationLastEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)

LLVM_ABI ModuleInlinerWrapperPass buildInlinerPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase)

Construct the module pipeline that performs inlining as well as the inlining-driven cleanups.

void registerAnalysisRegistrationCallback(const std::function< void(MachineFunctionAnalysisManager &)> &C)

Definition PassBuilder.h:579

LLVM_ABI void printPassNames(raw_ostream &OS)

Print pass names.

static bool checkParametrizedPassName(StringRef Name, StringRef PassName)

Definition PassBuilder.h:687

LLVM_ABI void invokeOptimizerEarlyEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level, ThinOrFullLTOPhase Phase)

LLVM_ABI void invokeVectorizerStartEPCallbacks(FunctionPassManager &FPM, OptimizationLevel Level)

void registerPipelineParsingCallback(const std::function< bool(StringRef Name, ModulePassManager &, ArrayRef< PipelineElement >)> &C)

Definition PassBuilder.h:604

LLVM_ABI AAManager buildDefaultAAPipeline()

Build the default AAManager with the default alias analysis pipeline registered.

LLVM_ABI Error parseAAPipeline(AAManager &AA, StringRef PipelineText)

Parse a textual alias analysis pipeline into the provided AA manager.

LLVM_ABI void invokeCGSCCOptimizerLateEPCallbacks(CGSCCPassManager &CGPM, OptimizationLevel Level)

void registerPipelineEarlySimplificationEPCallback(const std::function< void(ModulePassManager &, OptimizationLevel, ThinOrFullLTOPhase)> &C)

Definition PassBuilder.h:509

LLVM_ABI ModulePassManager buildThinLTOPreLinkDefaultPipeline(OptimizationLevel Level)

Build a pre-link, ThinLTO-targeting default optimization pipeline to a pass manager.

void registerAnalysisRegistrationCallback(const std::function< void(ModuleAnalysisManager &)> &C)

Definition PassBuilder.h:575

LLVM_ABI void addPGOInstrPassesForO0(ModulePassManager &MPM, bool RunProfileGen, bool IsCS, bool AtomicCounterUpdate, std::string ProfileFile, std::string ProfileRemappingFile)

Add PGOInstrumenation passes for O0 only.

void registerPipelineStartEPCallback(const std::function< void(ModulePassManager &, OptimizationLevel)> &C)

Definition PassBuilder.h:500

LLVM_ABI void invokeScalarOptimizerLateEPCallbacks(FunctionPassManager &FPM, OptimizationLevel Level)

void registerPipelineParsingCallback(const std::function< bool(StringRef Name, LoopPassManager &, ArrayRef< PipelineElement >)> &C)

Definition PassBuilder.h:599

LLVM_ABI void registerLoopAnalyses(LoopAnalysisManager &LAM)

Registers all available loop analysis passes.

LLVM_ABI std::optional< RegAllocFilterFunc > parseRegAllocFilter(StringRef RegAllocFilterName)

Parse RegAllocFilterName to get RegAllocFilterFunc.

PassInstrumentationCallbacks * getPassInstrumentationCallbacks() const

Returns PIC.

Definition PassBuilder.h:642

void registerLateLoopOptimizationsEPCallback(const std::function< void(LoopPassManager &, OptimizationLevel)> &C)

Definition PassBuilder.h:437

LLVM_ABI void crossRegisterProxies(LoopAnalysisManager &LAM, FunctionAnalysisManager &FAM, CGSCCAnalysisManager &CGAM, ModuleAnalysisManager &MAM, MachineFunctionAnalysisManager *MFAM=nullptr)

Cross register the analysis managers through their proxies.

void registerLoopOptimizerEndEPCallback(const std::function< void(LoopPassManager &, OptimizationLevel)> &C)

Definition PassBuilder.h:447

void registerOptimizerLastEPCallback(const std::function< void(ModulePassManager &, OptimizationLevel, ThinOrFullLTOPhase)> &C)

Definition PassBuilder.h:529

void registerParseAACallback(const std::function< bool(StringRef Name, AAManager &AA)> &C)

Definition PassBuilder.h:555

void registerVectorizerStartEPCallback(const std::function< void(FunctionPassManager &, OptimizationLevel)> &C)

Definition PassBuilder.h:479

void registerAnalysisRegistrationCallback(const std::function< void(LoopAnalysisManager &)> &C)

Definition PassBuilder.h:571

LLVM_ABI ModulePassManager buildPerModuleDefaultPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase=ThinOrFullLTOPhase::None)

Build a per-module default optimization pipeline.

void registerPeepholeEPCallback(const std::function< void(FunctionPassManager &, OptimizationLevel)> &C)

Definition PassBuilder.h:423

LLVM_ABI PassBuilder(TargetMachine *TM=nullptr, PipelineTuningOptions PTO=PipelineTuningOptions(), std::optional< PGOOptions > PGOOpt=std::nullopt, PassInstrumentationCallbacks *PIC=nullptr, IntrusiveRefCntPtr< vfs::FileSystem > FS=vfs::getRealFileSystem())

void registerAnalysisRegistrationCallback(const std::function< void(FunctionAnalysisManager &)> &C)

Definition PassBuilder.h:567

void registerScalarOptimizerLateEPCallback(const std::function< void(FunctionPassManager &, OptimizationLevel)> &C)

Definition PassBuilder.h:457

void registerAnalysisRegistrationCallback(const std::function< void(CGSCCAnalysisManager &)> &C)

{{@ Register callbacks for analysis registration with this PassBuilder instance.

Definition PassBuilder.h:563

LLVM_ABI void invokePipelineStartEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)

LLVM_ABI void invokeVectorizerEndEPCallbacks(FunctionPassManager &FPM, OptimizationLevel Level)

IntrusiveRefCntPtr< vfs::FileSystem > getVirtualFileSystemPtr() const

Returns the virtual file system.

Definition PassBuilder.h:647

LLVM_ABI ModulePassManager buildO0DefaultPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase=ThinOrFullLTOPhase::None)

Build an O0 pipeline with the minimal semantically required passes.

LLVM_ABI FunctionPassManager buildFunctionSimplificationPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase)

Construct the core LLVM function canonicalization and simplification pipeline.

void registerCGSCCOptimizerLateEPCallback(const std::function< void(CGSCCPassManager &, OptimizationLevel)> &C)

Definition PassBuilder.h:468

LLVM_ABI void invokePeepholeEPCallbacks(FunctionPassManager &FPM, OptimizationLevel Level)

LLVM_ABI void invokePipelineEarlySimplificationEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level, ThinOrFullLTOPhase Phase)

LLVM_ABI Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText)

Parse a textual pass pipeline description into a ModulePassManager.

LLVM_ABI void invokeLoopOptimizerEndEPCallbacks(LoopPassManager &LPM, OptimizationLevel Level)

void registerRegClassFilterParsingCallback(const std::function< RegAllocFilterFunc(StringRef)> &C)

Definition PassBuilder.h:619

LLVM_ABI ModulePassManager buildLTODefaultPipeline(OptimizationLevel Level, ModuleSummaryIndex *ExportSummary)

Build an LTO default optimization pipeline to a pass manager.

LLVM_ABI ModulePassManager buildModuleInlinerPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase)

Construct the module pipeline that performs inlining with module inliner pass.

LLVM_ABI ModulePassManager buildThinLTODefaultPipeline(OptimizationLevel Level, const ModuleSummaryIndex *ImportSummary)

Build a ThinLTO default optimization pipeline to a pass manager.

void registerPipelineParsingCallback(const std::function< bool(StringRef Name, CGSCCPassManager &, ArrayRef< PipelineElement >)> &C)

{{@ Register pipeline parsing callbacks with this pass builder instance.

Definition PassBuilder.h:589

void registerFullLinkTimeOptimizationEarlyEPCallback(const std::function< void(ModulePassManager &, OptimizationLevel)> &C)

Definition PassBuilder.h:539

LLVM_ABI void invokeLateLoopOptimizationsEPCallbacks(LoopPassManager &LPM, OptimizationLevel Level)

void registerPipelineParsingCallback(const std::function< bool(StringRef Name, FunctionPassManager &, ArrayRef< PipelineElement >)> &C)

Definition PassBuilder.h:594

LLVM_ABI void registerModuleAnalyses(ModuleAnalysisManager &MAM)

Registers all available module analysis passes.

void registerFullLinkTimeOptimizationLastEPCallback(const std::function< void(ModulePassManager &, OptimizationLevel)> &C)

Definition PassBuilder.h:548

LLVM_ABI void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM)

Registers all available CGSCC analysis passes.

LLVM_ABI void invokeFullLinkTimeOptimizationEarlyEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)

LLVM_ABI ModulePassManager buildFatLTODefaultPipeline(OptimizationLevel Level, bool ThinLTO, bool EmitSummary)

Build a fat object default optimization pipeline.

static auto parsePassParameters(ParametersParseCallableT &&Parser, StringRef Name, StringRef PassName) -> decltype(Parser(StringRef{}))

This performs customized parsing of pass name with parameters.

Definition PassBuilder.h:712

LLVM_ABI ModulePassManager buildModuleSimplificationPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase)

Construct the core LLVM module canonicalization and simplification pipeline.

void registerPipelineParsingCallback(const std::function< bool(StringRef Name, MachineFunctionPassManager &, ArrayRef< PipelineElement >)> &C)

Definition PassBuilder.h:609

static LLVM_ABI Expected< bool > parseSinglePassOption(StringRef Params, StringRef OptionName, StringRef PassName)

Handle passes only accept one bool-valued parameter.

void registerOptimizerEarlyEPCallback(const std::function< void(ModulePassManager &, OptimizationLevel, ThinOrFullLTOPhase Phase)> &C)

Definition PassBuilder.h:519

LLVM_ABI void registerMachineFunctionAnalyses(MachineFunctionAnalysisManager &MFAM)

Registers all available machine function analysis passes.

LLVM_ABI ModulePassManager buildModuleOptimizationPipeline(OptimizationLevel Level, ThinOrFullLTOPhase LTOPhase)

Construct the core LLVM module optimization pipeline.

LLVM_ABI void registerParseTopLevelPipelineCallback(const std::function< bool(ModulePassManager &, ArrayRef< PipelineElement >)> &C)

LLVM_ABI void invokeOptimizerLastEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level, ThinOrFullLTOPhase Phase)

void registerVectorizerEndEPCallback(const std::function< void(FunctionPassManager &, OptimizationLevel)> &C)

Definition PassBuilder.h:490

LLVM_ABI ModulePassManager buildLTOPreLinkDefaultPipeline(OptimizationLevel Level)

Build a pre-link, LTO-targeting default optimization pipeline to a pass manager.

LLVM_ABI void registerFunctionAnalyses(FunctionAnalysisManager &FAM)

Registers all available function analysis passes.

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

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

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

Tunable parameters for passes in the default pipelines.

Definition PassBuilder.h:41

unsigned LicmMssaNoAccForPromotionCap

Tuning option to disable promotion to scalars in LICM with MemorySSA, if the number of access is too ...

Definition PassBuilder.h:78

bool SLPVectorization

Tuning option to enable/disable slp loop vectorization, set based on opt level.

Definition PassBuilder.h:56

bool DevirtualizeSpeculatively

Definition PassBuilder.h:105

int InlinerThreshold

Tuning option to override the default inliner threshold.

Definition PassBuilder.h:92

bool LoopFusion

Tuning option to enable/disable loop fusion. Its default value is false.

Definition PassBuilder.h:66

bool EagerlyInvalidateAnalyses

Definition PassBuilder.h:101

bool CallGraphProfile

Tuning option to enable/disable call graph profile.

Definition PassBuilder.h:82

bool MergeFunctions

Tuning option to enable/disable function merging.

Definition PassBuilder.h:89

bool ForgetAllSCEVInLoopUnroll

Tuning option to forget all SCEV loops in LoopUnroll.

Definition PassBuilder.h:70

unsigned LicmMssaOptCap

Tuning option to cap the number of calls to retrive clobbering accesses in MemorySSA,...

Definition PassBuilder.h:74

bool LoopInterleaving

Tuning option to set loop interleaving on/off, set based on opt level.

Definition PassBuilder.h:48

LLVM_ABI PipelineTuningOptions()

Constructor sets pipeline tuning defaults based on cl::opts.

bool LoopUnrolling

Tuning option to enable/disable loop unrolling. Its default value is true.

Definition PassBuilder.h:59

bool LoopInterchange

Tuning option to enable/disable loop interchange.

Definition PassBuilder.h:63

bool LoopVectorization

Tuning option to enable/disable loop vectorization, set based on opt level.

Definition PassBuilder.h:52

bool UnifiedLTO

Definition PassBuilder.h:85

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

static PreservedAnalyses all()

Construct a special preserved set that preserves all passes.

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

constexpr StringRef substr(size_t Start, size_t N=npos) const

Return a reference to the substring from [Start, Start + N).

bool starts_with(StringRef Prefix) const

Check if this string starts with the given Prefix.

constexpr size_t size() const

size - Get the string size.

bool ends_with(StringRef Suffix) const

Check if this string ends with the given Suffix.

Primary interface to the complete machine description for the target machine.

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

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

Abstract Attribute helper functions.

@ C

The default llvm calling convention, compatible with C.

template class LLVM_TEMPLATE_ABI opt< bool >

LLVM_ABI IntrusiveRefCntPtr< FileSystem > getRealFileSystem()

Gets an vfs::FileSystem for the 'real' file system, as seen by the operating system.

This is an optimization pass for GlobalISel generic memory operations.

std::function< bool(const TargetRegisterInfo &TRI, const MachineRegisterInfo &MRI, const Register Reg)> RegAllocFilterFunc

Filter function for register classes during regalloc.

bool parseAnalysisUtilityPasses(StringRef AnalysisName, StringRef PipelineName, PassManager< IRUnitT, AnalysisManagerT, ExtraArgTs... > &PM)

This utility template takes care of adding require<> and invalidate<> passes for an analysis to a giv...

Definition PassBuilder.h:883

AnalysisManager< MachineFunction > MachineFunctionAnalysisManager

PassManager< LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, CGSCCUpdateResult & > CGSCCPassManager

The CGSCC pass manager.

AnalysisManager< LazyCallGraph::SCC, LazyCallGraph & > CGSCCAnalysisManager

The CGSCC analysis manager.

AnalysisManager< Loop, LoopStandardAnalysisResults & > LoopAnalysisManager

The loop analysis manager.

ThinOrFullLTOPhase

This enumerates the LLVM full LTO or ThinLTO optimization phases.

@ None

No LTO/ThinLTO behavior needed.

PassManager< Loop, LoopAnalysisManager, LoopStandardAnalysisResults &, LPMUpdater & > LoopPassManager

The Loop pass manager.

LLVM_ABI cl::opt< bool > PrintPipelinePasses

Common option used by multiple tools to print pipeline passes.

PassManager< Module > ModulePassManager

Convenience typedef for a pass manager over modules.

class LLVM_GSL_OWNER SmallVector

Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...

PassManager< Function > FunctionPassManager

Convenience typedef for a pass manager over functions.

ArrayRef(const T &OneElt) -> ArrayRef< T >

PassManager< MachineFunction > MachineFunctionPassManager

Convenience typedef for a pass manager over functions.

AnalysisManager< Function > FunctionAnalysisManager

Convenience typedef for the Function analysis manager.

AnalysisManager< Module > ModuleAnalysisManager

Convenience typedef for the Module analysis manager.

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...

Support structure for SCC passes to communicate updates the call graph back to the CGSCC pass manager...

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

The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...

Definition PassBuilder.h:943

No-op CGSCC pass which does nothing.

Definition PassBuilder.h:930

PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &, LazyCallGraph &, CGSCCUpdateResult &UR)

Definition PassBuilder.h:931

Definition PassBuilder.h:962

No-op function pass which does nothing.

Definition PassBuilder.h:950

PreservedAnalyses run(Function &F, FunctionAnalysisManager &)

Definition PassBuilder.h:951

Definition PassBuilder.h:995

No-op loop nest pass which does nothing.

Definition PassBuilder.h:967

PreservedAnalyses run(LoopNest &L, LoopAnalysisManager &, LoopStandardAnalysisResults &, LPMUpdater &)

Definition PassBuilder.h:968

No-op loop pass which does nothing.

Definition PassBuilder.h:975

PreservedAnalyses run(Loop &L, LoopAnalysisManager &, LoopStandardAnalysisResults &, LPMUpdater &)

Definition PassBuilder.h:976

No-op machine function pass which does nothing.

Definition PassBuilder.h:983

PreservedAnalyses run(MachineFunction &, MachineFunctionAnalysisManager &)

Definition PassBuilder.h:984

Definition PassBuilder.h:925

No-op module pass which does nothing.

Definition PassBuilder.h:913

PreservedAnalyses run(Module &M, ModuleAnalysisManager &)

Definition PassBuilder.h:914

A struct to capture parsed pass pipeline names.

Definition PassBuilder.h:130

std::vector< PipelineElement > InnerPipeline

Definition PassBuilder.h:132

StringRef Name

Definition PassBuilder.h:131

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

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