LLVM: include/llvm/Passes/CodeGenPassBuilder.h Source File (original) (raw)
1
2
3
4
5
6
7
8
9
10
11
12
13
14#ifndef LLVM_PASSES_CODEGENPASSBUILDER_H
15#define LLVM_PASSES_CODEGENPASSBUILDER_H
16
95#include
96#include <type_traits>
97#include
98
99namespace llvm {
100
101
102
103#define DUMMY_FUNCTION_PASS(NAME, PASS_NAME) \
104 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
105 template <typename... Ts> PASS_NAME(Ts &&...) {} \
106 PreservedAnalyses run(Function &, FunctionAnalysisManager &) { \
107 return PreservedAnalyses::all(); \
108 } \
109 };
110#define DUMMY_MACHINE_MODULE_PASS(NAME, PASS_NAME) \
111 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
112 template <typename... Ts> PASS_NAME(Ts &&...) {} \
113 PreservedAnalyses run(Module &, ModuleAnalysisManager &) { \
114 return PreservedAnalyses::all(); \
115 } \
116 };
117#define DUMMY_MACHINE_FUNCTION_PASS(NAME, PASS_NAME) \
118 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
119 template <typename... Ts> PASS_NAME(Ts &&...) {} \
120 PreservedAnalyses run(MachineFunction &, \
121 MachineFunctionAnalysisManager &) { \
122 return PreservedAnalyses::all(); \
123 } \
124 };
125#include "llvm/Passes/MachinePassRegistry.def"
126
127
128
129
130
131
132
134public:
139
140
141
142
143
146
149
152 }
153
157
159 return PIC;
160 }
161
162protected:
163 template
164 using has_required_t = decltype(std::declval<PassT &>().isRequired());
165
166 template
168 std::declval<Module &>(), std::declval<ModuleAnalysisManager &>()));
169
170 template
172 std::declval<Function &>(), std::declval<FunctionAnalysisManager &>()));
173
174 template
176 std::declval<MachineFunction &>(),
177 std::declval<MachineFunctionAnalysisManager &>()));
178
179
180
181
182
184 public:
189 }
190
191 template
195 "Only module pass and function pass are supported.");
196 bool Required = false;
198 Required = PassT::isRequired();
199 if (!PB.runBeforeAdding(Name) && !Required)
200 return;
201
202
205 } else {
206
210 }
211
213 }
214 }
215
216 private:
219 const DerivedT &PB;
220 };
221
222
224 public:
234 }
235 }
236
237 template
242 "Only module pass and function pass are supported.");
243
244 if (!Force && !PB.runBeforeAdding(Name))
245 return;
246
247
250 } else {
251
256 }
257
259 }
260
261 for (auto &C : PB.AfterCallbacks)
263 }
264
265 private:
268 const DerivedT &PB;
269 };
270
274
275 template TMC &getTM() const { return static_cast<TMC &>(TM); }
277
278
279
280
283 }
284
285
286
287
290 }
291
292
293
295 return make_error("addInstSelector is not overridden",
297 }
298
299
301
302
303
304
305
306
307
309
310
311
313
314
315
316
317
318
319
320
321
322
323
324
325
327
328
329
331
332
333
335
336
337
339
340
341
343
344
345
346
347
348
350
351
352
353
354
355
358 }
359
360
361
363 return make_error("addIRTranslator is not overridden",
365 }
366
367
368
370
371
372
374 return make_error("addLegalizeMachineIR is not overridden",
376 }
377
378
379
381
382
383
384
386 return make_error("addRegBankSelect is not overridden",
388 }
389
390
391
393
394
395
396
397
399 return make_error(
400 "addGlobalInstructionSelect is not overridden",
402 }
403
404
405
406
407
408
410
411
412
414
415
416
418
419
421
422
423
425
426
427
429
430
431
433
434
435
436
437
438
439
440
441
442
444
445
446
448
449
450
451
453
454
456
457
458
459
461
462
464
466 std::function<Expected<std::unique_ptr>(MCContext &)>;
469 }
470
471
472
473
474
475
477
478
479
481
482
483
486
487
488
490 BeforeCallbacks.emplace_back(
491 [](StringRef Name) { return ((Name != PassTs::name()) && ...); });
492 }
493
494
495
496 template <typename TargetPassT, typename InsertedPassT>
498 AfterCallbacks.emplace_back(
500 if (Name == TargetPassT::name())
501 MFPM.addPass(std::forward(Pass));
502 });
503 }
504
505private:
506 DerivedT &derived() { return static_cast<DerivedT &>(*this); }
507 const DerivedT &derived() const {
508 return static_cast<const DerivedT &>(*this);
509 }
510
511 bool runBeforeAdding(StringRef Name) const {
512 bool ShouldAdd = true;
513 for (auto &C : BeforeCallbacks)
515 return ShouldAdd;
516 }
517
518 void setStartStopPasses(const TargetPassConfig::StartStopInfo &Info) const;
519
520 Error verifyStartStop(const TargetPassConfig::StartStopInfo &Info) const;
521
523 BeforeCallbacks;
526 AfterCallbacks;
527
528
529 mutable bool Started = true;
530 mutable bool Stopped = true;
531};
532
533template <typename Derived, typename TargetMachineT>
538 if (!StartStopInfo)
539 return StartStopInfo.takeError();
540 setStartStopPasses(*StartStopInfo);
541
544
545 {
546 AddIRPass addIRPass(MPM, derived());
550 addISelPasses(addIRPass);
551 }
552
554
555 if (PrintMIR)
557
558 if (auto Err = addCoreISelPasses(addPass))
559 return std::move(Err);
560
561 if (auto Err = derived().addMachinePasses(addPass))
562 return std::move(Err);
563
566
567 if (PrintAsm) {
568 derived().addAsmPrinter(
569 addPass, [this, &Out, DwoOut, FileType](MCContext &Ctx) {
570 return this->TM.createMCStreamer(Out, DwoOut, FileType, Ctx);
571 });
572 }
573
574 if (PrintMIR)
576
577 return verifyStartStop(*StartStopInfo);
578}
579
580template <typename Derived, typename TargetMachineT>
583 if (.StartPass.empty()) {
584 Started = false;
585 BeforeCallbacks.emplace_back([this, &Info, AfterFlag = Info.StartAfter,
586 Count = 0u](StringRef ClassName) mutable {
587 if (Count == Info.StartInstanceNum) {
588 if (AfterFlag) {
589 AfterFlag = false;
590 Started = true;
591 }
592 return Started;
593 }
594
597 Started = .StartAfter;
598
599 return Started;
600 });
601 }
602
603 if (.StopPass.empty()) {
604 Stopped = false;
605 BeforeCallbacks.emplace_back([this, &Info, AfterFlag = Info.StopAfter,
606 Count = 0u](StringRef ClassName) mutable {
607 if (Count == Info.StopInstanceNum) {
608 if (AfterFlag) {
609 AfterFlag = false;
610 Stopped = true;
611 }
612 return !Stopped;
613 }
614
617 Stopped = .StopAfter;
618 return !Stopped;
619 });
620 }
621}
622
623template <typename Derived, typename TargetMachineT>
624Error CodeGenPassBuilder<Derived, TargetMachineT>::verifyStartStop(
625 const TargetPassConfig::StartStopInfo &Info) const {
626 if (Started && Stopped)
627 return Error::success();
628
629 if (!Started)
630 return make_error(
631 "Can't find start pass \"" + Info.StartPass + "\".",
632 std::make_error_code(std::errc::invalid_argument));
633 if (!Stopped)
634 return make_error(
635 "Can't find stop pass \"" + Info.StopPass + "\".",
636 std::make_error_code(std::errc::invalid_argument));
637 return Error::success();
638}
639
640template <typename Derived, typename TargetMachineT>
644 if (TM.useEmulatedTLS())
646
650
651 derived().addIRPasses(addPass);
652 derived().addCodeGenPrepare(addPass);
653 addPassesToHandleExceptions(addPass);
654 derived().addISelPrepare(addPass);
655}
656
657
658
659template <typename Derived, typename TargetMachineT>
662
663
666
667
668 if (getOptLevel() != CodeGenOptLevel::None && !Opt.DisableLSR) {
670 true));
671 }
672
673 if (getOptLevel() != CodeGenOptLevel::None) {
674
675
676
677
681 }
682
683
684
688
689
691
692
695
696
697
698 if (getOptLevel() != CodeGenOptLevel::None)
700
701 if (getOptLevel() != CodeGenOptLevel::None &&
704
705
707
708
709
710
712
713
715
716
719
722}
723
724
725
726template <typename Derived, typename TargetMachineT>
729 const MCAsmInfo *MCAI = TM.getMCAsmInfo();
730 assert(MCAI && "No MCAsmInfo");
732 case ExceptionHandling::SjLj:
733
734
735
736
737
738
740 [[fallthrough]];
741 case ExceptionHandling::DwarfCFI:
742 case ExceptionHandling::ARM:
743 case ExceptionHandling::AIX:
744 case ExceptionHandling::ZOS:
746 break;
747 case ExceptionHandling::WinEH:
748
749
750
753 break;
754 case ExceptionHandling::Wasm:
755
756
757
758
759 addPass(WinEHPreparePass(false));
761 break;
762 case ExceptionHandling::None:
764
765
767 break;
768 }
769}
770
771
772
773template <typename Derived, typename TargetMachineT>
776 if (getOptLevel() != CodeGenOptLevel::None && !Opt.DisableCGP)
778
779
780}
781
782
783
784template <typename Derived, typename TargetMachineT>
788
790
791
794
797 "\n\n*** Final LLVM Code input to ISel ***\n"));
798
799
800
803}
804
805template <typename Derived, typename TargetMachineT>
808
810
811
813 SelectorType Selector;
814
816 Selector = SelectorType::FastISel;
819 (TM.Options.EnableGlobalISel &&
822 Selector = SelectorType::GlobalISel;
823 else if (TM.getOptLevel() == CodeGenOptLevel::None && TM.getO0WantsFastISel())
824 Selector = SelectorType::FastISel;
825 else
826 Selector = SelectorType::SelectionDAG;
827
828
829 if (Selector == SelectorType::FastISel) {
830 TM.setFastISel(true);
831 TM.setGlobalISel(false);
832 } else if (Selector == SelectorType::GlobalISel) {
833 TM.setFastISel(false);
834 TM.setGlobalISel(true);
835 }
836
837
838 if (Selector == SelectorType::GlobalISel) {
839 if (auto Err = derived().addIRTranslator(addPass))
840 return std::move(Err);
841
842 derived().addPreLegalizeMachineIR(addPass);
843
844 if (auto Err = derived().addLegalizeMachineIR(addPass))
845 return std::move(Err);
846
847
848
849 derived().addPreRegBankSelect(addPass);
850
851 if (auto Err = derived().addRegBankSelect(addPass))
852 return std::move(Err);
853
854 derived().addPreGlobalInstructionSelect(addPass);
855
856 if (auto Err = derived().addGlobalInstructionSelect(addPass))
857 return std::move(Err);
858
859
860 addPass(ResetMachineFunctionPass(reportDiagnosticWhenGlobalISelFallback(),
861 isGlobalISelAbortEnabled()));
862
863
864
865 if (!isGlobalISelAbortEnabled())
866 if (auto Err = derived().addInstSelector(addPass))
867 return std::move(Err);
868
869 } else if (auto Err = derived().addInstSelector(addPass))
870 return std::move(Err);
871
872
873
875
876
877
878
879 return Error::success();
880}
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898template <typename Derived, typename TargetMachineT>
901
902 if (getOptLevel() != CodeGenOptLevel::None) {
904 } else {
905
906
908 }
909
910 if (TM.Options.EnableIPRA) {
913 }
914
915 derived().addPreRegAlloc(addPass);
916
917
918
920 derived().addOptimizedRegAlloc(addPass);
921 } else {
922 if (auto Err = derived().addFastRegAlloc(addPass))
923 return Err;
924 }
925
926
927 derived().addPostRegAlloc(addPass);
928
929 addPass(RemoveRedundantDebugValuesPass());
930
931
932 if (getOptLevel() != CodeGenOptLevel::None) {
933 addPass(PostRAMachineSinkingPass());
934 addPass(ShrinkWrapPass());
935 }
936
937 addPass(PrologEpilogInserterPass());
938
939
940 if (getOptLevel() != CodeGenOptLevel::None)
941 derived().addMachineLateOptimization(addPass);
942
943
944 addPass(ExpandPostRAPseudosPass());
945
946
947 derived().addPreSched2(addPass);
948
950 addPass(ImplicitNullChecksPass());
951
952
953
954
955 if (getOptLevel() != CodeGenOptLevel::None &&
956 !TM.targetSchedulesPostRAScheduling()) {
958 addPass(PostMachineSchedulerPass());
959 else
960 addPass(PostRASchedulerPass());
961 }
962
963
964 derived().addGCPasses(addPass);
965
966
967 if (getOptLevel() != CodeGenOptLevel::None)
968 derived().addBlockPlacement(addPass);
969
970
971 addPass(FEntryInserterPass());
972
973 addPass(XRayInstrumentationPass());
974 addPass(PatchableFunctionPass());
975
976 derived().addPreEmitPass(addPass);
977
978 if (TM.Options.EnableIPRA)
979
980
982
983 addPass(FuncletLayoutPass());
984
985 addPass(StackMapLivenessPass());
986 addPass(LiveDebugValuesPass());
987 addPass(MachineSanitizerBinaryMetadata());
988
989 if (TM.Options.EnableMachineOutliner &&
990 getOptLevel() != CodeGenOptLevel::None &&
992 bool RunOnAllFunctions =
994 bool AddOutliner = RunOnAllFunctions || TM.Options.SupportsDefaultOutlining;
995 if (AddOutliner)
996 addPass(MachineOutlinerPass(RunOnAllFunctions));
997 }
998
999
1000 derived().addPreEmitPass2(addPass);
1001
1002 return Error::success();
1003}
1004
1005
1006template <typename Derived, typename TargetMachineT>
1009
1011
1012
1013
1015
1016
1017
1019
1020
1021
1023
1024
1025
1026
1027
1029
1030
1031
1032
1033 derived().addILPOpts(addPass);
1034
1037
1038 addPass(MachineSinkingPass());
1039
1041
1042
1044}
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058template <typename Derived, typename TargetMachineT>
1061 if (Optimized)
1062 addPass(RAGreedyPass());
1063 else
1065}
1066
1067
1068
1069
1070template <typename Derived, typename TargetMachineT>
1073
1074}
1075
1076template <typename Derived, typename TargetMachineT>
1079
1080 addRegAllocPass(addPass, false);
1081 return Error::success();
1082}
1083
1084template <typename Derived, typename TargetMachineT>
1087
1088 addRegAllocPass(addPass, true);
1089
1090
1091 derived().addPreRewrite(addPass);
1092
1093
1094 addPass(VirtRegRewriterPass());
1095
1096
1097
1098
1099 addPass(StackSlotColoringPass());
1100
1101 return Error::success();
1102}
1103
1104
1105
1106template <typename Derived, typename TargetMachineT>
1111 return derived().addRegAssignmentFast(addPass);
1112}
1113
1114
1115
1116
1117template <typename Derived, typename TargetMachineT>
1120 addPass(DetectDeadLanesPass());
1121
1122 addPass(InitUndefPass());
1123
1124 addPass(ProcessImplicitDefsPass());
1125
1126
1128
1129
1132
1134 addPass(RegisterCoalescerPass());
1135
1136
1137
1138
1139 addPass(RenameIndependentSubregsPass());
1140
1141
1142 addPass(MachineSchedulerPass());
1143
1144 if (derived().addRegAssignmentOptimized(addPass)) {
1145
1146
1147 derived().addPostRewrite(addPass);
1148
1149
1150
1151 addPass(MachineCopyPropagationPass());
1152
1153
1154
1155
1157 }
1158}
1159
1160
1161
1162
1163
1164
1165template <typename Derived, typename TargetMachineT>
1168
1169 addPass(BranchFolderPass());
1170
1171
1172
1173
1174
1175 if (!TM.requiresStructuredCFG())
1177
1178
1179 addPass(MachineLateInstrsCleanupPass());
1180
1181
1182 addPass(MachineCopyPropagationPass());
1183}
1184
1185
1186template <typename Derived, typename TargetMachineT>
1189 addPass(MachineBlockPlacementPass());
1190
1192 addPass(MachineBlockPlacementStatsPass());
1193}
1194
1195}
1196
1197#endif
This is the interface for LLVM's primary stateless and local alias analysis.
Analysis containing CSE Info
Defines an IR pass for CodeGen Prepare.
This file defines passes to print out IR in various granularities.
This header defines various interfaces for pass management in LLVM.
This file contains the declaration of the InterleavedAccessPass class, its corresponding pass name is...
This header provides classes for managing a pipeline of passes over loops in LLVM IR.
The header file for the LowerConstantIntrinsics pass as used by the new pass manager.
PassInstrumentationCallbacks PIC
PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC)
This pass is required to take advantage of the interprocedural register allocation infrastructure.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This is the interface for a metadata-based scoped no-alias analysis.
This file contains the declaration of the SelectOptimizePass class, its corresponding pass name is se...
This file defines the SmallVector class.
Target-Independent Code Generator Pass Configuration Options pass.
This pass exposes codegen information to IR-level passes.
This is the interface for a metadata-based TBAA.
static const char PassName[]
AddIRPass(ModulePassManager &MPM, const DerivedT &PB)
void operator()(PassT &&Pass, StringRef Name=PassT::name())
AddMachinePass(ModulePassManager &MPM, const DerivedT &PB)
void operator()(PassT &&Pass, bool Force=false, StringRef Name=PassT::name())
This class provides access to building LLVM's passes.
void addPreRewrite(AddMachinePass &) const
addPreRewrite - Add passes to the optimized register allocation pipeline after register allocation is...
void addPostRegAlloc(AddMachinePass &) const
This method may be implemented by targets that want to run passes after register allocation pass pipe...
void insertPass(InsertedPassT &&Pass)
Insert InsertedPass pass after TargetPass pass.
void addPreGlobalInstructionSelect(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before the (global) ins...
Error addRegAssignmentFast(AddMachinePass &) const
Add core register alloator passes which do the actual register assignment and rewriting.
Error addFastRegAlloc(AddMachinePass &) const
addFastRegAlloc - Add the minimum set of target-independent passes that are required for fast registe...
Error addIRTranslator(AddMachinePass &) const
This method should install an IR translator pass, which converts from LLVM code to machine instructio...
void addILPOpts(AddMachinePass &) const
Add passes that optimize instruction level parallelism for out-of-order targets.
void addRegAllocPass(AddMachinePass &, bool Optimized) const
addMachinePasses helper to create the target-selected or overriden regalloc pass.
void addPreSched2(AddMachinePass &) const
This method may be implemented by targets that want to run passes after prolog-epilog insertion and b...
std::function< Expected< std::unique_ptr< MCStreamer > >(MCContext &)> CreateMCStreamer
Error addRegBankSelect(AddMachinePass &) const
This method should install a register bank selector pass, which assigns register banks to virtual reg...
decltype(std::declval< PassT & >().isRequired()) has_required_t
bool isGlobalISelAbortEnabled() const
Check whether or not GlobalISel should abort on error.
void addPreRegAlloc(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before register allocat...
void addGCPasses(AddMachinePass &) const
addGCPasses - Add late codegen passes that analyze code for garbage collection.
Error buildPipeline(ModulePassManager &MPM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut, CodeGenFileType FileType) const
void addGlobalMergePass(AddIRPass &) const
Target can override this to add GlobalMergePass before all IR passes.
Error addLegalizeMachineIR(AddMachinePass &) const
This method should install a legalize pass, which converts the instruction sequence into one that can...
Error addCoreISelPasses(AddMachinePass &) const
Add the actual instruction selection passes.
void addOptimizedRegAlloc(AddMachinePass &) const
addOptimizedRegAlloc - Add passes related to register allocation.
void addISelPasses(AddIRPass &) const
High level function that adds all passes necessary to go from llvm IR representation to the MI repres...
PassInstrumentationCallbacks * PIC
void addMachineSSAOptimization(AddMachinePass &) const
Methods with trivial inline returns are convenient points in the common codegen pass pipeline where t...
decltype(std::declval< PassT & >().run(std::declval< Module & >(), std::declval< ModuleAnalysisManager & >())) is_module_pass_t
CodeGenPassBuilder(TargetMachineT &TM, const CGPassBuilderOption &Opts, PassInstrumentationCallbacks *PIC)
Error addRegAssignmentOptimized(AddMachinePass &) const
void addCodeGenPrepare(AddIRPass &) const
Add pass to prepare the LLVM IR for code generation.
Error addMachinePasses(AddMachinePass &) const
Add the complete, standard set of LLVM CodeGen passes.
void addISelPrepare(AddIRPass &) const
Add common passes that perform LLVM IR to IR transforms in preparation for instruction selection.
void disablePass()
Allow the target to disable a specific pass by default.
void addBlockPlacement(AddMachinePass &) const
Add standard basic block placement passes.
Error addInstSelector(AddMachinePass &) const
addInstSelector - This method should install an instruction selector pass, which converts from LLVM c...
void addTargetRegisterAllocator(AddMachinePass &, bool Optimized) const
Utilities for targets to add passes to the pass manager.
void addPreEmitPass2(AddMachinePass &) const
Targets may add passes immediately before machine code is emitted in this callback.
void addPostRewrite(AddMachinePass &) const
Add passes to be run immediately after virtual registers are rewritten to physical registers.
void addPreRegBankSelect(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before the register ban...
void addPreEmitPass(AddMachinePass &) const
This pass may be implemented by targets that want to run passes immediately before machine code is em...
Error addGlobalInstructionSelect(AddMachinePass &) const
This method should install a (global) instruction selector pass, which converts possibly generic inst...
void addMachineLateOptimization(AddMachinePass &) const
Add passes that optimize machine instructions after register allocation.
void addIRPasses(AddIRPass &) const
Add common target configurable passes that perform LLVM IR to IR transforms following machine indepen...
decltype(std::declval< PassT & >().run(std::declval< Function & >(), std::declval< FunctionAnalysisManager & >())) is_function_pass_t
decltype(std::declval< PassT & >().run(std::declval< MachineFunction & >(), std::declval< MachineFunctionAnalysisManager & >())) is_machine_function_pass_t
void addPreLegalizeMachineIR(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before legalization.
CodeGenOptLevel getOptLevel() const
void addPassesToHandleExceptions(AddIRPass &) const
Add passes to lower exception handling for the code generator.
PassInstrumentationCallbacks * getPassInstrumentationCallbacks() const
bool reportDiagnosticWhenGlobalISelFallback() const
Check whether or not a diagnostic should be emitted when GlobalISel uses the fallback path.
void addPreISel(AddIRPass &) const
{{@ For GlobalISel
void addAsmPrinter(AddMachinePass &, CreateMCStreamer) const
Lightweight error class with error context and mandatory checking.
This is a fast-path instruction selection class that generates poor code and doesn't support illegal ...
LowerIntrinsics - This pass rewrites calls to the llvm.gcread or llvm.gcwrite intrinsics,...
Performs Loop Strength Reduce Pass.
This class is intended to be used as a base class for asm properties and features specific to the tar...
ExceptionHandling getExceptionHandlingType() const
Context object for machine code objects.
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v< PassT, PassManager > > addPass(PassT &&Pass)
bool isEmpty() const
Returns if the pass manager contains any passes.
Pass interface - Implemented by all 'passes'.
Pass (for the new pass manager) for printing a Function as LLVM's text IR assembly.
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
StringRef - Represent a constant reference to a string, i.e.
static Expected< StartStopInfo > getStartStopInfo(PassInstrumentationCallbacks &PIC)
Returns pass name in -stop-before or -stop-after NOTE: New pass manager migration only.
static bool willCompleteCodeGenPipeline()
Returns true if none of the -stop-before and -stop-after options is set.
An abstract base class for streams implementations that also support a pwrite operation.
unique_function is a type-erasing functor similar to std::function.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
This is an optimization pass for GlobalISel generic memory operations.
PassManager< Function > FunctionPassManager
Convenience typedef for a pass manager over functions.
ModuleToFunctionPassAdaptor createModuleToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
PassManager< MachineFunction > MachineFunctionPassManager
Convenience typedef for a pass manager over functions.
typename detail::detector< void, Op, Args... >::value_t is_detected
Detects if a given trait holds for some set of arguments 'Args'.
CodeGenFileType
These enums are meant to be passed into addPassesToEmitFile to indicate what type of file to emit,...
FunctionToMachineFunctionPassAdaptor createFunctionToMachineFunctionPassAdaptor(MachineFunctionPassT &&Pass)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
CodeGenOptLevel
Code generation optimization level.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
std::enable_if_t< is_detected< HasRunOnLoopT, LoopPassT >::value, FunctionToLoopPassAdaptor > createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA=false, bool UseBlockFrequencyInfo=false, bool UseBranchProbabilityInfo=false)
A function to deduce a loop pass type and wrap it in the templated adaptor.
bool DisablePartialLibcallInlining
std::optional< bool > EnableGlobalISelOption
std::optional< bool > EnableIPRA
bool DisableConstantHoisting
std::optional< bool > OptimizeRegAlloc
RunOutliner EnableMachineOutliner
bool EnableGlobalMergeFunc
std::optional< bool > EnableFastISelOption
std::optional< GlobalISelAbortMode > EnableGlobalISelAbort
bool EnableImplicitNullChecks
bool EnableBlockPlacementStats
bool DisableSelectOptimize
Global function merging pass for new pass manager.
A no-op pass template which simply forces a specific analysis result to be invalidated.
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
StringRef getPassNameForClassName(StringRef ClassName)
Get the pass name for a given pass class name.
A utility pass template to force an analysis result to be available.