RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-24 03:33:20 +01:00
Code Issues Projects Releases Wiki Activity
a22a21165f
llvm-mirror/include/llvm/InitializePasses.h

284 lines
13 KiB
C
Raw Normal View History

Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
//===- llvm/InitializePasses.h -------- Initialize All Passes ---*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the declarations for the pass initialization routines
// for the entire LLVM project.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_INITIALIZEPASSES_H
#define LLVM_INITIALIZEPASSES_H
namespace llvm {
class PassRegistry;
Implementation of path profiling. Modified patch by Adam Preuss. This builds on the existing framework for block tracing, edge profiling and optimal edge profiling. See -help-hidden for new flags. For documentation, see the technical report "Implementation of Path Profiling..." in llvm.org/pubs. llvm-svn: 124515
2011-01-29 02:09:53 +01:00
/// initializeCore - Initialize all passes linked into the
Add initialization routines for VMCore. llvm-svn: 115963
2010-10-07 21:51:21 +02:00
/// TransformUtils library.
void initializeCore(PassRegistry&);
Implementation of path profiling. Modified patch by Adam Preuss. This builds on the existing framework for block tracing, edge profiling and optimal edge profiling. See -help-hidden for new flags. For documentation, see the technical report "Implementation of Path Profiling..." in llvm.org/pubs. llvm-svn: 124515
2011-01-29 02:09:53 +01:00
/// initializeTransformUtils - Initialize all passes linked into the
Next step on the getting-rid-of-static-ctors train: begin adding per-library initialization functions that initialize the set of passes implemented in that library. Add C bindings for these functions as well. llvm-svn: 115927
2010-10-07 19:55:47 +02:00
/// TransformUtils library.
void initializeTransformUtils(PassRegistry&);
Implementation of path profiling. Modified patch by Adam Preuss. This builds on the existing framework for block tracing, edge profiling and optimal edge profiling. See -help-hidden for new flags. For documentation, see the technical report "Implementation of Path Profiling..." in llvm.org/pubs. llvm-svn: 124515
2011-01-29 02:09:53 +01:00
/// initializeScalarOpts - Initialize all passes linked into the
Next step on the getting-rid-of-static-ctors train: begin adding per-library initialization functions that initialize the set of passes implemented in that library. Add C bindings for these functions as well. llvm-svn: 115927
2010-10-07 19:55:47 +02:00
/// ScalarOpts library.
void initializeScalarOpts(PassRegistry&);
Extracted ObjCARC.cpp into its own library libLLVMObjCARCOpts in preparation for refactoring the ARC Optimizer. llvm-svn: 173647
2013-01-28 02:35:51 +01:00
/// initializeObjCARCOpts - Initialize all passes linked into the ObjCARCOpts
/// library.
void initializeObjCARCOpts(PassRegistry&);
Add a basic-block autovectorization pass. This is the initial checkin of the basic-block autovectorization pass along with some supporting vectorization infrastructure. Special thanks to everyone who helped review this code over the last several months (especially Tobias Grosser). llvm-svn: 149468
2012-02-01 04:51:43 +01:00
/// initializeVectorization - Initialize all passes linked into the
/// Vectorize library.
void initializeVectorization(PassRegistry&);
Implementation of path profiling. Modified patch by Adam Preuss. This builds on the existing framework for block tracing, edge profiling and optimal edge profiling. See -help-hidden for new flags. For documentation, see the technical report "Implementation of Path Profiling..." in llvm.org/pubs. llvm-svn: 124515
2011-01-29 02:09:53 +01:00
/// initializeInstCombine - Initialize all passes linked into the
Add initialization routines to InstCombine. llvm-svn: 115965
2010-10-07 22:04:55 +02:00
/// ScalarOpts library.
void initializeInstCombine(PassRegistry&);
Add an initialization routine for libLLVMipo.a llvm-svn: 115933
2010-10-07 20:09:59 +02:00
/// initializeIPO - Initialize all passes linked into the IPO library.
void initializeIPO(PassRegistry&);
Add initialization routines for Instrumentation. llvm-svn: 115971
2010-10-07 22:17:24 +02:00
/// initializeInstrumentation - Initialize all passes linked into the
/// Instrumentation library.
void initializeInstrumentation(PassRegistry&);
Add initialization routines for Analysis and IPA. llvm-svn: 115946
2010-10-07 20:31:00 +02:00
/// initializeAnalysis - Initialize all passes linked into the Analysis library.
void initializeAnalysis(PassRegistry&);
/// initializeIPA - Initialize all passes linked into the IPA library.
void initializeIPA(PassRegistry&);
Add initialization routines for CodeGen. llvm-svn: 115949
2010-10-07 20:41:20 +02:00
/// initializeCodeGen - Initialize all passes linked into the CodeGen library.
void initializeCodeGen(PassRegistry&);
Add initialization routines for Target. llvm-svn: 115957
2010-10-07 20:50:11 +02:00
/// initializeCodeGen - Initialize all passes linked into the CodeGen library.
void initializeTarget(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeAAEvalPass(PassRegistry&);
void initializeADCEPass(PassRegistry&);
void initializeAliasAnalysisAnalysisGroup(PassRegistry&);
void initializeAliasAnalysisCounterPass(PassRegistry&);
void initializeAliasDebuggerPass(PassRegistry&);
void initializeAliasSetPrinterPass(PassRegistry&);
void initializeAlwaysInlinerPass(PassRegistry&);
void initializeArgPromotionPass(PassRegistry&);
Introduce a BarrierNoop pass, a hack designed to allow *some* control over the implicitly-formed-and-nesting CGSCC pass manager and function pass managers, especially when using them on the opt commandline or using extension points in the module builder. The '-barrier' opt flag (or the pass itself) will create a no-op module pass in the pipeline, resetting the pass manager stack, and allowing the creation of a new pipeline of function passes or CGSCC passes to be created that is independent from any previous pipelines. For example, this can be used to test running two CGSCC passes in independent CGSCC pass managers as opposed to in the same CGSCC pass manager. It also allows us to introduce a further hack into the PassManagerBuilder to separate the O0 pipeline extension passes from the always-inliner's CGSCC pass manager, which they likely do not want to participate in... At the very least none of the Sanitizer passes want this behavior. This fixes a bug with ASan at O0 currently, and I'll commit the ASan test which covers this pass. I'm happy to add a test case that this pass exists and works, but not sure how much time folks would like me to spend adding test cases for the details of its behavior of partition pass managers.... The whole thing is just vile, and mostly intended to unblock ASan, so I'm hoping to rip this all out in a brave new pass manager world. llvm-svn: 166172
2012-10-18 10:05:46 +02:00
void initializeBarrierNoopPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeBasicAliasAnalysisPass(PassRegistry&);
void initializeBasicCallGraphPass(PassRegistry&);
Switch TargetTransformInfo from an immutable analysis pass that requires a TargetMachine to construct (and thus isn't always available), to an analysis group that supports layered implementations much like AliasAnalysis does. This is a pretty massive change, with a few parts that I was unable to easily separate (sorry), so I'll walk through it. The first step of this conversion was to make TargetTransformInfo an analysis group, and to sink the nonce implementations in ScalarTargetTransformInfo and VectorTargetTranformInfo into a NoTargetTransformInfo pass. This allows other passes to add a hard requirement on TTI, and assume they will always get at least on implementation. The TargetTransformInfo analysis group leverages the delegation chaining trick that AliasAnalysis uses, where the base class for the analysis group delegates to the previous analysis *pass*, allowing all but tho NoFoo analysis passes to only implement the parts of the interfaces they support. It also introduces a new trick where each pass in the group retains a pointer to the top-most pass that has been initialized. This allows passes to implement one API in terms of another API and benefit when some other pass above them in the stack has more precise results for the second API. The second step of this conversion is to create a pass that implements the TargetTransformInfo analysis using the target-independent abstractions in the code generator. This replaces the ScalarTargetTransformImpl and VectorTargetTransformImpl classes in lib/Target with a single pass in lib/CodeGen called BasicTargetTransformInfo. This class actually provides most of the TTI functionality, basing it upon the TargetLowering abstraction and other information in the target independent code generator. The third step of the conversion adds support to all TargetMachines to register custom analysis passes. This allows building those passes with access to TargetLowering or other target-specific classes, and it also allows each target to customize the set of analysis passes desired in the pass manager. The baseline LLVMTargetMachine implements this interface to add the BasicTTI pass to the pass manager, and all of the tools that want to support target-aware TTI passes call this routine on whatever target machine they end up with to add the appropriate passes. The fourth step of the conversion created target-specific TTI analysis passes for the X86 and ARM backends. These passes contain the custom logic that was previously in their extensions of the ScalarTargetTransformInfo and VectorTargetTransformInfo interfaces. I separated them into their own file, as now all of the interface bits are private and they just expose a function to create the pass itself. Then I extended these target machines to set up a custom set of analysis passes, first adding BasicTTI as a fallback, and then adding their customized TTI implementations. The fourth step required logic that was shared between the target independent layer and the specific targets to move to a different interface, as they no longer derive from each other. As a consequence, a helper functions were added to TargetLowering representing the common logic needed both in the target implementation and the codegen implementation of the TTI pass. While technically this is the only change that could have been committed separately, it would have been a nightmare to extract. The final step of the conversion was just to delete all the old boilerplate. This got rid of the ScalarTargetTransformInfo and VectorTargetTransformInfo classes, all of the support in all of the targets for producing instances of them, and all of the support in the tools for manually constructing a pass based around them. Now that TTI is a relatively normal analysis group, two things become straightforward. First, we can sink it into lib/Analysis which is a more natural layer for it to live. Second, clients of this interface can depend on it *always* being available which will simplify their code and behavior. These (and other) simplifications will follow in subsequent commits, this one is clearly big enough. Finally, I'm very aware that much of the comments and documentation needs to be updated. As soon as I had this working, and plausibly well commented, I wanted to get it committed and in front of the build bots. I'll be doing a few passes over documentation later if it sticks. Commits to update DragonEgg and Clang will be made presently. llvm-svn: 171681
2013-01-07 02:37:14 +01:00
void initializeBasicTTIPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeBlockExtractorPassPass(PassRegistry&);
Rename BlockFrequency to BlockFrequencyInfo and MachineBlockFrequency to MachineBlockFrequencyInfo. llvm-svn: 135937
2011-07-25 21:25:40 +02:00
void initializeBlockFrequencyInfoPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeBlockPlacementPass(PassRegistry&);
add a new pass to instrument loads and stores for run-time bounds checking move EmitGEPOffset from InstCombine to Transforms/Utils/Local.h (a draft of this) patch reviewed by Andrew, thanks. llvm-svn: 157261
2012-05-22 19:19:09 +02:00
void initializeBoundsCheckingPass(PassRegistry&);
Move pass configuration out of pass constructors: BranchFolderPass llvm-svn: 150095
2012-02-08 22:22:48 +01:00
void initializeBranchFolderPassPass(PassRegistry&);
New BranchProbabilityInfo analysis. Patch by Jakub Staszak! BranchProbabilityInfo provides an interface for IR passes to query the likelihood that control follows a CFG edge. This patch provides an initial implementation of static branch predication that will populate BranchProbabilityInfo for branches with no external profile information using very simple heuristics. It currently isn't hooked up to any external profile data, so static prediction does all the work. llvm-svn: 132613
2011-06-04 03:16:30 +02:00
void initializeBranchProbabilityInfoPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeBreakCriticalEdgesPass(PassRegistry&);
Added -view-callgraph module pass. -dot-callgraph similarly follows a standard module pass pattern. Patch by Speziale Ettore! llvm-svn: 172220
2013-01-11 18:28:14 +01:00
void initializeCallGraphPrinterPass(PassRegistry&);
void initializeCallGraphViewerPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeCFGOnlyPrinterPass(PassRegistry&);
void initializeCFGOnlyViewerPass(PassRegistry&);
void initializeCFGPrinterPass(PassRegistry&);
Factor FlattenCFG out from SimplifyCFG Patch by: Mei Ye llvm-svn: 187764
2013-08-06 04:43:45 +02:00
void initializeCFGSimplifyPassPass(PassRegistry&);
void initializeFlattenCFGPassPass(PassRegistry&);
Move StructurizeCFG out of R600 to generic Transforms. Register it with PassManager llvm-svn: 184343
2013-06-19 22:18:24 +02:00
void initializeStructurizeCFGPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeCFGViewerPass(PassRegistry&);
void initializeCalculateSpillWeightsPass(PassRegistry&);
void initializeCallGraphAnalysisGroup(PassRegistry&);
void initializeCodeGenPreparePass(PassRegistry&);
void initializeConstantMergePass(PassRegistry&);
void initializeConstantPropagationPass(PassRegistry&);
Added a late machine instruction copy propagation pass. This catches opportunities that only present themselves after late optimizations such as tail duplication .e.g. ## BB#1: movl %eax, %ecx movl %ecx, %eax ret The register allocator also leaves some of them around (due to false dep between copies from phi-elimination, etc.) This required some changes in codegen passes. Post-ra scheduler and the pseudo-instruction expansion passes have been moved after branch folding and tail merging. They were before branch folding before because it did not always update block livein's. That's fixed now. The pass change makes independently since we want to properly schedule instructions after branch folding / tail duplication. rdar://10428165 rdar://10640363 llvm-svn: 147716
2012-01-07 04:02:36 +01:00
void initializeMachineCopyPropagationPass(PassRegistry&);
Add a cost model analysis that allows us to estimate the cost of IR-level instructions. llvm-svn: 167324
2012-11-02 22:48:17 +01:00
void initializeCostModelAnalysisPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeCorrelatedValuePropagationPass(PassRegistry&);
void initializeDAEPass(PassRegistry&);
void initializeDAHPass(PassRegistry&);
void initializeDCEPass(PassRegistry&);
void initializeDSEPass(PassRegistry&);
Add DebugIR pass -- emits IR file and replace source lines with IR lines in MD - requires existing debug information to be present - fixes up file name and line number information in metadata - emits a "<orig_filename>-debug.ll" succinct IR file (without !dbg metadata or debug intrinsics) that can be read by a debugger - initialize pass in opt tool to enable the "-debug-ir" flag - lit tests to follow llvm-svn: 181467
2013-05-08 22:44:14 +02:00
void initializeDebugIRPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeDeadInstEliminationPass(PassRegistry&);
void initializeDeadMachineInstructionElimPass(PassRegistry&);
dependence analysis Patch from Preston Briggs <preston.briggs@gmail.com>. This is an updated version of the dependence-analysis patch, including an MIV test based on Banerjee's inequalities. It's a fairly complete implementation of the paper Practical Dependence Testing Gina Goff, Ken Kennedy, and Chau-Wen Tseng PLDI 1991 It cannot yet propagate constraints between coupled RDIV subscripts (discussed in Section 5.3.2 of the paper). It's organized as a FunctionPass with a single entry point that supports testing for dependence between two instructions in a function. If there's no dependence, it returns null. If there's a dependence, it returns a pointer to a Dependence which can be queried about details (what kind of dependence, is it loop independent, direction and distance vector entries, etc). I haven't included every imaginable feature, but there's a good selection that should be adequate for supporting many loop transformations. Of course, it can be extended as necessary. Included in the patch file are many test cases, commented with C code showing the loops and array references. llvm-svn: 165708
2012-10-11 09:32:34 +02:00
void initializeDependenceAnalysisPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeDomOnlyPrinterPass(PassRegistry&);
void initializeDomOnlyViewerPass(PassRegistry&);
void initializeDomPrinterPass(PassRegistry&);
void initializeDomViewerPass(PassRegistry&);
void initializeDominanceFrontierPass(PassRegistry&);
void initializeDominatorTreePass(PassRegistry&);
Add an experimental early if-conversion pass, off by default. This pass performs if-conversion on SSA form machine code by speculatively executing both sides of the branch and using a cmov instruction to select the result. This can help lower the number of branch mispredictions on architectures like x86 that don't have predicable instructions. The current implementation is very aggressive, and causes regressions on mosts tests. It needs good heuristics that have yet to be implemented. llvm-svn: 159694
2012-07-04 02:09:54 +02:00
void initializeEarlyIfConverterPass(PassRegistry&);
Turn the EdgeBundles class into a stand-alone machine CFG analysis pass. The analysis will be needed by both the greedy register allocator and the X86FloatingPoint pass. It only needs to be computed once when the CFG doesn't change. This pass is very fast, usually showing up as 0.0% wall time. llvm-svn: 122832
2011-01-04 22:10:05 +01:00
void initializeEdgeBundlesPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeEdgeProfilerPass(PassRegistry&);
Codegen pass definition cleanup. No functionality. Moving toward a uniform style of pass definition to allow easier target configuration. Globally declare Pass ID. Globally declare pass initializer. Use INITIALIZE_PASS consistently. Add a call to the initializer from CodeGen.cpp. Remove redundant "createPass" functions and "getPassName" methods. While cleaning up declarations, cleaned up comments (sorry for large diff). llvm-svn: 150100
2012-02-08 22:23:13 +01:00
void initializeExpandPostRAPass(PassRegistry&);
Implementation of path profiling. Modified patch by Adam Preuss. This builds on the existing framework for block tracing, edge profiling and optimal edge profiling. See -help-hidden for new flags. For documentation, see the technical report "Implementation of Path Profiling..." in llvm.org/pubs. llvm-svn: 124515
2011-01-29 02:09:53 +01:00
void initializePathProfilerPass(PassRegistry&);
Rename LineProfiling to GCOVProfiling to more accurately represent what it does. Also mostly implement it. Still a work-in-progress, but generates legal output on crafted test cases. llvm-svn: 129630
2011-04-16 03:20:23 +02:00
void initializeGCOVProfilerPass(PassRegistry&);
AddressSanitizer, first commit (compiler module only) llvm-svn: 144758
2011-11-16 02:35:23 +01:00
void initializeAddressSanitizerPass(PassRegistry&);
[asan] Split AddressSanitizer into two passes (FunctionPass, ModulePass), LLVM part. This requires a clang part which will follow. llvm-svn: 168781
2012-11-28 11:31:36 +01:00
void initializeAddressSanitizerModulePass(PassRegistry&);
Initial commit of MemorySanitizer. Compiler pass only. llvm-svn: 168866
2012-11-29 10:57:20 +01:00
void initializeMemorySanitizerPass(PassRegistry&);
ThreadSanitizer, a race detector. First LLVM commit. Clang patch (flags) will follow shortly. The run-time library will also follow, but not immediately. llvm-svn: 150423
2012-02-13 23:50:51 +01:00
void initializeThreadSanitizerPass(PassRegistry&);
DataFlowSanitizer; LLVM changes. DataFlowSanitizer is a generalised dynamic data flow analysis. Unlike other Sanitizer tools, this tool is not designed to detect a specific class of bugs on its own. Instead, it provides a generic dynamic data flow analysis framework to be used by clients to help detect application-specific issues within their own code. Differential Revision: http://llvm-reviews.chandlerc.com/D965 llvm-svn: 187923
2013-08-08 00:47:18 +02:00
void initializeDataFlowSanitizerPass(PassRegistry&);
sketch out a new early cse pass. No functionality yet. llvm-svn: 122713
2011-01-02 22:47:05 +01:00
void initializeEarlyCSEPass(PassRegistry&);
Rename ExpandPseudos to ExpandISelPseudos to help clarify its role. llvm-svn: 119716
2010-11-18 19:45:06 +01:00
void initializeExpandISelPseudosPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeFindUsedTypesPass(PassRegistry&);
void initializeFunctionAttrsPass(PassRegistry&);
Codegen pass definition cleanup. No functionality. Moving toward a uniform style of pass definition to allow easier target configuration. Globally declare Pass ID. Globally declare pass initializer. Use INITIALIZE_PASS consistently. Add a call to the initializer from CodeGen.cpp. Remove redundant "createPass" functions and "getPassName" methods. While cleaning up declarations, cleaned up comments (sorry for large diff). llvm-svn: 150100
2012-02-08 22:23:13 +01:00
void initializeGCMachineCodeAnalysisPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeGCModuleInfoPass(PassRegistry&);
void initializeGVNPass(PassRegistry&);
void initializeGlobalDCEPass(PassRegistry&);
void initializeGlobalOptPass(PassRegistry&);
void initializeGlobalsModRefPass(PassRegistry&);
void initializeIPCPPass(PassRegistry&);
void initializeIPSCCPPass(PassRegistry&);
void initializeIVUsersPass(PassRegistry&);
void initializeIfConverterPass(PassRegistry&);
void initializeIndVarSimplifyPass(PassRegistry&);
Make the inline cost a proper analysis pass. This remains essentially a dynamic analysis done on each call to the routine. However, now it can use the standard pass infrastructure to reference other analyses, instead of a silly setter method. This will become more interesting as I teach it about more analysis passes. This updates the two inliner passes to use the inline cost analysis. Doing so highlights how utterly redundant these two passes are. Either we should find a cheaper way to do always inlining, or we should merge the two and just fiddle with the thresholds to get the desired behavior. I'm leaning increasingly toward the latter as it would also remove the Inliner sub-class split. llvm-svn: 173030
2013-01-21 12:39:18 +01:00
void initializeInlineCostAnalysisPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeInstCombinerPass(PassRegistry&);
void initializeInstCountPass(PassRegistry&);
void initializeInstNamerPass(PassRegistry&);
void initializeInternalizePassPass(PassRegistry&);
void initializeIntervalPartitionPass(PassRegistry&);
void initializeJumpThreadingPass(PassRegistry&);
void initializeLCSSAPass(PassRegistry&);
void initializeLICMPass(PassRegistry&);
void initializeLazyValueInfoPass(PassRegistry&);
void initializeLibCallAliasAnalysisPass(PassRegistry&);
void initializeLintPass(PassRegistry&);
Stub out a new LiveDebugVariables pass. This analysis is going to run immediately after LiveIntervals. It will stay alive during register allocation and keep track of user variables mentioned in DBG_VALUE instructions. When the register allocator is moving values between registers and the stack, it is very hard to keep track of DBG_VALUE instructions. We usually get it wrong. This analysis maintains a data structure that makes it easy to update DBG_VALUE instructions. llvm-svn: 120385
2010-11-30 03:17:10 +01:00
void initializeLiveDebugVariablesPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeLiveIntervalsPass(PassRegistry&);
Sketch a LiveRegMatrix analysis pass. The LiveRegMatrix represents the live range of assigned virtual registers in a Live interval union per register unit. This is not fundamentally different from the interference tracking in RegAllocBase that both RABasic and RAGreedy use. The important differences are: - LiveRegMatrix tracks interference per register unit instead of per physical register. This makes interference checks cheaper and assignments slightly more expensive. For example, the ARM D7 reigster has 24 aliases, so we would check 24 physregs before assigning to one. With unit-based interference, we check 2 units before assigning to 2 units. - LiveRegMatrix caches regmask interference checks. That is currently duplicated functionality in RABasic and RAGreedy. - LiveRegMatrix is a pass which makes it possible to insert target-dependent passes between register allocation and rewriting. Such passes could tweak the register assignments with interference checking support from LiveRegMatrix. Eventually, RABasic and RAGreedy will be switched to LiveRegMatrix. llvm-svn: 158255
2012-06-09 04:13:10 +02:00
void initializeLiveRegMatrixPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeLiveStacksPass(PassRegistry&);
void initializeLiveVariablesPass(PassRegistry&);
void initializeLoaderPassPass(PassRegistry&);
Profile: set branch weight metadata with data generated from profiling. This patch implements ProfileDataLoader which loads profile data generated by -insert-edge-profiling and updates branch weight metadata accordingly. Patch by Alastair Murray. llvm-svn: 162799
2012-08-29 00:21:25 +02:00
void initializeProfileMetadataLoaderPassPass(PassRegistry&);
Implementation of path profiling. Modified patch by Adam Preuss. This builds on the existing framework for block tracing, edge profiling and optimal edge profiling. See -help-hidden for new flags. For documentation, see the technical report "Implementation of Path Profiling..." in llvm.org/pubs. llvm-svn: 124515
2011-01-29 02:09:53 +01:00
void initializePathProfileLoaderPassPass(PassRegistry&);
Codegen pass definition cleanup. No functionality. Moving toward a uniform style of pass definition to allow easier target configuration. Globally declare Pass ID. Globally declare pass initializer. Use INITIALIZE_PASS consistently. Add a call to the initializer from CodeGen.cpp. Remove redundant "createPass" functions and "getPassName" methods. While cleaning up declarations, cleaned up comments (sorry for large diff). llvm-svn: 150100
2012-02-08 22:23:13 +01:00
void initializeLocalStackSlotPassPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeLoopDeletionPass(PassRegistry&);
void initializeLoopExtractorPass(PassRegistry&);
void initializeLoopInfoPass(PassRegistry&);
Add a new loop-instsimplify pass, with the intention of replacing the instance of instcombine that is currently in the middle of the loop pass pipeline. This commit only checks in the pass; it will hopefully be enabled by default later. llvm-svn: 122719
2011-01-03 01:25:16 +01:00
void initializeLoopInstSimplifyPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeLoopRotatePass(PassRegistry&);
void initializeLoopSimplifyPass(PassRegistry&);
void initializeLoopStrengthReducePass(PassRegistry&);
svn mv Target/ARM/ARMGlobalMerge.cpp Transforms/Scalar/GlobalMerge.cpp There is no reason to have simple IR level pass in lib/Target. llvm-svn: 142200
2011-10-17 19:17:43 +02:00
void initializeGlobalMergePass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeLoopUnrollPass(PassRegistry&);
void initializeLoopUnswitchPass(PassRegistry&);
Start of a pass for recognizing memset and memcpy idioms. No functionality yet. llvm-svn: 122562
2010-12-26 20:32:44 +01:00
void initializeLoopIdiomRecognizePass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeLowerAtomicPass(PassRegistry&);
Introduce "expect" intrinsic instructions. llvm-svn: 134516
2011-07-06 20:22:43 +02:00
void initializeLowerExpectIntrinsicPass(PassRegistry&);
Get rid of static constructors for pass registration. Instead, every pass exposes an initializeMyPassFunction(), which must be called in the pass's constructor. This function uses static dependency declarations to recursively initialize the pass's dependencies. Clients that only create passes through the createFooPass() APIs will require no changes. Clients that want to use the CommandLine options for passes will need to manually call the appropriate initialization functions in PassInitialization.h before parsing commandline arguments. I have tested this with all standard configurations of clang and llvm-gcc on Darwin. It is possible that there are problems with the static dependencies that will only be visible with non-standard options. If you encounter any crash in pass registration/creation, please send the testcase to me directly. llvm-svn: 116820
2010-10-19 19:21:58 +02:00
void initializeLowerIntrinsicsPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeLowerInvokePass(PassRegistry&);
void initializeLowerSwitchPass(PassRegistry&);
Rename BlockFrequency to BlockFrequencyInfo and MachineBlockFrequency to MachineBlockFrequencyInfo. llvm-svn: 135937
2011-07-25 21:25:40 +02:00
void initializeMachineBlockFrequencyInfoPass(PassRegistry&);
Implement a block placement pass based on the branch probability and block frequency analyses. This differs substantially from the existing block-placement pass in LLVM: 1) It operates on the Machine-IR in the CodeGen layer. This exposes much more (and more precise) information and opportunities. Also, the results are more stable due to fewer transforms ocurring after the pass runs. 2) It uses the generalized probability and frequency analyses. These can model static heuristics, code annotation derived heuristics as well as eventual profile loading. By basing the optimization on the analysis interface it can work from any (or a combination) of these inputs. 3) It uses a more aggressive algorithm, both building chains from tho bottom up to maximize benefit, and using an SCC-based walk to layout chains of blocks in a profitable ordering without O(N^2) iterations which the old pass involves. The pass is currently gated behind a flag, and not enabled by default because it still needs to grow some important features. Most notably, it needs to support loop aligning and careful layout of loop structures much as done by hand currently in CodePlacementOpt. Once it supports these, and has sufficient testing and quality tuning, it should replace both of these passes. Thanks to Nick Lewycky and Richard Smith for help authoring & debugging this, and to Jakob, Andy, Eric, Jim, and probably a few others I'm forgetting for reviewing and answering all my questions. Writing a backend pass is *sooo* much better now than it used to be. =D llvm-svn: 142641
2011-10-21 08:46:38 +02:00
void initializeMachineBlockPlacementPass(PassRegistry&);
Begin collecting some of the statistics for block placement discussed on the mailing list. Suggestions for other statistics to collect would be awesome. =] Currently these are implemented as a separate pass guarded by a separate flag. I'm not thrilled by that, but I wanted to be able to collect the statistics for the old code placement as well as the new in order to have a point of comparison. I'm planning on folding them into the single pass if / when there is only one pass of interest. llvm-svn: 143537
2011-11-02 08:17:12 +01:00
void initializeMachineBlockPlacementStatsPass(PassRegistry&);
Introduce MachineBranchProbabilityInfo class, which has similar API to BranchProbabilityInfo (expect setEdgeWeight which is not available here). Branch Weights are kept in MachineBasicBlocks. To turn off this analysis set -use-mbpi=false. llvm-svn: 133184
2011-06-16 22:22:37 +02:00
void initializeMachineBranchProbabilityInfoPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeMachineCSEPass(PassRegistry&);
void initializeMachineDominatorTreePass(PassRegistry&);
Add a MachinePostDominator pass This is used in the AMDIL and R600 backends. llvm-svn: 164029
2012-09-17 16:08:37 +02:00
void initializeMachinePostDominatorTreePass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeMachineLICMPass(PassRegistry&);
void initializeMachineLoopInfoPass(PassRegistry&);
void initializeMachineModuleInfoPass(PassRegistry&);
Renamed MachineScheduler to ScheduleTopDownLive. Responding to code review. llvm-svn: 148290
2012-01-17 07:55:03 +01:00
void initializeMachineSchedulerPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeMachineSinkingPass(PassRegistry&);
Start scaffolding for a MachineTraceMetrics analysis pass. This is still a work in progress. Out-of-order CPUs usually execute instructions from multiple basic blocks simultaneously, so it is necessary to look at longer traces when estimating the performance effects of code transformations. The MachineTraceMetrics analysis will pick a typical trace through a given basic block and provide performance metrics for the trace. Metrics will include: - Instruction count through the trace. - Issue count per functional unit. - Critical path length, and per-instruction 'slack'. These metrics can be used to determine the performance limiting factor when executing the trace, and how it will be affected by a code transformation. Initially, this will be used by the early if-conversion pass. llvm-svn: 160796
2012-07-26 20:38:11 +02:00
void initializeMachineTraceMetricsPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeMachineVerifierPassPass(PassRegistry&);
void initializeMemCpyOptPass(PassRegistry&);
void initializeMemDepPrinterPass(PassRegistry&);
void initializeMemoryDependenceAnalysisPass(PassRegistry&);
Add a pass that renames everything with metasyntatic names. This works well after using bugpoint to reduce the confusion presented by the original names, which no longer mean what they used to. llvm-svn: 163592
2012-09-11 04:46:18 +02:00
void initializeMetaRenamerPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeMergeFunctionsPass(PassRegistry&);
void initializeModuleDebugInfoPrinterPass(PassRegistry&);
void initializeNoAAPass(PassRegistry&);
void initializeNoProfileInfoPass(PassRegistry&);
Implementation of path profiling. Modified patch by Adam Preuss. This builds on the existing framework for block tracing, edge profiling and optimal edge profiling. See -help-hidden for new flags. For documentation, see the technical report "Implementation of Path Profiling..." in llvm.org/pubs. llvm-svn: 124515
2011-01-29 02:09:53 +01:00
void initializeNoPathProfileInfoPass(PassRegistry&);
The ARC language-specific optimizer. Credit to Dan Gohman. llvm-svn: 133108
2011-06-16 01:37:01 +02:00
void initializeObjCARCAliasAnalysisPass(PassRegistry&);
Add a new ObjC ARC optimization pass to eliminate unneeded autorelease push+pop pairs. llvm-svn: 148330
2012-01-17 21:52:24 +01:00
void initializeObjCARCAPElimPass(PassRegistry&);
The ARC language-specific optimizer. Credit to Dan Gohman. llvm-svn: 133108
2011-06-16 01:37:01 +02:00
void initializeObjCARCExpandPass(PassRegistry&);
void initializeObjCARCContractPass(PassRegistry&);
void initializeObjCARCOptPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeOptimalEdgeProfilerPass(PassRegistry&);
void initializeOptimizePHIsPass(PassRegistry&);
Turn MipsOptimizeMathLibCalls into a target-independent scalar transform ...so that it can be used for z too. Most of the code is the same. The only real change is to use TargetTransformInfo to test when a sqrt instruction is available. The pass is opt-in because at the moment it only handles sqrt. llvm-svn: 189097
2013-08-23 12:27:02 +02:00
void initializePartiallyInlineLibCallsPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializePEIPass(PassRegistry&);
void initializePHIEliminationPass(PassRegistry&);
void initializePartialInlinerPass(PassRegistry&);
void initializePeepholeOptimizerPass(PassRegistry&);
void initializePostDomOnlyPrinterPass(PassRegistry&);
void initializePostDomOnlyViewerPass(PassRegistry&);
void initializePostDomPrinterPass(PassRegistry&);
void initializePostDomViewerPass(PassRegistry&);
void initializePostDominatorTreePass(PassRegistry&);
Codegen pass definition cleanup. No functionality. Moving toward a uniform style of pass definition to allow easier target configuration. Globally declare Pass ID. Globally declare pass initializer. Use INITIALIZE_PASS consistently. Add a call to the initializer from CodeGen.cpp. Remove redundant "createPass" functions and "getPassName" methods. While cleaning up declarations, cleaned up comments (sorry for large diff). llvm-svn: 150100
2012-02-08 22:23:13 +01:00
void initializePostRASchedulerPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializePreVerifierPass(PassRegistry&);
void initializePrintFunctionPassPass(PassRegistry&);
void initializePrintModulePassPass(PassRegistry&);
Enable *BasicBlockPass::createPrinterPass() Enables raw_ostream I/O for BasicBlockPass. llvm-svn: 174776
2013-02-09 00:37:41 +01:00
void initializePrintBasicBlockPassPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeProcessImplicitDefsPass(PassRegistry&);
void initializeProfileEstimatorPassPass(PassRegistry&);
void initializeProfileInfoAnalysisGroup(PassRegistry&);
Implementation of path profiling. Modified patch by Adam Preuss. This builds on the existing framework for block tracing, edge profiling and optimal edge profiling. See -help-hidden for new flags. For documentation, see the technical report "Implementation of Path Profiling..." in llvm.org/pubs. llvm-svn: 124515
2011-01-29 02:09:53 +01:00
void initializePathProfileInfoAnalysisGroup(PassRegistry&);
void initializePathProfileVerifierPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeProfileVerifierPassPass(PassRegistry&);
void initializePromotePassPass(PassRegistry&);
void initializePruneEHPass(PassRegistry&);
void initializeReassociatePass(PassRegistry&);
void initializeRegToMemPass(PassRegistry&);
void initializeRegionInfoPass(PassRegistry&);
void initializeRegionOnlyPrinterPass(PassRegistry&);
void initializeRegionOnlyViewerPass(PassRegistry&);
void initializeRegionPrinterPass(PassRegistry&);
void initializeRegionViewerPass(PassRegistry&);
void initializeSCCPPass(PassRegistry&);
Introduce a new SROA implementation. This is essentially a ground up re-think of the SROA pass in LLVM. It was initially inspired by a few problems with the existing pass: - It is subject to the bane of my existence in optimizations: arbitrary thresholds. - It is overly conservative about which constructs can be split and promoted. - The vector value replacement aspect is separated from the splitting logic, missing many opportunities where splitting and vector value formation can work together. - The splitting is entirely based around the underlying type of the alloca, despite this type often having little to do with the reality of how that memory is used. This is especially prevelant with unions and base classes where we tail-pack derived members. - When splitting fails (often due to the thresholds), the vector value replacement (again because it is separate) can kick in for preposterous cases where we simply should have split the value. This results in forming i1024 and i2048 integer "bit vectors" that tremendously slow down subsequnet IR optimizations (due to large APInts) and impede the backend's lowering. The new design takes an approach that fundamentally is not susceptible to many of these problems. It is the result of a discusison between myself and Duncan Sands over IRC about how to premptively avoid these types of problems and how to do SROA in a more principled way. Since then, it has evolved and grown, but this remains an important aspect: it fixes real world problems with the SROA process today. First, the transform of SROA actually has little to do with replacement. It has more to do with splitting. The goal is to take an aggregate alloca and form a composition of scalar allocas which can replace it and will be most suitable to the eventual replacement by scalar SSA values. The actual replacement is performed by mem2reg (and in the future SSAUpdater). The splitting is divided into four phases. The first phase is an analysis of the uses of the alloca. This phase recursively walks uses, building up a dense datastructure representing the ranges of the alloca's memory actually used and checking for uses which inhibit any aspects of the transform such as the escape of a pointer. Once we have a mapping of the ranges of the alloca used by individual operations, we compute a partitioning of the used ranges. Some uses are inherently splittable (such as memcpy and memset), while scalar uses are not splittable. The goal is to build a partitioning that has the minimum number of splits while placing each unsplittable use in its own partition. Overlapping unsplittable uses belong to the same partition. This is the target split of the aggregate alloca, and it maximizes the number of scalar accesses which become accesses to their own alloca and candidates for promotion. Third, we re-walk the uses of the alloca and assign each specific memory access to all the partitions touched so that we have dense use-lists for each partition. Finally, we build a new, smaller alloca for each partition and rewrite each use of that partition to use the new alloca. During this phase the pass will also work very hard to transform uses of an alloca into a form suitable for promotion, including forming vector operations, speculating loads throguh PHI nodes and selects, etc. After splitting is complete, each newly refined alloca that is a candidate for promotion to a scalar SSA value is run through mem2reg. There are lots of reasonably detailed comments in the source code about the design and algorithms, and I'm going to be trying to improve them in subsequent commits to ensure this is well documented, as the new pass is in many ways more complex than the old one. Some of this is still a WIP, but the current state is reasonbly stable. It has passed bootstrap, the nightly test suite, and Duncan has run it successfully through the ACATS and DragonEgg test suites. That said, it remains behind a default-off flag until the last few pieces are in place, and full testing can be done. Specific areas I'm looking at next: - Improved comments and some code cleanup from reviews. - SSAUpdater and enabling this pass inside the CGSCC pass manager. - Some datastructure tuning and compile-time measurements. - More aggressive FCA splitting and vector formation. Many thanks to Duncan Sands for the thorough final review, as well as Benjamin Kramer for lots of review during the process of writing this pass, and Daniel Berlin for reviewing the data structures and algorithms and general theory of the pass. Also, several other people on IRC, over lunch tables, etc for lots of feedback and advice. llvm-svn: 163883
2012-09-14 11:22:59 +02:00
void initializeSROAPass(PassRegistry&);
Remove outdated references to dominance frontiers. llvm-svn: 123724
2011-01-18 04:53:26 +01:00
void initializeSROA_DTPass(PassRegistry&);
split SROA into two passes: one that uses DomFrontiers (-scalarrepl) and one that uses SSAUpdater (-scalarrepl-ssa) llvm-svn: 123436
2011-01-14 09:13:00 +01:00
void initializeSROA_SSAUpPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeScalarEvolutionAliasAnalysisPass(PassRegistry&);
void initializeScalarEvolutionPass(PassRegistry&);
void initializeSimpleInlinerPass(PassRegistry&);
There is only one register coalescer. Merge it into the base class and remove the analysis group. llvm-svn: 133899
2011-06-27 00:34:10 +02:00
void initializeRegisterCoalescerPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeSingleLoopExtractorPass(PassRegistry&);
void initializeSinkingPass(PassRegistry&);
void initializeSlotIndexesPass(PassRegistry&);
Add the SpillPlacement analysis pass. This pass precomputes CFG block frequency information that can be used by the register allocator to find optimal spill code placement. Given an interference pattern, placeSpills() will compute which basic blocks should have the current variable enter or exit in a register, and which blocks prefer the stack. The algorithm is ready to consume block frequencies from profiling data, but for now it gets by with the static estimates used for spill weights. This is a work in progress and still not hooked up to RegAllocGreedy. llvm-svn: 122938
2011-01-06 02:21:53 +01:00
void initializeSpillPlacementPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeStackProtectorPass(PassRegistry&);
Add a new optimization pass: Stack Coloring, that merges disjoint static allocations (allocas). Allocas are known to be disjoint if they are marked by disjoint lifetime markers (@llvm.lifetime.XXX intrinsics). llvm-svn: 163299
2012-09-06 11:17:37 +02:00
void initializeStackColoringPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeStackSlotColoringPass(PassRegistry&);
void initializeStripDeadDebugInfoPass(PassRegistry&);
void initializeStripDeadPrototypesPassPass(PassRegistry&);
void initializeStripDebugDeclarePass(PassRegistry&);
void initializeStripNonDebugSymbolsPass(PassRegistry&);
void initializeStripSymbolsPass(PassRegistry&);
void initializeStrongPHIEliminationPass(PassRegistry&);
void initializeTailCallElimPass(PassRegistry&);
Codegen pass definition cleanup. No functionality. Moving toward a uniform style of pass definition to allow easier target configuration. Globally declare Pass ID. Globally declare pass initializer. Use INITIALIZE_PASS consistently. Add a call to the initializer from CodeGen.cpp. Remove redundant "createPass" functions and "getPassName" methods. While cleaning up declarations, cleaned up comments (sorry for large diff). llvm-svn: 150100
2012-02-08 22:23:13 +01:00
void initializeTailDuplicatePassPass(PassRegistry&);
Make TargetPassConfig an ImmutablePass so CodeGenPasses can query options llvm-svn: 149752
2012-02-04 03:56:45 +01:00
void initializeTargetPassConfigPass(PassRegistry&);
Rename the Target specific passes in the DataLayout class to be Target agnostic. llvm-svn: 165270
2012-10-05 01:01:22 +02:00
void initializeDataLayoutPass(PassRegistry&);
Convert the TargetTransformInfo from an immutable pass with dynamic interfaces which could be extracted from it, and must be provided on construction, to a chained analysis group. The end goal here is that TTI works much like AA -- there is a baseline "no-op" and target independent pass which is in the group, and each target can expose a target-specific pass in the group. These passes will naturally chain allowing each target-specific pass to delegate to the generic pass as needed. In particular, this will allow a much simpler interface for passes that would like to use TTI -- they can have a hard dependency on TTI and it will just be satisfied by the stub implementation when that is all that is available. This patch is a WIP however. In particular, the "stub" pass is actually the one and only pass, and everything there is implemented by delegating to the target-provided interfaces. As a consequence the tools still have to explicitly construct the pass. Switching targets to provide custom passes and sinking the stub behavior into the NoTTI pass is the next step. llvm-svn: 171621
2013-01-05 12:43:11 +01:00
void initializeTargetTransformInfoAnalysisGroup(PassRegistry&);
void initializeNoTTIPass(PassRegistry&);
introduce a new TargetLibraryInfo pass, which transformations can use to query about available library functions. For now this just has memset_pattern16, which exists on darwin, but it can be extended for a bunch of other things in the future. llvm-svn: 125965
2011-02-18 22:50:34 +01:00
void initializeTargetLibraryInfoPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
void initializeTwoAddressInstructionPassPass(PassRegistry&);
void initializeTypeBasedAliasAnalysisPass(PassRegistry&);
void initializeUnifyFunctionExitNodesPass(PassRegistry&);
void initializeUnreachableBlockElimPass(PassRegistry&);
void initializeUnreachableMachineBlockElimPass(PassRegistry&);
void initializeVerifierPass(PassRegistry&);
void initializeVirtRegMapPass(PassRegistry&);
Reintroduce VirtRegRewriter. OK, not really. We don't want to reintroduce the old rewriter hacks. This patch extracts virtual register rewriting as a separate pass that runs after the register allocator. This is possible now that CodeGen/Passes.cpp can configure the full optimizing register allocator pipeline. The rewriter pass uses register assignments in VirtRegMap to rewrite virtual registers to physical registers, and it inserts kill flags based on live intervals. These finalization steps are the same for the optimizing register allocators: RABasic, RAGreedy, and PBQP. llvm-svn: 158244
2012-06-09 01:44:45 +02:00
void initializeVirtRegRewriterPass(PassRegistry&);
Add a new convenience pass for testing InstructionSimplify. Previously it could only be tested indirectly, via instcombine, gvn or some other pass that makes use of InstructionSimplify, which means that testcases had to be carefully contrived to dance around any other transformations that that pass did. llvm-svn: 122264
2010-12-20 21:54:37 +01:00
void initializeInstSimplifierPass(PassRegistry&);
- Add MachineInstrBundle.h and MachineInstrBundle.cpp. This includes a function to finalize MI bundles (i.e. add BUNDLE instruction and computing register def and use lists of the BUNDLE instruction) and a pass to unpack bundles. - Teach more of MachineBasic and MachineInstr methods to be bundle aware. - Switch Thumb2 IT block to MI bundles and delete the hazard recognizer hack to prevent IT blocks from being broken apart. llvm-svn: 146542
2011-12-14 03:11:42 +01:00
void initializeUnpackMachineBundlesPass(PassRegistry&);
More bundle related API additions. llvm-svn: 148465
2012-01-19 08:47:03 +01:00
void initializeFinalizeMachineBundlesPass(PassRegistry&);
Add a loop vectorizer. llvm-svn: 166112
2012-10-17 20:25:06 +02:00
void initializeLoopVectorizePass(PassRegistry&);
Add support for bottom-up SLP vectorization infrastructure. This commit adds the infrastructure for performing bottom-up SLP vectorization (and other optimizations) on parallel computations. The infrastructure has three potential users: 1. The loop vectorizer needs to be able to vectorize AOS data structures such as (sum += A[i] + A[i+1]). 2. The BB-vectorizer needs this infrastructure for bottom-up SLP vectorization, because bottom-up vectorization is faster to compute. 3. A loop-roller needs to be able to analyze consecutive chains and roll them into a loop, in order to reduce code size. A loop roller does not need to create vector instructions, and this infrastructure separates the chain analysis from the vectorization. This patch also includes a simple (100 LOC) bottom up SLP vectorizer that uses the infrastructure, and can vectorize this code: void SAXPY(int *x, int *y, int a, int i) { x[i] = a * x[i] + y[i]; x[i+1] = a * x[i+1] + y[i+1]; x[i+2] = a * x[i+2] + y[i+2]; x[i+3] = a * x[i+3] + y[i+3]; } llvm-svn: 179117
2013-04-09 21:44:35 +02:00
void initializeSLPVectorizerPass(PassRegistry&);
Add a basic-block autovectorization pass. This is the initial checkin of the basic-block autovectorization pass along with some supporting vectorization infrastructure. Special thanks to everyone who helped review this code over the last several months (especially Tobias Grosser). llvm-svn: 149468
2012-02-01 04:51:43 +01:00
void initializeBBVectorizePass(PassRegistry&);
Add an insertPass API to TargetPassConfig. <rdar://problem/11498613> Besides adding the new insertPass function, this patch uses it to enhance the existing -print-machineinstrs so that the MachineInstrs after a specific pass can be printed. Patch by Bin Zeng! llvm-svn: 157655
2012-05-30 02:17:12 +02:00
void initializeMachineFunctionPrinterPassPass(PassRegistry&);
Add the header that I accidentally forgot from r115900. llvm-svn: 115901
2010-10-07 06:17:38 +02:00
}
#endif
Reference in New Issue Copy Permalink