LLVM  16.0.0git
Passes.h
Go to the documentation of this file.
1 //===-- Passes.h - Target independent code generation passes ----*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines interfaces to access the target independent code generation
10 // passes provided by the LLVM backend.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CODEGEN_PASSES_H
15 #define LLVM_CODEGEN_PASSES_H
16 
17 #include "llvm/Support/CodeGen.h"
20 
21 #include <functional>
22 #include <string>
23 
24 namespace llvm {
25 
26 class FunctionPass;
27 class MachineFunction;
28 class MachineFunctionPass;
29 class ModulePass;
30 class Pass;
31 class TargetMachine;
32 class raw_ostream;
33 
34 } // End llvm namespace
35 
36 // List of target independent CodeGen pass IDs.
37 namespace llvm {
38 
39  /// AtomicExpandPass - At IR level this pass replace atomic instructions with
40  /// __atomic_* library calls, or target specific instruction which implement the
41  /// same semantics in a way which better fits the target backend.
42  FunctionPass *createAtomicExpandPass();
43 
44  /// createUnreachableBlockEliminationPass - The LLVM code generator does not
45  /// work well with unreachable basic blocks (what live ranges make sense for a
46  /// block that cannot be reached?). As such, a code generator should either
47  /// not instruction select unreachable blocks, or run this pass as its
48  /// last LLVM modifying pass to clean up blocks that are not reachable from
49  /// the entry block.
51 
52  /// createBasicBlockSections Pass - This pass assigns sections to machine
53  /// basic blocks and is enabled with -fbasic-block-sections.
54  MachineFunctionPass *createBasicBlockSectionsPass();
55 
56  /// createMachineFunctionSplitterPass - This pass splits machine functions
57  /// using profile information.
58  MachineFunctionPass *createMachineFunctionSplitterPass();
59 
60  /// MachineFunctionPrinter pass - This pass prints out the machine function to
61  /// the given stream as a debugging tool.
62  MachineFunctionPass *
63  createMachineFunctionPrinterPass(raw_ostream &OS,
64  const std::string &Banner ="");
65 
66  /// MIRPrinting pass - this pass prints out the LLVM IR into the given stream
67  /// using the MIR serialization format.
68  MachineFunctionPass *createPrintMIRPass(raw_ostream &OS);
69 
70  /// This pass resets a MachineFunction when it has the FailedISel property
71  /// as if it was just created.
72  /// If EmitFallbackDiag is true, the pass will emit a
73  /// DiagnosticInfoISelFallback for every MachineFunction it resets.
74  /// If AbortOnFailedISel is true, abort compilation instead of resetting.
75  MachineFunctionPass *createResetMachineFunctionPass(bool EmitFallbackDiag,
76  bool AbortOnFailedISel);
77 
78  /// createCodeGenPreparePass - Transform the code to expose more pattern
79  /// matching during instruction selection.
80  FunctionPass *createCodeGenPreparePass();
81 
82  /// This pass implements generation of target-specific intrinsics to support
83  /// handling of complex number arithmetic
84  FunctionPass *createComplexDeinterleavingPass(const TargetMachine *TM);
85 
86  /// AtomicExpandID -- Lowers atomic operations in terms of either cmpxchg
87  /// load-linked/store-conditional loops.
88  extern char &AtomicExpandID;
89 
90  /// MachineLoopInfo - This pass is a loop analysis pass.
91  extern char &MachineLoopInfoID;
92 
93  /// MachineDominators - This pass is a machine dominators analysis pass.
94  extern char &MachineDominatorsID;
95 
96  /// MachineDominanaceFrontier - This pass is a machine dominators analysis.
97  extern char &MachineDominanceFrontierID;
98 
99  /// MachineRegionInfo - This pass computes SESE regions for machine functions.
100  extern char &MachineRegionInfoPassID;
101 
102  /// EdgeBundles analysis - Bundle machine CFG edges.
103  extern char &EdgeBundlesID;
104 
105  /// LiveVariables pass - This pass computes the set of blocks in which each
106  /// variable is life and sets machine operand kill flags.
107  extern char &LiveVariablesID;
108 
109  /// PHIElimination - This pass eliminates machine instruction PHI nodes
110  /// by inserting copy instructions. This destroys SSA information, but is the
111  /// desired input for some register allocators. This pass is "required" by
112  /// these register allocator like this: AU.addRequiredID(PHIEliminationID);
113  extern char &PHIEliminationID;
114 
115  /// LiveIntervals - This analysis keeps track of the live ranges of virtual
116  /// and physical registers.
117  extern char &LiveIntervalsID;
118 
119  /// LiveStacks pass. An analysis keeping track of the liveness of stack slots.
120  extern char &LiveStacksID;
121 
122  /// TwoAddressInstruction - This pass reduces two-address instructions to
123  /// use two operands. This destroys SSA information but it is desired by
124  /// register allocators.
125  extern char &TwoAddressInstructionPassID;
126 
127  /// ProcessImpicitDefs pass - This pass removes IMPLICIT_DEFs.
128  extern char &ProcessImplicitDefsID;
129 
130  /// RegisterCoalescer - This pass merges live ranges to eliminate copies.
131  extern char &RegisterCoalescerID;
132 
133  /// MachineScheduler - This pass schedules machine instructions.
134  extern char &MachineSchedulerID;
135 
136  /// PostMachineScheduler - This pass schedules machine instructions postRA.
137  extern char &PostMachineSchedulerID;
138 
139  /// SpillPlacement analysis. Suggest optimal placement of spill code between
140  /// basic blocks.
141  extern char &SpillPlacementID;
142 
143  /// ShrinkWrap pass. Look for the best place to insert save and restore
144  // instruction and update the MachineFunctionInfo with that information.
145  extern char &ShrinkWrapID;
146 
147  /// LiveRangeShrink pass. Move instruction close to its definition to shrink
148  /// the definition's live range.
149  extern char &LiveRangeShrinkID;
150 
151  /// Greedy register allocator.
152  extern char &RAGreedyID;
153 
154  /// Basic register allocator.
155  extern char &RABasicID;
156 
157  /// VirtRegRewriter pass. Rewrite virtual registers to physical registers as
158  /// assigned in VirtRegMap.
159  extern char &VirtRegRewriterID;
160  FunctionPass *createVirtRegRewriter(bool ClearVirtRegs = true);
161 
162  /// UnreachableMachineBlockElimination - This pass removes unreachable
163  /// machine basic blocks.
164  extern char &UnreachableMachineBlockElimID;
165 
166  /// DeadMachineInstructionElim - This pass removes dead machine instructions.
167  extern char &DeadMachineInstructionElimID;
168 
169  /// This pass adds dead/undef flags after analyzing subregister lanes.
170  extern char &DetectDeadLanesID;
171 
172  /// This pass perform post-ra machine sink for COPY instructions.
173  extern char &PostRAMachineSinkingID;
174 
175  /// This pass adds flow sensitive discriminators.
176  extern char &MIRAddFSDiscriminatorsID;
177 
178  /// This pass reads flow sensitive profile.
179  extern char &MIRProfileLoaderPassID;
180 
181  /// FastRegisterAllocation Pass - This pass register allocates as fast as
182  /// possible. It is best suited for debug code where live ranges are short.
183  ///
184  FunctionPass *createFastRegisterAllocator();
186  bool ClearVirtRegs);
187 
188  /// BasicRegisterAllocation Pass - This pass implements a degenerate global
189  /// register allocator using the basic regalloc framework.
190  ///
191  FunctionPass *createBasicRegisterAllocator();
193 
194  /// Greedy register allocation pass - This pass implements a global register
195  /// allocator for optimized builds.
196  ///
197  FunctionPass *createGreedyRegisterAllocator();
199 
200  /// PBQPRegisterAllocation Pass - This pass implements the Partitioned Boolean
201  /// Quadratic Prograaming (PBQP) based register allocator.
202  ///
203  FunctionPass *createDefaultPBQPRegisterAllocator();
204 
205  /// PrologEpilogCodeInserter - This pass inserts prolog and epilog code,
206  /// and eliminates abstract frame references.
207  extern char &PrologEpilogCodeInserterID;
208  MachineFunctionPass *createPrologEpilogInserterPass();
209 
210  /// ExpandPostRAPseudos - This pass expands pseudo instructions after
211  /// register allocation.
212  extern char &ExpandPostRAPseudosID;
213 
214  /// PostRAHazardRecognizer - This pass runs the post-ra hazard
215  /// recognizer.
216  extern char &PostRAHazardRecognizerID;
217 
218  /// PostRAScheduler - This pass performs post register allocation
219  /// scheduling.
220  extern char &PostRASchedulerID;
221 
222  /// BranchFolding - This pass performs machine code CFG based
223  /// optimizations to delete branches to branches, eliminate branches to
224  /// successor blocks (creating fall throughs), and eliminating branches over
225  /// branches.
226  extern char &BranchFolderPassID;
227 
228  /// BranchRelaxation - This pass replaces branches that need to jump further
229  /// than is supported by a branch instruction.
230  extern char &BranchRelaxationPassID;
231 
232  /// MachineFunctionPrinterPass - This pass prints out MachineInstr's.
233  extern char &MachineFunctionPrinterPassID;
234 
235  /// MIRPrintingPass - this pass prints out the LLVM IR using the MIR
236  /// serialization format.
237  extern char &MIRPrintingPassID;
238 
239  /// TailDuplicate - Duplicate blocks with unconditional branches
240  /// into tails of their predecessors.
241  extern char &TailDuplicateID;
242 
243  /// Duplicate blocks with unconditional branches into tails of their
244  /// predecessors. Variant that works before register allocation.
245  extern char &EarlyTailDuplicateID;
246 
247  /// MachineTraceMetrics - This pass computes critical path and CPU resource
248  /// usage in an ensemble of traces.
249  extern char &MachineTraceMetricsID;
250 
251  /// EarlyIfConverter - This pass performs if-conversion on SSA form by
252  /// inserting cmov instructions.
253  extern char &EarlyIfConverterID;
254 
255  /// EarlyIfPredicator - This pass performs if-conversion on SSA form by
256  /// predicating if/else block and insert select at the join point.
257  extern char &EarlyIfPredicatorID;
258 
259  /// This pass performs instruction combining using trace metrics to estimate
260  /// critical-path and resource depth.
261  extern char &MachineCombinerID;
262 
263  /// StackSlotColoring - This pass performs stack coloring and merging.
264  /// It merges disjoint allocas to reduce the stack size.
265  extern char &StackColoringID;
266 
267  /// IfConverter - This pass performs machine code if conversion.
268  extern char &IfConverterID;
269 
270  FunctionPass *createIfConverter(
271  std::function<bool(const MachineFunction &)> Ftor);
272 
273  /// MachineBlockPlacement - This pass places basic blocks based on branch
274  /// probabilities.
275  extern char &MachineBlockPlacementID;
276 
277  /// MachineBlockPlacementStats - This pass collects statistics about the
278  /// basic block placement using branch probabilities and block frequency
279  /// information.
280  extern char &MachineBlockPlacementStatsID;
281 
282  /// GCLowering Pass - Used by gc.root to perform its default lowering
283  /// operations.
284  FunctionPass *createGCLoweringPass();
285 
286  /// GCLowering Pass - Used by gc.root to perform its default lowering
287  /// operations.
288  extern char &GCLoweringID;
289 
290  /// ShadowStackGCLowering - Implements the custom lowering mechanism
291  /// used by the shadow stack GC. Only runs on functions which opt in to
292  /// the shadow stack collector.
293  FunctionPass *createShadowStackGCLoweringPass();
294 
295  /// ShadowStackGCLowering - Implements the custom lowering mechanism
296  /// used by the shadow stack GC.
297  extern char &ShadowStackGCLoweringID;
298 
299  /// GCMachineCodeAnalysis - Target-independent pass to mark safe points
300  /// in machine code. Must be added very late during code generation, just
301  /// prior to output, and importantly after all CFG transformations (such as
302  /// branch folding).
303  extern char &GCMachineCodeAnalysisID;
304 
305  /// Creates a pass to print GC metadata.
306  ///
307  FunctionPass *createGCInfoPrinter(raw_ostream &OS);
308 
309  /// MachineCSE - This pass performs global CSE on machine instructions.
310  extern char &MachineCSEID;
311 
312  /// MIRCanonicalizer - This pass canonicalizes MIR by renaming vregs
313  /// according to the semantics of the instruction as well as hoists
314  /// code.
315  extern char &MIRCanonicalizerID;
316 
317  /// ImplicitNullChecks - This pass folds null pointer checks into nearby
318  /// memory operations.
319  extern char &ImplicitNullChecksID;
320 
321  /// This pass performs loop invariant code motion on machine instructions.
322  extern char &MachineLICMID;
323 
324  /// This pass performs loop invariant code motion on machine instructions.
325  /// This variant works before register allocation. \see MachineLICMID.
326  extern char &EarlyMachineLICMID;
327 
328  /// MachineSinking - This pass performs sinking on machine instructions.
329  extern char &MachineSinkingID;
330 
331  /// MachineCopyPropagation - This pass performs copy propagation on
332  /// machine instructions.
333  extern char &MachineCopyPropagationID;
334 
335  MachineFunctionPass *createMachineCopyPropagationPass(bool UseCopyInstr);
336 
337  /// MachineLateInstrsCleanup - This pass removes redundant identical
338  /// instructions after register allocation and rematerialization.
339  extern char &MachineLateInstrsCleanupID;
340 
341  /// PeepholeOptimizer - This pass performs peephole optimizations -
342  /// like extension and comparison eliminations.
343  extern char &PeepholeOptimizerID;
344 
345  /// OptimizePHIs - This pass optimizes machine instruction PHIs
346  /// to take advantage of opportunities created during DAG legalization.
347  extern char &OptimizePHIsID;
348 
349  /// StackSlotColoring - This pass performs stack slot coloring.
350  extern char &StackSlotColoringID;
351 
352  /// This pass lays out funclets contiguously.
353  extern char &FuncletLayoutID;
354 
355  /// This pass inserts the XRay instrumentation sleds if they are supported by
356  /// the target platform.
357  extern char &XRayInstrumentationID;
358 
359  /// This pass inserts FEntry calls
360  extern char &FEntryInserterID;
361 
362  /// This pass implements the "patchable-function" attribute.
363  extern char &PatchableFunctionID;
364 
365  /// createStackProtectorPass - This pass adds stack protectors to functions.
366  ///
367  FunctionPass *createStackProtectorPass();
368 
369  /// createMachineVerifierPass - This pass verifies cenerated machine code
370  /// instructions for correctness.
371  ///
372  FunctionPass *createMachineVerifierPass(const std::string& Banner);
373 
374  /// createDwarfEHPass - This pass mulches exception handling code into a form
375  /// adapted to code generation. Required if using dwarf exception handling.
376  FunctionPass *createDwarfEHPass(CodeGenOpt::Level OptLevel);
377 
378  /// createWinEHPass - Prepares personality functions used by MSVC on Windows,
379  /// in addition to the Itanium LSDA based personalities.
380  FunctionPass *createWinEHPass(bool DemoteCatchSwitchPHIOnly = false);
381 
382  /// createSjLjEHPreparePass - This pass adapts exception handling code to use
383  /// the GCC-style builtin setjmp/longjmp (sjlj) to handling EH control flow.
384  ///
385  FunctionPass *createSjLjEHPreparePass(const TargetMachine *TM);
386 
387  /// createWasmEHPass - This pass adapts exception handling code to use
388  /// WebAssembly's exception handling scheme.
389  FunctionPass *createWasmEHPass();
390 
391  /// LocalStackSlotAllocation - This pass assigns local frame indices to stack
392  /// slots relative to one another and allocates base registers to access them
393  /// when it is estimated by the target to be out of range of normal frame
394  /// pointer or stack pointer index addressing.
395  extern char &LocalStackSlotAllocationID;
396 
397  /// This pass expands pseudo-instructions, reserves registers and adjusts
398  /// machine frame information.
399  extern char &FinalizeISelID;
400 
401  /// UnpackMachineBundles - This pass unpack machine instruction bundles.
402  extern char &UnpackMachineBundlesID;
403 
404  FunctionPass *
405  createUnpackMachineBundles(std::function<bool(const MachineFunction &)> Ftor);
406 
407  /// FinalizeMachineBundles - This pass finalize machine instruction
408  /// bundles (created earlier, e.g. during pre-RA scheduling).
409  extern char &FinalizeMachineBundlesID;
410 
411  /// StackMapLiveness - This pass analyses the register live-out set of
412  /// stackmap/patchpoint intrinsics and attaches the calculated information to
413  /// the intrinsic for later emission to the StackMap.
414  extern char &StackMapLivenessID;
415 
416  // MachineSanitizerBinaryMetadata - appends/finalizes sanitizer binary
417  // metadata after llvm SanitizerBinaryMetadata pass.
419 
420  /// RemoveRedundantDebugValues pass.
421  extern char &RemoveRedundantDebugValuesID;
422 
423  /// MachineCFGPrinter pass.
424  extern char &MachineCFGPrinterID;
425 
426  /// LiveDebugValues pass
427  extern char &LiveDebugValuesID;
428 
429  /// createJumpInstrTables - This pass creates jump-instruction tables.
430  ModulePass *createJumpInstrTablesPass();
431 
432  /// InterleavedAccess Pass - This pass identifies and matches interleaved
433  /// memory accesses to target specific intrinsics.
434  ///
435  FunctionPass *createInterleavedAccessPass();
436 
437  /// InterleavedLoadCombines Pass - This pass identifies interleaved loads and
438  /// combines them into wide loads detectable by InterleavedAccessPass
439  ///
440  FunctionPass *createInterleavedLoadCombinePass();
441 
442  /// LowerEmuTLS - This pass generates __emutls_[vt].xyz variables for all
443  /// TLS variables for the emulated TLS model.
444  ///
445  ModulePass *createLowerEmuTLSPass();
446 
447  /// This pass lowers the \@llvm.load.relative and \@llvm.objc.* intrinsics to
448  /// instructions. This is unsafe to do earlier because a pass may combine the
449  /// constant initializer into the load, which may result in an overflowing
450  /// evaluation.
452 
453  /// GlobalMerge - This pass merges internal (by default) globals into structs
454  /// to enable reuse of a base pointer by indexed addressing modes.
455  /// It can also be configured to focus on size optimizations only.
456  ///
457  Pass *createGlobalMergePass(const TargetMachine *TM, unsigned MaximalOffset,
458  bool OnlyOptimizeForSize = false,
459  bool MergeExternalByDefault = false);
460 
461  /// This pass splits the stack into a safe stack and an unsafe stack to
462  /// protect against stack-based overflow vulnerabilities.
463  FunctionPass *createSafeStackPass();
464 
465  /// This pass detects subregister lanes in a virtual register that are used
466  /// independently of other lanes and splits them into separate virtual
467  /// registers.
468  extern char &RenameIndependentSubregsID;
469 
470  /// This pass is executed POST-RA to collect which physical registers are
471  /// preserved by given machine function.
472  FunctionPass *createRegUsageInfoCollector();
473 
474  /// Return a MachineFunction pass that identifies call sites
475  /// and propagates register usage information of callee to caller
476  /// if available with PysicalRegisterUsageInfo pass.
477  FunctionPass *createRegUsageInfoPropPass();
478 
479  /// This pass performs software pipelining on machine instructions.
480  extern char &MachinePipelinerID;
481 
482  /// This pass frees the memory occupied by the MachineFunction.
483  FunctionPass *createFreeMachineFunctionPass();
484 
485  /// This pass performs outlining on machine instructions directly before
486  /// printing assembly.
487  ModulePass *createMachineOutlinerPass(bool RunOnAllFunctions = true);
488 
489  /// This pass expands the experimental reduction intrinsics into sequences of
490  /// shuffles.
491  FunctionPass *createExpandReductionsPass();
492 
493  // This pass replaces intrinsics operating on vector operands with calls to
494  // the corresponding function in a vector library (e.g., SVML, libmvec).
495  FunctionPass *createReplaceWithVeclibLegacyPass();
496 
497  /// This pass expands the vector predication intrinsics into unpredicated
498  /// instructions with selects or just the explicit vector length into the
499  /// predicate mask.
500  FunctionPass *createExpandVectorPredicationPass();
501 
502  // Expands large div/rem instructions.
503  FunctionPass *createExpandLargeDivRemPass();
504 
505  // Expands large div/rem instructions.
506  FunctionPass *createExpandLargeFpConvertPass();
507 
508  // This pass expands memcmp() to load/stores.
509  FunctionPass *createExpandMemCmpPass();
510 
511  /// Creates Break False Dependencies pass. \see BreakFalseDeps.cpp
512  FunctionPass *createBreakFalseDeps();
513 
514  // This pass expands indirectbr instructions.
515  FunctionPass *createIndirectBrExpandPass();
516 
517  /// Creates CFI Fixup pass. \see CFIFixup.cpp
518  FunctionPass *createCFIFixup();
519 
520  /// Creates CFI Instruction Inserter pass. \see CFIInstrInserter.cpp
521  FunctionPass *createCFIInstrInserter();
522 
523  /// Creates CFGuard longjmp target identification pass.
524  /// \see CFGuardLongjmp.cpp
525  FunctionPass *createCFGuardLongjmpPass();
526 
527  /// Creates EHContGuard catchret target identification pass.
528  /// \see EHContGuardCatchret.cpp
529  FunctionPass *createEHContGuardCatchretPass();
530 
531  /// Create Hardware Loop pass. \see HardwareLoops.cpp
532  FunctionPass *createHardwareLoopsPass();
533 
534  /// This pass inserts pseudo probe annotation for callsite profiling.
535  FunctionPass *createPseudoProbeInserter();
536 
537  /// Create IR Type Promotion pass. \see TypePromotion.cpp
538  FunctionPass *createTypePromotionPass();
539 
540  /// Add Flow Sensitive Discriminators. PassNum specifies the
541  /// sequence number of this pass (starting from 1).
542  FunctionPass *
544 
545  /// Read Flow Sensitive Profile.
546  FunctionPass *createMIRProfileLoaderPass(std::string File,
547  std::string RemappingFile,
549 
550  /// Creates MIR Debugify pass. \see MachineDebugify.cpp
551  ModulePass *createDebugifyMachineModulePass();
552 
553  /// Creates MIR Strip Debug pass. \see MachineStripDebug.cpp
554  /// If OnlyDebugified is true then it will only strip debug info if it was
555  /// added by a Debugify pass. The module will be left unchanged if the debug
556  /// info was generated by another source such as clang.
557  ModulePass *createStripDebugMachineModulePass(bool OnlyDebugified);
558 
559  /// Creates MIR Check Debug pass. \see MachineCheckDebugify.cpp
560  ModulePass *createCheckDebugMachineModulePass();
561 
562  /// The pass fixups statepoint machine instruction to replace usage of
563  /// caller saved registers with stack slots.
564  extern char &FixupStatepointCallerSavedID;
565 
566  /// The pass transforms load/store <256 x i32> to AMX load/store intrinsics
567  /// or split the data to two <128 x i32>.
568  FunctionPass *createX86LowerAMXTypePass();
569 
570  /// The pass insert tile config intrinsics for AMX fast register allocation.
571  FunctionPass *createX86PreAMXConfigPass();
572 
573  /// The pass transforms amx intrinsics to scalar operation if the function has
574  /// optnone attribute or it is O0.
575  FunctionPass *createX86LowerAMXIntrinsicsPass();
576 
577  /// When learning an eviction policy, extract score(reward) information,
578  /// otherwise this does nothing
579  FunctionPass *createRegAllocScoringPass();
580 
581  /// JMC instrument pass.
582  ModulePass *createJMCInstrumenterPass();
583 
584  /// This pass converts conditional moves to conditional jumps when profitable.
585  FunctionPass *createSelectOptimizePass();
586 } // End llvm namespace
587 
588 #endif
llvm::createX86LowerAMXTypePass
FunctionPass * createX86LowerAMXTypePass()
The pass transforms load/store <256 x i32> to AMX load/store intrinsics or split the data to two <128...
Definition: X86LowerAMXType.cpp:1273
llvm::createJMCInstrumenterPass
ModulePass * createJMCInstrumenterPass()
JMC instrument pass.
llvm::createFastRegisterAllocator
FunctionPass * createFastRegisterAllocator()
FastRegisterAllocation Pass - This pass register allocates as fast as possible.
Definition: RegAllocFast.cpp:1608
llvm::createCheckDebugMachineModulePass
ModulePass * createCheckDebugMachineModulePass()
Creates MIR Check Debug pass.
Definition: MachineCheckDebugify.cpp:124
llvm::OptimizePHIsID
char & OptimizePHIsID
OptimizePHIs - This pass optimizes machine instruction PHIs to take advantage of opportunities create...
Definition: OptimizePHIs.cpp:68
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::createGreedyRegisterAllocator
FunctionPass * createGreedyRegisterAllocator()
Greedy register allocation pass - This pass implements a global register allocator for optimized buil...
Definition: RegAllocGreedy.cpp:186
llvm::LiveStacksID
char & LiveStacksID
LiveStacks pass. An analysis keeping track of the liveness of stack slots.
Definition: LiveStacks.cpp:30
llvm::createMachineCopyPropagationPass
MachineFunctionPass * createMachineCopyPropagationPass(bool UseCopyInstr)
Definition: MachineCopyPropagation.cpp:1030
Pass
print lazy value Lazy Value Info Printer Pass
Definition: LazyValueInfo.cpp:1999
RegAllocCommon.h
llvm::createMachineFunctionSplitterPass
MachineFunctionPass * createMachineFunctionSplitterPass()
createMachineFunctionSplitterPass - This pass splits machine functions using profile information.
llvm::PeepholeOptimizerID
char & PeepholeOptimizerID
PeepholeOptimizer - This pass performs peephole optimizations - like extension and comparison elimina...
Definition: PeepholeOptimizer.cpp:443
llvm::RABasicID
char & RABasicID
Basic register allocator.
Definition: RegAllocBasic.cpp:128
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::createDefaultPBQPRegisterAllocator
FunctionPass * createDefaultPBQPRegisterAllocator()
PBQPRegisterAllocation Pass - This pass implements the Partitioned Boolean Quadratic Prograaming (PBQ...
Definition: RegAllocPBQP.cpp:952
llvm::PHIEliminationID
char & PHIEliminationID
PHIElimination - This pass eliminates machine instruction PHI nodes by inserting copy instructions.
Definition: PHIElimination.cpp:128
llvm::MachinePipelinerID
char & MachinePipelinerID
This pass performs software pipelining on machine instructions.
Definition: MachinePipeliner.cpp:198
llvm::createVirtRegRewriter
FunctionPass * createVirtRegRewriter(bool ClearVirtRegs=true)
Definition: VirtRegMap.cpp:646
llvm::UnpackMachineBundlesID
char & UnpackMachineBundlesID
UnpackMachineBundles - This pass unpack machine instruction bundles.
Definition: MachineInstrBundle.cpp:42
llvm::ExpandPostRAPseudosID
char & ExpandPostRAPseudosID
ExpandPostRAPseudos - This pass expands pseudo instructions after register allocation.
Definition: ExpandPostRAPseudos.cpp:57
llvm::createPrologEpilogInserterPass
MachineFunctionPass * createPrologEpilogInserterPass()
Definition: PrologEpilogInserter.cpp:161
Discriminator.h
llvm::ShadowStackGCLoweringID
char & ShadowStackGCLoweringID
ShadowStackGCLowering - Implements the custom lowering mechanism used by the shadow stack GC.
Definition: ShadowStackGCLowering.cpp:92
llvm::LocalStackSlotAllocationID
char & LocalStackSlotAllocationID
LocalStackSlotAllocation - This pass assigns local frame indices to stack slots relative to one anoth...
Definition: LocalStackSlotAllocation.cpp:108
llvm::createGCInfoPrinter
FunctionPass * createGCInfoPrinter(raw_ostream &OS)
Creates a pass to print GC metadata.
Definition: GCMetadata.cpp:89
llvm::MIRAddFSDiscriminatorsID
char & MIRAddFSDiscriminatorsID
This pass adds flow sensitive discriminators.
llvm::SpillPlacementID
char & SpillPlacementID
SpillPlacement analysis.
Definition: SpillPlacement.cpp:50
llvm::StackSlotColoringID
char & StackSlotColoringID
StackSlotColoring - This pass performs stack slot coloring.
Definition: StackSlotColoring.cpp:131
llvm::MachineCopyPropagationID
char & MachineCopyPropagationID
MachineCopyPropagation - This pass performs copy propagation on machine instructions.
Definition: MachineCopyPropagation.cpp:355
llvm::TwoAddressInstructionPassID
char & TwoAddressInstructionPassID
TwoAddressInstruction - This pass reduces two-address instructions to use two operands.
Definition: TwoAddressInstructionPass.cpp:193
llvm::MachineLICMID
char & MachineLICMID
This pass performs loop invariant code motion on machine instructions.
Definition: MachineLICM.cpp:296
llvm::createUnreachableBlockEliminationPass
FunctionPass * createUnreachableBlockEliminationPass()
createUnreachableBlockEliminationPass - The LLVM code generator does not work well with unreachable b...
llvm::MIRCanonicalizerID
char & MIRCanonicalizerID
MIRCanonicalizer - This pass canonicalizes MIR by renaming vregs according to the semantics of the in...
Definition: MIRCanonicalizerPass.cpp:68
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::createComplexDeinterleavingPass
FunctionPass * createComplexDeinterleavingPass(const TargetMachine *TM)
This pass implements generation of target-specific intrinsics to support handling of complex number a...
Definition: ComplexDeinterleavingPass.cpp:313
llvm::createExpandMemCmpPass
FunctionPass * createExpandMemCmpPass()
Definition: ExpandMemCmp.cpp:920
llvm::sampleprof::FSDiscriminatorPass
FSDiscriminatorPass
Definition: Discriminator.h:57
llvm::EdgeBundlesID
char & EdgeBundlesID
EdgeBundles analysis - Bundle machine CFG edges.
llvm::LiveDebugValuesID
char & LiveDebugValuesID
LiveDebugValues pass.
Definition: LiveDebugValues.cpp:95
llvm::createLowerEmuTLSPass
ModulePass * createLowerEmuTLSPass()
LowerEmuTLS - This pass generates __emutls_[vt].xyz variables for all TLS variables for the emulated ...
llvm::createDwarfEHPass
FunctionPass * createDwarfEHPass(CodeGenOpt::Level OptLevel)
createDwarfEHPass - This pass mulches exception handling code into a form adapted to code generation.
Definition: DwarfEHPrepare.cpp:378
llvm::createEHContGuardCatchretPass
FunctionPass * createEHContGuardCatchretPass()
Creates EHContGuard catchret target identification pass.
llvm::PrologEpilogCodeInserterID
char & PrologEpilogCodeInserterID
PrologEpilogCodeInserter - This pass inserts prolog and epilog code, and eliminates abstract frame re...
Definition: PrologEpilogInserter.cpp:150
llvm::FEntryInserterID
char & FEntryInserterID
This pass inserts FEntry calls.
Definition: FEntryInserter.cpp:48
llvm::PostRAHazardRecognizerID
char & PostRAHazardRecognizerID
PostRAHazardRecognizer - This pass runs the post-ra hazard recognizer.
Definition: PostRAHazardRecognizer.cpp:61
llvm::createPreISelIntrinsicLoweringPass
ModulePass * createPreISelIntrinsicLoweringPass()
This pass lowers the @llvm.load.relative and @llvm.objc.
llvm::FuncletLayoutID
char & FuncletLayoutID
This pass lays out funclets contiguously.
Definition: FuncletLayout.cpp:39
llvm::GCMachineCodeAnalysisID
char & GCMachineCodeAnalysisID
GCMachineCodeAnalysis - Target-independent pass to mark safe points in machine code.
Definition: GCRootLowering.cpp:238
llvm::createReplaceWithVeclibLegacyPass
FunctionPass * createReplaceWithVeclibLegacyPass()
Definition: ReplaceWithVeclib.cpp:251
llvm::MachineTraceMetricsID
char & MachineTraceMetricsID
MachineTraceMetrics - This pass computes critical path and CPU resource usage in an ensemble of trace...
Definition: MachineTraceMetrics.cpp:46
llvm::createResetMachineFunctionPass
MachineFunctionPass * createResetMachineFunctionPass(bool EmitFallbackDiag, bool AbortOnFailedISel)
This pass resets a MachineFunction when it has the FailedISel property as if it was just created.
llvm::RegisterCoalescerID
char & RegisterCoalescerID
RegisterCoalescer - This pass merges live ranges to eliminate copies.
Definition: RegisterCoalescer.cpp:405
llvm::EarlyIfConverterID
char & EarlyIfConverterID
EarlyIfConverter - This pass performs if-conversion on SSA form by inserting cmov instructions.
Definition: EarlyIfConversion.cpp:782
llvm::createAtomicExpandPass
FunctionPass * createAtomicExpandPass()
AtomicExpandPass - At IR level this pass replace atomic instructions with __atomic_* library calls,...
llvm::createMIRProfileLoaderPass
FunctionPass * createMIRProfileLoaderPass(std::string File, std::string RemappingFile, sampleprof::FSDiscriminatorPass P)
Read Flow Sensitive Profile.
Definition: MIRSampleProfile.cpp:75
llvm::createX86LowerAMXIntrinsicsPass
FunctionPass * createX86LowerAMXIntrinsicsPass()
The pass transforms amx intrinsics to scalar operation if the function has optnone attribute or it is...
Definition: X86LowerAMXIntrinsics.cpp:679
llvm::createCFIInstrInserter
FunctionPass * createCFIInstrInserter()
Creates CFI Instruction Inserter pass.
llvm::createRegAllocScoringPass
FunctionPass * createRegAllocScoringPass()
When learning an eviction policy, extract score(reward) information, otherwise this does nothing.
Definition: MLRegallocEvictAdvisor.cpp:111
llvm::AtomicExpandID
char & AtomicExpandID
AtomicExpandID – Lowers atomic operations in terms of either cmpxchg load-linked/store-conditional lo...
Definition: AtomicExpandPass.cpp:143
llvm::StackMapLivenessID
char & StackMapLivenessID
StackMapLiveness - This pass analyses the register live-out set of stackmap/patchpoint intrinsics and...
Definition: StackMapLivenessAnalysis.cpp:86
llvm::createShadowStackGCLoweringPass
FunctionPass * createShadowStackGCLoweringPass()
ShadowStackGCLowering - Implements the custom lowering mechanism used by the shadow stack GC.
Definition: ShadowStackGCLowering.cpp:101
llvm::createMachineOutlinerPass
ModulePass * createMachineOutlinerPass(bool RunOnAllFunctions=true)
This pass performs outlining on machine instructions directly before printing assembly.
Definition: MachineOutliner.cpp:458
llvm::createCFIFixup
FunctionPass * createCFIFixup()
Creates CFI Fixup pass.
llvm::createMachineFunctionPrinterPass
MachineFunctionPass * createMachineFunctionPrinterPass(raw_ostream &OS, const std::string &Banner="")
MachineFunctionPrinter pass - This pass prints out the machine function to the given stream as a debu...
llvm::EarlyTailDuplicateID
char & EarlyTailDuplicateID
Duplicate blocks with unconditional branches into tails of their predecessors.
Definition: TailDuplication.cpp:77
llvm::VirtRegRewriterID
char & VirtRegRewriterID
VirtRegRewriter pass.
Definition: VirtRegMap.cpp:227
llvm::MachineLoopInfoID
char & MachineLoopInfoID
MachineLoopInfo - This pass is a loop analysis pass.
Definition: MachineLoopInfo.cpp:43
llvm::GCLoweringID
char & GCLoweringID
GCLowering Pass - Used by gc.root to perform its default lowering operations.
Definition: GCRootLowering.cpp:85
llvm::StackColoringID
char & StackColoringID
StackSlotColoring - This pass performs stack coloring and merging.
Definition: StackColoring.cpp:549
llvm::MIRProfileLoaderPassID
char & MIRProfileLoaderPassID
This pass reads flow sensitive profile.
Definition: MIRSampleProfile.cpp:73
llvm::RAGreedyID
char & RAGreedyID
Greedy register allocator.
Definition: RegAllocGreedy.cpp:148
llvm::MachineSinkingID
char & MachineSinkingID
MachineSinking - This pass performs sinking on machine instructions.
Definition: MachineSink.cpp:260
llvm::DetectDeadLanesID
char & DetectDeadLanesID
This pass adds dead/undef flags after analyzing subregister lanes.
Definition: DetectDeadLanes.cpp:125
llvm::createPrintMIRPass
MachineFunctionPass * createPrintMIRPass(raw_ostream &OS)
MIRPrinting pass - this pass prints out the LLVM IR into the given stream using the MIR serialization...
Definition: MIRPrintingPass.cpp:66
llvm::FinalizeMachineBundlesID
char & FinalizeMachineBundlesID
FinalizeMachineBundles - This pass finalize machine instruction bundles (created earlier,...
Definition: MachineInstrBundle.cpp:99
llvm::RegClassFilterFunc
std::function< bool(const TargetRegisterInfo &TRI, const TargetRegisterClass &RC)> RegClassFilterFunc
Definition: RegAllocCommon.h:17
llvm::createUnpackMachineBundles
FunctionPass * createUnpackMachineBundles(std::function< bool(const MachineFunction &)> Ftor)
Definition: MachineInstrBundle.cpp:81
llvm::createRegUsageInfoPropPass
FunctionPass * createRegUsageInfoPropPass()
Return a MachineFunction pass that identifies call sites and propagates register usage information of...
Definition: RegUsageInfoPropagate.cpp:152
llvm::createMachineVerifierPass
FunctionPass * createMachineVerifierPass(const std::string &Banner)
createMachineVerifierPass - This pass verifies cenerated machine code instructions for correctness.
llvm::LiveRangeShrinkID
char & LiveRangeShrinkID
LiveRangeShrink pass.
Definition: LiveRangeShrink.cpp:64
llvm::LiveVariablesID
char & LiveVariablesID
LiveVariables pass - This pass computes the set of blocks in which each variable is life and sets mac...
Definition: LiveVariables.cpp:45
llvm::MachineCSEID
char & MachineCSEID
MachineCSE - This pass performs global CSE on machine instructions.
Definition: MachineCSE.cpp:162
llvm::FinalizeISelID
char & FinalizeISelID
This pass expands pseudo-instructions, reserves registers and adjusts machine frame information.
Definition: FinalizeISel.cpp:42
llvm::createExpandReductionsPass
FunctionPass * createExpandReductionsPass()
This pass expands the experimental reduction intrinsics into sequences of shuffles.
Definition: ExpandReductions.cpp:200
llvm::createTypePromotionPass
FunctionPass * createTypePromotionPass()
Create IR Type Promotion pass.
Definition: TypePromotion.cpp:1014
llvm::createGCLoweringPass
FunctionPass * createGCLoweringPass()
GCLowering Pass - Used by gc.root to perform its default lowering operations.
llvm::createExpandVectorPredicationPass
FunctionPass * createExpandVectorPredicationPass()
This pass expands the vector predication intrinsics into unpredicated instructions with selects or ju...
Definition: ExpandVectorPredication.cpp:707
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:82
llvm::ProcessImplicitDefsID
char & ProcessImplicitDefsID
ProcessImpicitDefs pass - This pass removes IMPLICIT_DEFs.
Definition: ProcessImplicitDefs.cpp:58
llvm::PatchableFunctionID
char & PatchableFunctionID
This pass implements the "patchable-function" attribute.
Definition: PatchableFunction.cpp:96
llvm::MachineBlockPlacementStatsID
char & MachineBlockPlacementStatsID
MachineBlockPlacementStats - This pass collects statistics about the basic block placement using bran...
Definition: MachineBlockPlacement.cpp:3663
llvm::createFreeMachineFunctionPass
FunctionPass * createFreeMachineFunctionPass()
This pass frees the memory occupied by the MachineFunction.
Definition: MachineModuleInfo.cpp:175
llvm::createSjLjEHPreparePass
FunctionPass * createSjLjEHPreparePass(const TargetMachine *TM)
createSjLjEHPreparePass - This pass adapts exception handling code to use the GCC-style builtin setjm...
llvm::createX86PreAMXConfigPass
FunctionPass * createX86PreAMXConfigPass()
The pass insert tile config intrinsics for AMX fast register allocation.
Definition: X86PreAMXConfig.cpp:412
llvm::XRayInstrumentationID
char & XRayInstrumentationID
This pass inserts the XRay instrumentation sleds if they are supported by the target platform.
Definition: XRayInstrumentation.cpp:264
llvm::UnreachableMachineBlockElimID
char & UnreachableMachineBlockElimID
UnreachableMachineBlockElimination - This pass removes unreachable machine basic blocks.
llvm::createHardwareLoopsPass
FunctionPass * createHardwareLoopsPass()
Create Hardware Loop pass.
Definition: HardwareLoops.cpp:543
llvm::createStripDebugMachineModulePass
ModulePass * createStripDebugMachineModulePass(bool OnlyDebugified)
Creates MIR Strip Debug pass.
Definition: MachineStripDebug.cpp:106
llvm::BranchFolderPassID
char & BranchFolderPassID
BranchFolding - This pass performs machine code CFG based optimizations to delete branches to branche...
Definition: BranchFolding.cpp:118
llvm::MachineBlockPlacementID
char & MachineBlockPlacementID
MachineBlockPlacement - This pass places basic blocks based on branch probabilities.
Definition: MachineBlockPlacement.cpp:622
llvm::createIndirectBrExpandPass
FunctionPass * createIndirectBrExpandPass()
Definition: IndirectBrExpandPass.cpp:78
llvm::MachineRegionInfoPassID
char & MachineRegionInfoPassID
MachineRegionInfo - This pass computes SESE regions for machine functions.
Definition: MachineRegionInfo.cpp:129
llvm::ShrinkWrapID
char & ShrinkWrapID
ShrinkWrap pass. Look for the best place to insert save and restore.
Definition: ShrinkWrap.cpp:250
llvm::createWinEHPass
FunctionPass * createWinEHPass(bool DemoteCatchSwitchPHIOnly=false)
createWinEHPass - Prepares personality functions used by MSVC on Windows, in addition to the Itanium ...
llvm::createDebugifyMachineModulePass
ModulePass * createDebugifyMachineModulePass()
Creates MIR Debugify pass.
Definition: MachineDebugify.cpp:205
llvm::CodeGenOpt::Level
Level
Definition: CodeGen.h:52
llvm::RenameIndependentSubregsID
char & RenameIndependentSubregsID
This pass detects subregister lanes in a virtual register that are used independently of other lanes ...
Definition: RenameIndependentSubregs.cpp:113
llvm::FixupStatepointCallerSavedID
char & FixupStatepointCallerSavedID
The pass fixups statepoint machine instruction to replace usage of caller saved registers with stack ...
Definition: FixupStatepointCallerSaved.cpp:84
llvm::createInterleavedAccessPass
FunctionPass * createInterleavedAccessPass()
InterleavedAccess Pass - This pass identifies and matches interleaved memory accesses to target speci...
Definition: InterleavedAccessPass.cpp:145
llvm::createRegUsageInfoCollector
FunctionPass * createRegUsageInfoCollector()
This pass is executed POST-RA to collect which physical registers are preserved by given machine func...
Definition: RegUsageInfoCollector.cpp:75
llvm::createMIRAddFSDiscriminatorsPass
FunctionPass * createMIRAddFSDiscriminatorsPass(sampleprof::FSDiscriminatorPass P)
Add Flow Sensitive Discriminators.
llvm::createBreakFalseDeps
FunctionPass * createBreakFalseDeps()
Creates Break False Dependencies pass.
Definition: BreakFalseDeps.cpp:107
llvm::createJumpInstrTablesPass
ModulePass * createJumpInstrTablesPass()
createJumpInstrTables - This pass creates jump-instruction tables.
llvm::createSelectOptimizePass
FunctionPass * createSelectOptimizePass()
This pass converts conditional moves to conditional jumps when profitable.
Definition: SelectOptimize.cpp:230
llvm::createWasmEHPass
FunctionPass * createWasmEHPass()
createWasmEHPass - This pass adapts exception handling code to use WebAssembly's exception handling s...
Definition: WasmEHPrepare.cpp:134
llvm::createExpandLargeFpConvertPass
FunctionPass * createExpandLargeFpConvertPass()
Definition: ExpandLargeFpConvert.cpp:660
llvm::createPseudoProbeInserter
FunctionPass * createPseudoProbeInserter()
This pass inserts pseudo probe annotation for callsite profiling.
Definition: PseudoProbeInserter.cpp:151
llvm::MachineFunctionPrinterPassID
char & MachineFunctionPrinterPassID
MachineFunctionPrinterPass - This pass prints out MachineInstr's.
Definition: MachineFunctionPrinterPass.cpp:58
llvm::MachineSanitizerBinaryMetadataID
char & MachineSanitizerBinaryMetadataID
llvm::TailDuplicateID
char & TailDuplicateID
TailDuplicate - Duplicate blocks with unconditional branches into tails of their predecessors.
Definition: TailDuplication.cpp:76
llvm::DeadMachineInstructionElimID
char & DeadMachineInstructionElimID
DeadMachineInstructionElim - This pass removes dead machine instructions.
Definition: DeadMachineInstructionElim.cpp:56
llvm::createIfConverter
FunctionPass * createIfConverter(std::function< bool(const MachineFunction &)> Ftor)
Definition: IfConversion.cpp:2364
llvm::createGlobalMergePass
Pass * createGlobalMergePass(const TargetMachine *TM, unsigned MaximalOffset, bool OnlyOptimizeForSize=false, bool MergeExternalByDefault=false)
GlobalMerge - This pass merges internal (by default) globals into structs to enable reuse of a base p...
Definition: GlobalMerge.cpp:692
llvm::BranchRelaxationPassID
char & BranchRelaxationPassID
BranchRelaxation - This pass replaces branches that need to jump further than is supported by a branc...
Definition: BranchRelaxation.cpp:121
llvm::MachineLateInstrsCleanupID
char & MachineLateInstrsCleanupID
MachineLateInstrsCleanup - This pass removes redundant identical instructions after register allocati...
Definition: MachineLateInstrsCleanup.cpp:77
llvm::MachineSchedulerID
char & MachineSchedulerID
MachineScheduler - This pass schedules machine instructions.
Definition: MachineScheduler.cpp:212
CodeGen.h
llvm::MachineDominanceFrontierID
char & MachineDominanceFrontierID
MachineDominanaceFrontier - This pass is a machine dominators analysis.
Definition: MachineDominanceFrontier.cpp:37
llvm::PostRASchedulerID
char & PostRASchedulerID
PostRAScheduler - This pass performs post register allocation scheduling.
Definition: PostRASchedulerList.cpp:197
llvm::MachineDominatorsID
char & MachineDominatorsID
MachineDominators - This pass is a machine dominators analysis pass.
llvm::MachineCombinerID
char & MachineCombinerID
This pass performs instruction combining using trace metrics to estimate critical-path and resource d...
Definition: MachineCombiner.cpp:131
llvm::MIRPrintingPassID
char & MIRPrintingPassID
MIRPrintingPass - this pass prints out the LLVM IR using the MIR serialization format.
Definition: MIRPrintingPass.cpp:61
TM
const char LLVMTargetMachineRef TM
Definition: PassBuilderBindings.cpp:47
llvm::MachineCFGPrinterID
char & MachineCFGPrinterID
MachineCFGPrinter pass.
Definition: MachineCFGPrinter.cpp:77
llvm::createBasicRegisterAllocator
FunctionPass * createBasicRegisterAllocator()
BasicRegisterAllocation Pass - This pass implements a degenerate global register allocator using the ...
Definition: RegAllocBasic.cpp:333
llvm::ImplicitNullChecksID
char & ImplicitNullChecksID
ImplicitNullChecks - This pass folds null pointer checks into nearby memory operations.
Definition: ImplicitNullChecks.cpp:816
llvm::EarlyMachineLICMID
char & EarlyMachineLICMID
This pass performs loop invariant code motion on machine instructions.
Definition: MachineLICM.cpp:297
llvm::createInterleavedLoadCombinePass
FunctionPass * createInterleavedLoadCombinePass()
InterleavedLoadCombines Pass - This pass identifies interleaved loads and combines them into wide loa...
Definition: InterleavedLoadCombinePass.cpp:1358
llvm::PostMachineSchedulerID
char & PostMachineSchedulerID
PostMachineScheduler - This pass schedules machine instructions postRA.
Definition: MachineScheduler.cpp:243
llvm::createExpandLargeDivRemPass
FunctionPass * createExpandLargeDivRemPass()
Definition: ExpandLargeDivRem.cpp:135
llvm::PostRAMachineSinkingID
char & PostRAMachineSinkingID
This pass perform post-ra machine sink for COPY instructions.
Definition: MachineSink.cpp:1622
llvm::RemoveRedundantDebugValuesID
char & RemoveRedundantDebugValuesID
RemoveRedundantDebugValues pass.
Definition: RemoveRedundantDebugValues.cpp:61
llvm::IfConverterID
char & IfConverterID
IfConverter - This pass performs machine code if conversion.
Definition: IfConversion.cpp:434
llvm::createSafeStackPass
FunctionPass * createSafeStackPass()
This pass splits the stack into a safe stack and an unsafe stack to protect against stack-based overf...
Definition: SafeStack.cpp:939
llvm::LiveIntervalsID
char & LiveIntervalsID
LiveIntervals - This analysis keeps track of the live ranges of virtual and physical registers.
Definition: LiveIntervals.cpp:61
llvm::createBasicBlockSectionsPass
MachineFunctionPass * createBasicBlockSectionsPass()
createBasicBlockSections Pass - This pass assigns sections to machine basic blocks and is enabled wit...
Definition: BasicBlockSections.cpp:391
llvm::createCodeGenPreparePass
FunctionPass * createCodeGenPreparePass()
createCodeGenPreparePass - Transform the code to expose more pattern matching during instruction sele...
Definition: CodeGenPrepare.cpp:488
llvm::EarlyIfPredicatorID
char & EarlyIfPredicatorID
EarlyIfPredicator - This pass performs if-conversion on SSA form by predicating if/else block and ins...
Definition: EarlyIfConversion.cpp:1107
llvm::createStackProtectorPass
FunctionPass * createStackProtectorPass()
createStackProtectorPass - This pass adds stack protectors to functions.
Definition: StackProtector.cpp:76
llvm::createCFGuardLongjmpPass
FunctionPass * createCFGuardLongjmpPass()
Creates CFGuard longjmp target identification pass.