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
130#include
131#include
132
133namespace llvm {
134
135
136
137#define DUMMY_FUNCTION_PASS(NAME, PASS_NAME) \
138 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
139 template <typename... Ts> PASS_NAME(Ts &&...) {} \
140 PreservedAnalyses run(Function &, FunctionAnalysisManager &) { \
141 return PreservedAnalyses::all(); \
142 } \
143 };
144#define DUMMY_MACHINE_MODULE_PASS(NAME, PASS_NAME) \
145 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
146 template <typename... Ts> PASS_NAME(Ts &&...) {} \
147 PreservedAnalyses run(Module &, ModuleAnalysisManager &) { \
148 return PreservedAnalyses::all(); \
149 } \
150 };
151#define DUMMY_MACHINE_FUNCTION_PASS(NAME, PASS_NAME) \
152 struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
153 template <typename... Ts> PASS_NAME(Ts &&...) {} \
154 PreservedAnalyses run(MachineFunction &, \
155 MachineFunctionAnalysisManager &) { \
156 return PreservedAnalyses::all(); \
157 } \
158 };
159#include "llvm/Passes/MachinePassRegistry.def"
160
161
162
163
164
165
166
168public:
173
174
175
176
177
178 if (Opt.EnableIPRA) {
179 TM.Options.EnableIPRA = *Opt.EnableIPRA;
180 } else {
181
182 TM.Options.EnableIPRA |= TM.useIPRA();
183 }
184
185 if (Opt.EnableGlobalISelAbort)
186 TM.Options.GlobalISelAbort = *Opt.EnableGlobalISelAbort;
187
188 if (.OptimizeRegAlloc)
190 }
191
195
199
200protected:
201 template
203 std::declval<Module &>(), std::declval<ModuleAnalysisManager &>()));
204
205 template
207 std::declval<Function &>(), std::declval<FunctionAnalysisManager &>()));
208
209 template
211 std::declval<MachineFunction &>(),
212 std::declval<MachineFunctionAnalysisManager &>()));
213
214
215
216
217
219 public:
222
223 template
225 StringRef Name = PassT::name()) {
228 "Only module pass and function pass are supported.");
229 if (!Force && !PB.runBeforeAdding(Name))
230 return;
231
232
234 FPM.addPass(std::forward(Pass));
235 } else {
236
237 flushFPMToMPM();
238 MPM.addPass(std::forward(Pass));
239 }
240 }
241
242
244 if (PB.AddInCGSCCOrder)
245 return;
246 flushFPMToMPM();
247 PB.AddInCGSCCOrder = true;
248 }
249
250
251
253 if (!PB.AddInCGSCCOrder)
254 return;
255 flushFPMToMPM();
256 PB.AddInCGSCCOrder = false;
257 }
258
259 private:
260 void flushFPMToMPM() {
262 return;
263 if (PB.AddInCGSCCOrder) {
266 } else {
268 }
270 }
273 const DerivedT &PB;
274 };
275
276
278 public:
280 : MPM(MPM), PB(PB) {}
282 if (MFPM.isEmpty())
283 return;
284
288 if (this->PB.AddInCGSCCOrder) {
291 } else
293 }
294
295 template
297 StringRef Name = PassT::name()) {
300 "Only module pass and function pass are supported.");
301
302 if (!Force && !PB.runBeforeAdding(Name))
303 return;
304
305
307 MFPM.addPass(std::forward(Pass));
308 } else {
309
310 flushMFPMToMPM();
311 MPM.addPass(std::forward(Pass));
312 }
313
314 for (auto &C : PB.AfterCallbacks)
315 C(Name, MFPM);
316 }
317
318
320 if (PB.AddInCGSCCOrder)
321 return;
322 flushMFPMToMPM();
323 PB.AddInCGSCCOrder = true;
324 }
325
326
327
329 if (!PB.AddInCGSCCOrder)
330 return;
331 flushMFPMToMPM();
332 PB.AddInCGSCCOrder = false;
333 }
334
335 private:
336 void flushMFPMToMPM() {
338 return;
339
340 if (PB.AddInCGSCCOrder) {
344 } else {
347 }
349 }
350
353 const DerivedT &PB;
354 };
355
359
360 template TMC &getTM() const { return static_cast<TMC &>(TM); }
362
363
364
365
369
370
371
372
376
377
378
383
384
386
387
388
389
390
391
392
394
395
396
398
399
400
401
402
403
404
405
406
407
408
409
410
412
413
414
416
417
418
420
421
422
424
425
426
428
429
430
431
432
433
435
436
437
438
439
440
444
445
446
451
452
453
455
456
457
462
463
464
466
467
468
469
474
475
476
478
479
480
481
482
485 "addGlobalInstructionSelect is not overridden",
487 }
488
489
490
491
492
493
495
496
497
499
500
501
503
504
506
507
508
510
511
512
514
515
516
518
519
520
521
522
523
524
525
526
527
529
530
531
533
534
535
536
538
539
541
542
543
544
546
547
549
551 std::function<Expected<std::unique_ptr>(MCContext &)>;
555
556
557
558
559
560
562
563
564
566
567
568
571
572
573
575 BeforeCallbacks.emplace_back(
576 [](StringRef Name) { return ((Name != PassTs::name()) && ...); });
577 }
578
579
580
581 template <typename TargetPassT, typename InsertedPassT>
583 AfterCallbacks.emplace_back(
585 if (Name == TargetPassT::name() &&
586 runBeforeAdding(InsertedPassT::name())) {
587 MFPM.addPass(std::forward(Pass));
588 }
589 });
590 }
591
592private:
593 DerivedT &derived() { return static_cast<DerivedT &>(*this); }
594 const DerivedT &derived() const {
595 return static_cast<const DerivedT &>(*this);
596 }
597
598 bool runBeforeAdding(StringRef Name) const {
599 bool ShouldAdd = true;
600 for (auto &C : BeforeCallbacks)
601 ShouldAdd &= C(Name);
602 return ShouldAdd;
603 }
604
605 void setStartStopPasses(const TargetPassConfig::StartStopInfo &Info) const;
606
607 Error verifyStartStop(const TargetPassConfig::StartStopInfo &Info) const;
608
609 mutable SmallVector<llvm::unique_function<bool(StringRef)>, 4>
610 BeforeCallbacks;
613 AfterCallbacks;
614
615
616 mutable bool Started = true;
617 mutable bool Stopped = true;
618 mutable bool AddInCGSCCOrder = false;
619};
620
621template <typename Derived, typename TargetMachineT>
626 if (!StartStopInfo)
627 return StartStopInfo.takeError();
628 setStartStopPasses(*StartStopInfo);
629
632
633 {
634 AddIRPass addIRPass(MPM, derived());
636 true);
638 true);
640 true);
642 true);
644 }
645
647
648 if (PrintMIR)
650
652 return std::move(Err);
653
655 return std::move(Err);
656
657 if (.DisableVerify)
659
660 if (PrintAsm) {
661 derived().addAsmPrinter(
662 addPass, [this, &Out, DwoOut, FileType](MCContext &Ctx) {
663 return this->TM.createMCStreamer(Out, DwoOut, FileType, Ctx);
664 });
665 }
666
667 if (PrintMIR)
669
670 return verifyStartStop(*StartStopInfo);
671}
672
673template <typename Derived, typename TargetMachineT>
674void CodeGenPassBuilder<Derived, TargetMachineT>::setStartStopPasses(
676 if (!Info.StartPass.empty()) {
677 Started = false;
678 BeforeCallbacks.emplace_back([this, &Info, AfterFlag = Info.StartAfter,
680 if (Count == Info.StartInstanceNum) {
681 if (AfterFlag) {
682 AfterFlag = false;
683 Started = true;
684 }
685 return Started;
686 }
687
688 auto PassName = PIC->getPassNameForClassName(ClassName);
689 if (Info.StartPass == PassName && ++Count == Info.StartInstanceNum)
690 Started = !Info.StartAfter;
691
692 return Started;
693 });
694 }
695
696 if (.StopPass.empty()) {
697 Stopped = false;
698 BeforeCallbacks.emplace_back([this, &Info, AfterFlag = Info.StopAfter,
700 if (Count == Info.StopInstanceNum) {
701 if (AfterFlag) {
702 AfterFlag = false;
703 Stopped = true;
704 }
705 return !Stopped;
706 }
707
710 Stopped = .StopAfter;
711 return !Stopped;
712 });
713 }
714}
715
716template <typename Derived, typename TargetMachineT>
717Error CodeGenPassBuilder<Derived, TargetMachineT>::verifyStartStop(
719 if (Started && Stopped)
721
722 if (!Started)
724 "Can't find start pass \"" + Info.StartPass + "\".",
725 std::make_error_code(std::errc::invalid_argument));
726 if (!Stopped)
728 "Can't find stop pass \"" + Info.StopPass + "\".",
729 std::make_error_code(std::errc::invalid_argument));
731}
732
733template <typename Derived, typename TargetMachineT>
736 derived().addGlobalMergePass(addPass);
737 if (TM.useEmulatedTLS())
739
743
744 derived().addIRPasses(addPass);
745 derived().addCodeGenPrepare(addPass);
747 derived().addISelPrepare(addPass);
748}
749
750
751
752template <typename Derived, typename TargetMachineT>
755
756
757 if (.DisableVerify)
759
760
765 if (Opt.EnableLoopTermFold)
768 true));
769 }
770
772
773
774
775
776 if (.DisableMergeICmps)
779 }
780
781
782
786
787
789
790
793
794
795
798
800 .DisablePartialLibcallInlining)
802
803
805
806
807
808
810
811
812 if (.DisableExpandReductions)
814
815
818
819 if (Opt.EnableGlobalMergeFunc)
821}
822
823
824
825template <typename Derived, typename TargetMachineT>
828 const MCAsmInfo *MCAI = TM.getMCAsmInfo();
829 assert(MCAI && "No MCAsmInfo");
832
833
834
835
836
837
839 [[fallthrough]];
845 break;
847
848
849
852 break;
854
855
856
857
858 addPass(WinEHPreparePass(false));
860 break;
863
864
866 break;
867 }
868}
869
870
871
872template <typename Derived, typename TargetMachineT>
880
881
882
883template <typename Derived, typename TargetMachineT>
886 derived().addPreISel(addPass);
887
888 if (Opt.RequiresCodeGenSCCOrder)
890
893
895
896
899
900 if (Opt.PrintISelInput)
902 "\n\n*** Final LLVM Code input to ISel ***\n"));
903
904
905
906 if (.DisableVerify)
908}
909
910template <typename Derived, typename TargetMachineT>
913
914 TM.setO0WantsFastISel(Opt.EnableFastISelOption.value_or(true));
915
916
918 SelectorType Selector;
919
920 if (Opt.EnableFastISelOption && *Opt.EnableFastISelOption == true)
921 Selector = SelectorType::FastISel;
922 else if ((Opt.EnableGlobalISelOption &&
923 *Opt.EnableGlobalISelOption == true) ||
924 (TM.Options.EnableGlobalISel &&
925 (.EnableGlobalISelOption ||
926 *Opt.EnableGlobalISelOption == false)))
927 Selector = SelectorType::GlobalISel;
929 Selector = SelectorType::FastISel;
930 else
931 Selector = SelectorType::SelectionDAG;
932
933
934 if (Selector == SelectorType::FastISel) {
935 TM.setFastISel(true);
936 TM.setGlobalISel(false);
937 } else if (Selector == SelectorType::GlobalISel) {
938 TM.setFastISel(false);
939 TM.setGlobalISel(true);
940 }
941
942
943 if (Selector == SelectorType::GlobalISel) {
945 return std::move(Err);
946
947 derived().addPreLegalizeMachineIR(addPass);
948
950 return std::move(Err);
951
952
953
954 derived().addPreRegBankSelect(addPass);
955
957 return std::move(Err);
958
959 derived().addPreGlobalInstructionSelect(addPass);
960
962 return std::move(Err);
963
964
967
968
969
972 return std::move(Err);
973
974 } else if (auto Err = derived().addInstSelector(addPass))
975 return std::move(Err);
976
977
978
980
981
982
983
985}
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003template <typename Derived, typename TargetMachineT>
1006
1008 derived().addMachineSSAOptimization(addPass);
1009 } else {
1010
1011
1013 }
1014
1015 if (TM.Options.EnableIPRA) {
1018 }
1019
1020 derived().addPreRegAlloc(addPass);
1021
1022
1023
1024 if (*Opt.OptimizeRegAlloc) {
1025 derived().addOptimizedRegAlloc(addPass);
1026 } else {
1028 return Err;
1029 }
1030
1031
1032 derived().addPostRegAlloc(addPass);
1033
1036
1037
1041 }
1042
1044
1045
1047 derived().addMachineLateOptimization(addPass);
1048
1049
1051
1052
1053 derived().addPreSched2(addPass);
1054
1055 if (Opt.EnableImplicitNullChecks)
1056 addPass(ImplicitNullChecksPass());
1057
1058
1059
1060
1062 .targetSchedulesPostRAScheduling()) {
1063 if (Opt.MISchedPostRA)
1065 else
1067 }
1068
1069
1070 derived().addGCPasses(addPass);
1071
1072
1074 derived().addBlockPlacement(addPass);
1075
1076
1078
1081
1082 derived().addPreEmitPass(addPass);
1083
1084 if (TM.Options.EnableIPRA) {
1085
1086
1089 }
1090
1091 addPass(FuncletLayoutPass());
1092
1094 addPass(StackMapLivenessPass());
1098
1099 if (TM.Options.EnableMachineOutliner &&
1103 TM.Options.SupportsDefaultOutlining)
1104 addPass(MachineOutlinerPass(Opt.EnableMachineOutliner));
1105 }
1106
1108
1109
1110 derived().addPreEmitPass2(addPass);
1111
1113}
1114
1115
1116template <typename Derived, typename TargetMachineT>
1119
1121
1122
1123
1125
1126
1127
1129
1130
1131
1133
1134
1135
1136
1137
1139
1140
1141
1142
1143 derived().addILPOpts(addPass);
1144
1147
1149
1151
1152
1154}
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170template <typename Derived, typename TargetMachineT>
1173 if (Optimized)
1175 else
1177}
1178
1179
1180
1181
1182
1183
1184
1185template <typename Derived, typename TargetMachineT>
1188
1190 switch (Opt.RegAlloc) {
1193 break;
1196 break;
1197 default:
1199 }
1200 return;
1201 }
1202
1203
1204 derived().addTargetRegisterAllocator(addPass, Optimized);
1205}
1206
1207template <typename Derived, typename TargetMachineT>
1214
1215template <typename Derived, typename TargetMachineT>
1218
1220
1221
1222 derived().addPreRewrite(addPass);
1223
1224
1226
1227
1228
1229
1231
1233}
1234
1235
1236
1237template <typename Derived, typename TargetMachineT>
1242 return derived().addRegAssignmentFast(addPass);
1243}
1244
1245
1246
1247
1248template <typename Derived, typename TargetMachineT>
1252
1254
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1269
1270
1273
1274
1275 if (Opt.EarlyLiveIntervals)
1277
1280
1281
1282
1283
1285
1286
1288
1290
1291 return;
1292 }
1293
1294
1295 derived().addPostRewrite(addPass);
1296
1297
1298
1300
1301
1302
1303
1305}
1306
1307
1308
1309
1310
1311
1312template <typename Derived, typename TargetMachineT>
1315
1317
1318
1319
1320
1321
1322 if (.requiresStructuredCFG())
1324
1325
1327
1328
1330}
1331
1332
1333template <typename Derived, typename TargetMachineT>
1337
1338 if (Opt.EnableBlockPlacementStats)
1340}
1341
1342}
1343
1344#endif
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This is the interface for LLVM's primary stateless and local alias analysis.
This header provides classes for managing passes over SCCs of the call graph.
Analysis containing CSE Info
Defines an IR pass for CodeGen Prepare.
Analysis that tracks defined/used subregister lanes across COPY instructions and instructions that ge...
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.
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[]
A pass that canonicalizes freeze instructions in a loop.
AddIRPass(ModulePassManager &MPM, const DerivedT &PB)
Definition CodeGenPassBuilder.h:220
void operator()(PassT &&Pass, bool Force=false, StringRef Name=PassT::name())
Definition CodeGenPassBuilder.h:224
~AddIRPass()
Definition CodeGenPassBuilder.h:221
void requireCGSCCOrder()
Setting this will add passes to the CGSCC pass manager.
Definition CodeGenPassBuilder.h:243
void stopAddingInCGSCCOrder()
Stop adding passes to the CGSCC pass manager.
Definition CodeGenPassBuilder.h:252
void stopAddingInCGSCCOrder()
Stop adding passes to the CGSCC pass manager.
Definition CodeGenPassBuilder.h:328
AddMachinePass(ModulePassManager &MPM, const DerivedT &PB)
Definition CodeGenPassBuilder.h:279
~AddMachinePass()
Definition CodeGenPassBuilder.h:281
void operator()(PassT &&Pass, bool Force=false, StringRef Name=PassT::name())
Definition CodeGenPassBuilder.h:296
void requireCGSCCOrder()
Setting this will add passes to the CGSCC pass manager.
Definition CodeGenPassBuilder.h:319
void addPreRewrite(AddMachinePass &) const
addPreRewrite - Add passes to the optimized register allocation pipeline after register allocation is...
Definition CodeGenPassBuilder.h:411
void addPostRegAlloc(AddMachinePass &) const
This method may be implemented by targets that want to run passes after register allocation pass pipe...
Definition CodeGenPassBuilder.h:419
void addPreGlobalInstructionSelect(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before the (global) ins...
Definition CodeGenPassBuilder.h:477
Error addRegAssignmentFast(AddMachinePass &) const
Add core register alloator passes which do the actual register assignment and rewriting.
Definition CodeGenPassBuilder.h:1208
decltype(std::declval< PassT & >().run( std::declval< Function & >(), std::declval< FunctionAnalysisManager & >())) is_function_pass_t
Definition CodeGenPassBuilder.h:206
Error addFastRegAlloc(AddMachinePass &) const
addFastRegAlloc - Add the minimum set of target-independent passes that are required for fast registe...
Definition CodeGenPassBuilder.h:1238
Error addIRTranslator(AddMachinePass &) const
This method should install an IR translator pass, which converts from LLVM code to machine instructio...
Definition CodeGenPassBuilder.h:447
void addILPOpts(AddMachinePass &) const
Add passes that optimize instruction level parallelism for out-of-order targets.
Definition CodeGenPassBuilder.h:393
void addRegAllocPass(AddMachinePass &, bool Optimized) const
addMachinePasses helper to create the target-selected or overriden regalloc pass.
Definition CodeGenPassBuilder.h:1186
void addPreSched2(AddMachinePass &) const
This method may be implemented by targets that want to run passes after prolog-epilog insertion and b...
Definition CodeGenPassBuilder.h:423
Error addRegBankSelect(AddMachinePass &) const
This method should install a register bank selector pass, which assigns register banks to virtual reg...
Definition CodeGenPassBuilder.h:470
bool isGlobalISelAbortEnabled() const
Check whether or not GlobalISel should abort on error.
Definition CodeGenPassBuilder.h:366
GCNTargetMachine & TM
Definition CodeGenPassBuilder.h:356
void addPreRegAlloc(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before register allocat...
Definition CodeGenPassBuilder.h:397
void insertPass(InsertedPassT &&Pass) const
Insert InsertedPass pass after TargetPass pass.
Definition CodeGenPassBuilder.h:582
void addGCPasses(AddMachinePass &) const
addGCPasses - Add late codegen passes that analyze code for garbage collection.
Definition CodeGenPassBuilder.h:545
Error buildPipeline(ModulePassManager &MPM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut, CodeGenFileType FileType) const
Definition CodeGenPassBuilder.h:622
void addGlobalMergePass(AddIRPass &) const
Target can override this to add GlobalMergePass before all IR passes.
Definition CodeGenPassBuilder.h:385
Error addLegalizeMachineIR(AddMachinePass &) const
This method should install a legalize pass, which converts the instruction sequence into one that can...
Definition CodeGenPassBuilder.h:458
Error addCoreISelPasses(AddMachinePass &) const
Add the actual instruction selection passes.
Definition CodeGenPassBuilder.h:911
std::function< Expected< std::unique_ptr< MCStreamer > >(MCContext &)> CreateMCStreamer
Definition CodeGenPassBuilder.h:550
void addOptimizedRegAlloc(AddMachinePass &) const
addOptimizedRegAlloc - Add passes related to register allocation.
Definition CodeGenPassBuilder.h:1249
TMC & getTM() const
Definition CodeGenPassBuilder.h:360
void addISelPasses(AddIRPass &) const
High level function that adds all passes necessary to go from llvm IR representation to the MI repres...
Definition CodeGenPassBuilder.h:734
decltype(std::declval< PassT & >().run( std::declval< MachineFunction & >(), std::declval< MachineFunctionAnalysisManager & >())) is_machine_function_pass_t
Definition CodeGenPassBuilder.h:210
PassInstrumentationCallbacks * PIC
Definition CodeGenPassBuilder.h:358
void addMachineSSAOptimization(AddMachinePass &) const
Methods with trivial inline returns are convenient points in the common codegen pass pipeline where t...
Definition CodeGenPassBuilder.h:1117
CodeGenPassBuilder(TargetMachineT &TM, const CGPassBuilderOption &Opts, PassInstrumentationCallbacks *PIC)
Definition CodeGenPassBuilder.h:169
CGPassBuilderOption Opt
Definition CodeGenPassBuilder.h:357
Error addRegAssignmentOptimized(AddMachinePass &) const
Definition CodeGenPassBuilder.h:1216
void addCodeGenPrepare(AddIRPass &) const
Add pass to prepare the LLVM IR for code generation.
Definition CodeGenPassBuilder.h:873
Error addMachinePasses(AddMachinePass &) const
Add the complete, standard set of LLVM CodeGen passes.
Definition CodeGenPassBuilder.h:1004
void addISelPrepare(AddIRPass &) const
Add common passes that perform LLVM IR to IR transforms in preparation for instruction selection.
Definition CodeGenPassBuilder.h:884
void disablePass()
Allow the target to disable a specific pass by default.
Definition CodeGenPassBuilder.h:574
void addBlockPlacement(AddMachinePass &) const
Add standard basic block placement passes.
Definition CodeGenPassBuilder.h:1334
Error addInstSelector(AddMachinePass &) const
addInstSelector - This method should install an instruction selector pass, which converts from LLVM c...
Definition CodeGenPassBuilder.h:379
void addTargetRegisterAllocator(AddMachinePass &, bool Optimized) const
Utilities for targets to add passes to the pass manager.
Definition CodeGenPassBuilder.h:1171
void addPreEmitPass2(AddMachinePass &) const
Targets may add passes immediately before machine code is emitted in this callback.
Definition CodeGenPassBuilder.h:434
void addPostRewrite(AddMachinePass &) const
Add passes to be run immediately after virtual registers are rewritten to physical registers.
Definition CodeGenPassBuilder.h:415
void addPreRegBankSelect(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before the register ban...
Definition CodeGenPassBuilder.h:465
void addPreEmitPass(AddMachinePass &) const
This pass may be implemented by targets that want to run passes immediately before machine code is em...
Definition CodeGenPassBuilder.h:427
Error addGlobalInstructionSelect(AddMachinePass &) const
This method should install a (global) instruction selector pass, which converts possibly generic inst...
Definition CodeGenPassBuilder.h:483
void addMachineLateOptimization(AddMachinePass &) const
Add passes that optimize machine instructions after register allocation.
Definition CodeGenPassBuilder.h:1313
void addIRPasses(AddIRPass &) const
Add common target configurable passes that perform LLVM IR to IR transforms following machine indepen...
Definition CodeGenPassBuilder.h:753
decltype(std::declval< PassT & >().run( std::declval< Module & >(), std::declval< ModuleAnalysisManager & >())) is_module_pass_t
Definition CodeGenPassBuilder.h:202
void addPreLegalizeMachineIR(AddMachinePass &) const
This method may be implemented by targets that want to run passes immediately before legalization.
Definition CodeGenPassBuilder.h:454
CodeGenOptLevel getOptLevel() const
Definition CodeGenPassBuilder.h:361
void addPassesToHandleExceptions(AddIRPass &) const
Add passes to lower exception handling for the code generator.
Definition CodeGenPassBuilder.h:826
PassInstrumentationCallbacks * getPassInstrumentationCallbacks() const
Definition CodeGenPassBuilder.h:196
bool reportDiagnosticWhenGlobalISelFallback() const
Check whether or not a diagnostic should be emitted when GlobalISel uses the fallback path.
Definition CodeGenPassBuilder.h:373
void addPreISel(AddIRPass &) const
{{@ For GlobalISel
Definition CodeGenPassBuilder.h:441
void addAsmPrinter(AddMachinePass &, CreateMCStreamer) const
Definition CodeGenPassBuilder.h:552
Lightweight error class with error context and mandatory checking.
static ErrorSuccess success()
Create a success value.
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.
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
LLVM_ABI StringRef getPassNameForClassName(StringRef ClassName)
Get the pass name for a given pass class name. Empty if no match found.
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.
#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.
ModuleToFunctionPassAdaptor createModuleToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
LLVM_ABI std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
@ SjLj
setjmp/longjmp based exceptions
@ ZOS
z/OS MVS Exception Handling.
@ None
No exception support.
@ AIX
AIX Exception Handling.
@ DwarfCFI
DWARF-like instruction based exceptions.
@ WinEH
Windows Exception Handling.
@ Wasm
WebAssembly Exception Handling.
PassManager< Loop, LoopAnalysisManager, LoopStandardAnalysisResults &, LPMUpdater & > LoopPassManager
The Loop pass manager.
ModuleToPostOrderCGSCCPassAdaptor createModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT &&Pass)
A function to deduce a function pass type and wrap it in the templated adaptor.
FunctionToLoopPassAdaptor createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA=false)
A function to deduce a loop pass type and wrap it in the templated adaptor.
CGSCCToFunctionPassAdaptor createCGSCCToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false, bool NoRerun=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
CodeGenFileType
These enums are meant to be passed into addPassesToEmitFile to indicate what type of file to emit,...
FunctionToMachineFunctionPassAdaptor createFunctionToMachineFunctionPassAdaptor(MachineFunctionPassT &&Pass)
PassManager< Module > ModulePassManager
Convenience typedef for a pass manager over modules.
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
FunctionAddr VTableAddr Count
CodeGenOptLevel
Code generation optimization level.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
Error make_error(ArgTs &&... Args)
Make a Error instance representing failure using the given error info type.
PassManager< Function > FunctionPassManager
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'.
PassManager< MachineFunction > MachineFunctionPassManager
Convenience typedef for a pass manager over functions.
LLVM_ABI void reportFatalUsageError(Error Err)
Report a fatal error that does not indicate a bug in LLVM.
Global function merging pass for new pass manager.
A utility pass template to force an analysis result to be available.