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;
|
|
|
|
|
|
2016-06-09 21:58:30 +02:00
|
|
|
/// Initialize all passes linked into the TransformUtils library.
|
2010-10-07 21:51:21 +02:00
|
|
|
void initializeCore(PassRegistry&);
|
|
|
|
|
|
2016-06-09 21:58:30 +02:00
|
|
|
/// Initialize all passes linked into the TransformUtils library.
|
2010-10-07 19:55:47 +02:00
|
|
|
void initializeTransformUtils(PassRegistry&);
|
|
|
|
|
|
2016-06-09 21:58:30 +02:00
|
|
|
/// Initialize all passes linked into the ScalarOpts library.
|
2010-10-07 19:55:47 +02:00
|
|
|
void initializeScalarOpts(PassRegistry&);
|
|
|
|
|
|
2016-06-09 21:58:30 +02:00
|
|
|
/// Initialize all passes linked into the ObjCARCOpts library.
|
2013-01-28 02:35:51 +01:00
|
|
|
void initializeObjCARCOpts(PassRegistry&);
|
|
|
|
|
|
2016-06-09 21:58:30 +02:00
|
|
|
/// Initialize all passes linked into the Vectorize library.
|
2012-02-01 04:51:43 +01:00
|
|
|
void initializeVectorization(PassRegistry&);
|
|
|
|
|
|
2016-06-09 21:58:30 +02:00
|
|
|
/// Initialize all passes linked into the InstCombine library.
|
2010-10-07 22:04:55 +02:00
|
|
|
void initializeInstCombine(PassRegistry&);
|
|
|
|
|
|
2016-06-09 21:58:30 +02:00
|
|
|
/// Initialize all passes linked into the IPO library.
|
2010-10-07 20:09:59 +02:00
|
|
|
void initializeIPO(PassRegistry&);
|
|
|
|
|
|
2016-06-09 21:58:30 +02:00
|
|
|
/// Initialize all passes linked into the Instrumentation library.
|
2010-10-07 22:17:24 +02:00
|
|
|
void initializeInstrumentation(PassRegistry&);
|
|
|
|
|
|
2016-06-09 21:58:30 +02:00
|
|
|
/// Initialize all passes linked into the Analysis library.
|
2010-10-07 20:31:00 +02:00
|
|
|
void initializeAnalysis(PassRegistry&);
|
|
|
|
|
|
2016-06-09 21:58:30 +02:00
|
|
|
/// Initialize all passes linked into the CodeGen library.
|
2010-10-07 20:41:20 +02:00
|
|
|
void initializeCodeGen(PassRegistry&);
|
|
|
|
|
|
2016-03-08 02:38:55 +01:00
|
|
|
/// Initialize all passes linked into the GlobalISel library.
|
|
|
|
|
void initializeGlobalISel(PassRegistry &Registry);
|
|
|
|
|
|
2016-06-09 21:58:30 +02:00
|
|
|
/// Initialize all passes linked into the CodeGen library.
|
2010-10-07 20:50:11 +02:00
|
|
|
void initializeTarget(PassRegistry&);
|
|
|
|
|
|
2016-02-20 04:46:03 +01:00
|
|
|
void initializeAAEvalLegacyPassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeAAResultsWrapperPassPass(PassRegistry &);
|
2015-10-31 00:13:18 +01:00
|
|
|
void initializeADCELegacyPassPass(PassRegistry&);
|
2016-06-15 23:51:30 +02:00
|
|
|
void initializeAddDiscriminatorsLegacyPassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeAddressSanitizerModulePass(PassRegistry&);
|
|
|
|
|
void initializeAddressSanitizerPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeAliasSetPrinterPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeAlignmentFromAssumptionsPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeAlwaysInlinerPass(PassRegistry&);
|
|
|
|
|
void initializeArgPromotionPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeAssumptionCacheTrackerPass(PassRegistry &);
|
2014-08-21 23:50:01 +02:00
|
|
|
void initializeAtomicExpandPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeBBVectorizePass(PassRegistry&);
|
|
|
|
|
void initializeBDCELegacyPassPass(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&);
|
[PM/AA] Rebuild LLVM's alias analysis infrastructure in a way compatible
with the new pass manager, and no longer relying on analysis groups.
This builds essentially a ground-up new AA infrastructure stack for
LLVM. The core ideas are the same that are used throughout the new pass
manager: type erased polymorphism and direct composition. The design is
as follows:
- FunctionAAResults is a type-erasing alias analysis results aggregation
interface to walk a single query across a range of results from
different alias analyses. Currently this is function-specific as we
always assume that aliasing queries are *within* a function.
- AAResultBase is a CRTP utility providing stub implementations of
various parts of the alias analysis result concept, notably in several
cases in terms of other more general parts of the interface. This can
be used to implement only a narrow part of the interface rather than
the entire interface. This isn't really ideal, this logic should be
hoisted into FunctionAAResults as currently it will cause
a significant amount of redundant work, but it faithfully models the
behavior of the prior infrastructure.
- All the alias analysis passes are ported to be wrapper passes for the
legacy PM and new-style analysis passes for the new PM with a shared
result object. In some cases (most notably CFL), this is an extremely
naive approach that we should revisit when we can specialize for the
new pass manager.
- BasicAA has been restructured to reflect that it is much more
fundamentally a function analysis because it uses dominator trees and
loop info that need to be constructed for each function.
All of the references to getting alias analysis results have been
updated to use the new aggregation interface. All the preservation and
other pass management code has been updated accordingly.
The way the FunctionAAResultsWrapperPass works is to detect the
available alias analyses when run, and add them to the results object.
This means that we should be able to continue to respect when various
passes are added to the pipeline, for example adding CFL or adding TBAA
passes should just cause their results to be available and to get folded
into this. The exception to this rule is BasicAA which really needs to
be a function pass due to using dominator trees and loop info. As
a consequence, the FunctionAAResultsWrapperPass directly depends on
BasicAA and always includes it in the aggregation.
This has significant implications for preserving analyses. Generally,
most passes shouldn't bother preserving FunctionAAResultsWrapperPass
because rebuilding the results just updates the set of known AA passes.
The exception to this rule are LoopPass instances which need to preserve
all the function analyses that the loop pass manager will end up
needing. This means preserving both BasicAAWrapperPass and the
aggregating FunctionAAResultsWrapperPass.
Now, when preserving an alias analysis, you do so by directly preserving
that analysis. This is only necessary for non-immutable-pass-provided
alias analyses though, and there are only three of interest: BasicAA,
GlobalsAA (formerly GlobalsModRef), and SCEVAA. Usually BasicAA is
preserved when needed because it (like DominatorTree and LoopInfo) is
marked as a CFG-only pass. I've expanded GlobalsAA into the preserved
set everywhere we previously were preserving all of AliasAnalysis, and
I've added SCEVAA in the intersection of that with where we preserve
SCEV itself.
One significant challenge to all of this is that the CGSCC passes were
actually using the alias analysis implementations by taking advantage of
a pretty amazing set of loop holes in the old pass manager's analysis
management code which allowed analysis groups to slide through in many
cases. Moving away from analysis groups makes this problem much more
obvious. To fix it, I've leveraged the flexibility the design of the new
PM components provides to just directly construct the relevant alias
analyses for the relevant functions in the IPO passes that need them.
This is a bit hacky, but should go away with the new pass manager, and
is already in many ways cleaner than the prior state.
Another significant challenge is that various facilities of the old
alias analysis infrastructure just don't fit any more. The most
significant of these is the alias analysis 'counter' pass. That pass
relied on the ability to snoop on AA queries at different points in the
analysis group chain. Instead, I'm planning to build printing
functionality directly into the aggregation layer. I've not included
that in this patch merely to keep it smaller.
Note that all of this needs a nearly complete rewrite of the AA
documentation. I'm planning to do that, but I'd like to make sure the
new design settles, and to flesh out a bit more of what it looks like in
the new pass manager first.
Differential Revision: http://reviews.llvm.org/D12080
llvm-svn: 247167
2015-09-09 19:55:00 +02:00
|
|
|
void initializeBasicAAWrapperPassPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeBlockExtractorPassPass(PassRegistry&);
|
2015-07-15 01:40:50 +02:00
|
|
|
void initializeBlockFrequencyInfoWrapperPassPass(PassRegistry&);
|
2012-05-22 19:19:09 +02:00
|
|
|
void initializeBoundsCheckingPass(PassRegistry&);
|
2012-02-08 22:22:48 +01:00
|
|
|
void initializeBranchFolderPassPass(PassRegistry&);
|
2015-07-16 00:48:29 +02:00
|
|
|
void initializeBranchProbabilityInfoWrapperPassPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeBreakCriticalEdgesPass(PassRegistry&);
|
|
|
|
|
void initializeCFGOnlyPrinterPass(PassRegistry&);
|
|
|
|
|
void initializeCFGOnlyViewerPass(PassRegistry&);
|
|
|
|
|
void initializeCFGPrinterPass(PassRegistry&);
|
2013-08-06 04:43:45 +02:00
|
|
|
void initializeCFGSimplifyPassPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeCFGViewerPass(PassRegistry&);
|
2016-07-06 02:26:41 +02:00
|
|
|
void initializeCFLAndersAAWrapperPassPass(PassRegistry&);
|
|
|
|
|
void initializeCFLSteensAAWrapperPassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeCallGraphDOTPrinterPass(PassRegistry&);
|
|
|
|
|
void initializeCallGraphPrinterLegacyPassPass(PassRegistry&);
|
|
|
|
|
void initializeCallGraphViewerPass(PassRegistry&);
|
|
|
|
|
void initializeCallGraphWrapperPassPass(PassRegistry &);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeCodeGenPreparePass(PassRegistry&);
|
2016-07-02 02:16:47 +02:00
|
|
|
void initializeConstantHoistingLegacyPassPass(PassRegistry&);
|
2016-05-05 02:51:09 +02:00
|
|
|
void initializeConstantMergeLegacyPassPass(PassRegistry &);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeConstantPropagationPass(PassRegistry&);
|
|
|
|
|
void initializeCorrelatedValuePropagationPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeCostModelAnalysisPass(PassRegistry&);
|
2015-12-16 00:00:08 +01:00
|
|
|
void initializeCrossDSOCFIPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeDAEPass(PassRegistry&);
|
|
|
|
|
void initializeDAHPass(PassRegistry&);
|
2016-04-22 21:40:41 +02:00
|
|
|
void initializeDCELegacyPassPass(PassRegistry&);
|
2016-05-17 23:38:13 +02:00
|
|
|
void initializeDSELegacyPassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeDataFlowSanitizerPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeDeadInstEliminationPass(PassRegistry&);
|
|
|
|
|
void initializeDeadMachineInstructionElimPass(PassRegistry&);
|
2013-11-12 23:47:20 +01:00
|
|
|
void initializeDelinearizationPass(PassRegistry &);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeDemandedBitsWrapperPassPass(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&);
|
2016-05-13 00:19:39 +02:00
|
|
|
void initializeDependenceAnalysisWrapperPassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeDetectDeadLanesPass(PassRegistry&);
|
Divergence analysis for GPU programs
Summary:
Some optimizations such as jump threading and loop unswitching can negatively
affect performance when applied to divergent branches. The divergence analysis
added in this patch conservatively estimates which branches in a GPU program
can diverge. This information can then help LLVM to run certain optimizations
selectively.
Test Plan: test/Analysis/DivergenceAnalysis/NVPTX/diverge.ll
Reviewers: resistor, hfinkel, eliben, meheff, jholewinski
Subscribers: broune, bjarke.roune, madhur13490, tstellarAMD, dberlin, echristo, jholewinski, llvm-commits
Differential Revision: http://reviews.llvm.org/D8576
llvm-svn: 234567
2015-04-10 07:03:50 +02:00
|
|
|
void initializeDivergenceAnalysisPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeDomOnlyPrinterPass(PassRegistry&);
|
|
|
|
|
void initializeDomOnlyViewerPass(PassRegistry&);
|
|
|
|
|
void initializeDomPrinterPass(PassRegistry&);
|
|
|
|
|
void initializeDomViewerPass(PassRegistry&);
|
2016-02-25 18:54:15 +01:00
|
|
|
void initializeDominanceFrontierWrapperPassPass(PassRegistry&);
|
2014-01-13 14:07:17 +01:00
|
|
|
void initializeDominatorTreeWrapperPassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeDwarfEHPreparePass(PassRegistry&);
|
|
|
|
|
void initializeEarlyCSELegacyPassPass(PassRegistry &);
|
2012-07-04 02:09:54 +02:00
|
|
|
void initializeEarlyIfConverterPass(PassRegistry&);
|
2011-01-04 22:10:05 +01:00
|
|
|
void initializeEdgeBundlesPass(PassRegistry&);
|
[esan] EfficiencySanitizer instrumentation pass
Summary:
Adds an instrumentation pass for the new EfficiencySanitizer ("esan")
performance tuning family of tools. Multiple tools will be supported
within the same framework. Preliminary support for a cache fragmentation
tool is included here.
The shared instrumentation includes:
+ Turn mem{set,cpy,move} instrinsics into library calls.
+ Slowpath instrumentation of loads and stores via callouts to
the runtime library.
+ Fastpath instrumentation will be per-tool.
+ Which memory accesses to ignore will be per-tool.
Reviewers: eugenis, vitalybuka, aizatsky, filcab
Subscribers: filcab, vkalintiris, pcc, silvas, llvm-commits, zhaoqin, kcc
Differential Revision: http://reviews.llvm.org/D19167
llvm-svn: 267058
2016-04-21 23:30:22 +02:00
|
|
|
void initializeEfficiencySanitizerPass(PassRegistry&);
|
2016-05-05 04:37:32 +02:00
|
|
|
void initializeEliminateAvailableExternallyLegacyPassPass(PassRegistry &);
|
2016-07-15 15:45:20 +02:00
|
|
|
void initializeGVNHoistLegacyPassPass(PassRegistry &);
|
2010-11-18 19:45:06 +01:00
|
|
|
void initializeExpandISelPseudosPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeExpandPostRAPass(PassRegistry&);
|
|
|
|
|
void initializeExternalAAWrapperPassPass(PassRegistry&);
|
|
|
|
|
void initializeFinalizeMachineBundlesPass(PassRegistry&);
|
|
|
|
|
void initializeFlattenCFGPassPass(PassRegistry&);
|
2016-06-25 01:32:02 +02:00
|
|
|
void initializeFloat2IntLegacyPassPass(PassRegistry&);
|
2015-12-27 09:13:45 +01:00
|
|
|
void initializeForceFunctionAttrsLegacyPassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeForwardControlFlowIntegrityPass(PassRegistry&);
|
|
|
|
|
void initializeFuncletLayoutPass(PassRegistry &);
|
|
|
|
|
void initializeFunctionImportPassPass(PassRegistry &);
|
2012-02-08 22:23:13 +01:00
|
|
|
void initializeGCMachineCodeAnalysisPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeGCModuleInfoPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeGCOVProfilerLegacyPassPass(PassRegistry&);
|
2016-03-11 09:50:55 +01:00
|
|
|
void initializeGVNLegacyPassPass(PassRegistry&);
|
2016-05-03 21:39:15 +02:00
|
|
|
void initializeGlobalDCELegacyPassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeGlobalMergePass(PassRegistry&);
|
2016-04-26 02:28:01 +02:00
|
|
|
void initializeGlobalOptLegacyPassPass(PassRegistry&);
|
[PM/AA] Rebuild LLVM's alias analysis infrastructure in a way compatible
with the new pass manager, and no longer relying on analysis groups.
This builds essentially a ground-up new AA infrastructure stack for
LLVM. The core ideas are the same that are used throughout the new pass
manager: type erased polymorphism and direct composition. The design is
as follows:
- FunctionAAResults is a type-erasing alias analysis results aggregation
interface to walk a single query across a range of results from
different alias analyses. Currently this is function-specific as we
always assume that aliasing queries are *within* a function.
- AAResultBase is a CRTP utility providing stub implementations of
various parts of the alias analysis result concept, notably in several
cases in terms of other more general parts of the interface. This can
be used to implement only a narrow part of the interface rather than
the entire interface. This isn't really ideal, this logic should be
hoisted into FunctionAAResults as currently it will cause
a significant amount of redundant work, but it faithfully models the
behavior of the prior infrastructure.
- All the alias analysis passes are ported to be wrapper passes for the
legacy PM and new-style analysis passes for the new PM with a shared
result object. In some cases (most notably CFL), this is an extremely
naive approach that we should revisit when we can specialize for the
new pass manager.
- BasicAA has been restructured to reflect that it is much more
fundamentally a function analysis because it uses dominator trees and
loop info that need to be constructed for each function.
All of the references to getting alias analysis results have been
updated to use the new aggregation interface. All the preservation and
other pass management code has been updated accordingly.
The way the FunctionAAResultsWrapperPass works is to detect the
available alias analyses when run, and add them to the results object.
This means that we should be able to continue to respect when various
passes are added to the pipeline, for example adding CFL or adding TBAA
passes should just cause their results to be available and to get folded
into this. The exception to this rule is BasicAA which really needs to
be a function pass due to using dominator trees and loop info. As
a consequence, the FunctionAAResultsWrapperPass directly depends on
BasicAA and always includes it in the aggregation.
This has significant implications for preserving analyses. Generally,
most passes shouldn't bother preserving FunctionAAResultsWrapperPass
because rebuilding the results just updates the set of known AA passes.
The exception to this rule are LoopPass instances which need to preserve
all the function analyses that the loop pass manager will end up
needing. This means preserving both BasicAAWrapperPass and the
aggregating FunctionAAResultsWrapperPass.
Now, when preserving an alias analysis, you do so by directly preserving
that analysis. This is only necessary for non-immutable-pass-provided
alias analyses though, and there are only three of interest: BasicAA,
GlobalsAA (formerly GlobalsModRef), and SCEVAA. Usually BasicAA is
preserved when needed because it (like DominatorTree and LoopInfo) is
marked as a CFG-only pass. I've expanded GlobalsAA into the preserved
set everywhere we previously were preserving all of AliasAnalysis, and
I've added SCEVAA in the intersection of that with where we preserve
SCEV itself.
One significant challenge to all of this is that the CGSCC passes were
actually using the alias analysis implementations by taking advantage of
a pretty amazing set of loop holes in the old pass manager's analysis
management code which allowed analysis groups to slide through in many
cases. Moving away from analysis groups makes this problem much more
obvious. To fix it, I've leveraged the flexibility the design of the new
PM components provides to just directly construct the relevant alias
analyses for the relevant functions in the IPO passes that need them.
This is a bit hacky, but should go away with the new pass manager, and
is already in many ways cleaner than the prior state.
Another significant challenge is that various facilities of the old
alias analysis infrastructure just don't fit any more. The most
significant of these is the alias analysis 'counter' pass. That pass
relied on the ability to snoop on AA queries at different points in the
analysis group chain. Instead, I'm planning to build printing
functionality directly into the aggregation layer. I've not included
that in this patch merely to keep it smaller.
Note that all of this needs a nearly complete rewrite of the AA
documentation. I'm planning to do that, but I'd like to make sure the
new design settles, and to flesh out a bit more of what it looks like in
the new pass manager first.
Differential Revision: http://reviews.llvm.org/D12080
llvm-svn: 247167
2015-09-09 19:55:00 +02:00
|
|
|
void initializeGlobalsAAWrapperPassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeGuardWideningLegacyPassPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeIPCPPass(PassRegistry&);
|
2016-05-05 23:05:36 +02:00
|
|
|
void initializeIPSCCPLegacyPassPass(PassRegistry &);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeIRTranslatorPass(PassRegistry &);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeIVUsersPass(PassRegistry&);
|
|
|
|
|
void initializeIfConverterPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeImplicitNullChecksPass(PassRegistry&);
|
2016-05-29 23:42:00 +02:00
|
|
|
void initializeIndVarSimplifyLegacyPassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeInductiveRangeCheckEliminationPass(PassRegistry&);
|
2015-12-27 09:41:34 +01:00
|
|
|
void initializeInferFunctionAttrsLegacyPassPass(PassRegistry&);
|
2013-01-21 12:39:18 +01:00
|
|
|
void initializeInlineCostAnalysisPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeInstCountPass(PassRegistry&);
|
|
|
|
|
void initializeInstNamerPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeInstSimplifierPass(PassRegistry&);
|
|
|
|
|
void initializeInstrProfilingLegacyPassPass(PassRegistry &);
|
|
|
|
|
void initializeInstructionCombiningPassPass(PassRegistry&);
|
2016-05-19 22:08:32 +02:00
|
|
|
void initializeInterleavedAccessPass(PassRegistry &);
|
2016-04-26 22:15:52 +02:00
|
|
|
void initializeInternalizeLegacyPassPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeIntervalPartitionPass(PassRegistry&);
|
|
|
|
|
void initializeJumpThreadingPass(PassRegistry&);
|
2016-06-09 21:44:46 +02:00
|
|
|
void initializeLCSSAWrapperPassPass(PassRegistry &);
|
2016-07-13 00:37:48 +02:00
|
|
|
void initializeLegacyLICMPassPass(PassRegistry&);
|
2016-07-13 07:01:48 +02:00
|
|
|
void initializeLazyBlockFrequencyInfoPassPass(PassRegistry&);
|
2016-06-14 00:01:25 +02:00
|
|
|
void initializeLazyValueInfoWrapperPassPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeLintPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeLiveDebugValuesPass(PassRegistry&);
|
2010-11-30 03:17:10 +01:00
|
|
|
void initializeLiveDebugVariablesPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeLiveIntervalsPass(PassRegistry&);
|
2012-06-09 04:13:10 +02:00
|
|
|
void initializeLiveRegMatrixPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeLiveStacksPass(PassRegistry&);
|
|
|
|
|
void initializeLiveVariablesPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeLoadCombinePass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeLoaderPassPass(PassRegistry&);
|
2016-07-01 01:11:38 +02:00
|
|
|
void initializeLoadStoreVectorizerPass(PassRegistry&);
|
2012-02-08 22:23:13 +01:00
|
|
|
void initializeLocalStackSlotPassPass(PassRegistry&);
|
2016-07-08 22:55:26 +02:00
|
|
|
void initializeLoopAccessLegacyAnalysisPass(PassRegistry&);
|
2016-02-22 22:41:22 +01:00
|
|
|
void initializeLoopDataPrefetchPass(PassRegistry&);
|
2016-07-14 20:28:29 +02:00
|
|
|
void initializeLoopDeletionLegacyPassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeLoopDistributePass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeLoopExtractorPass(PassRegistry&);
|
2016-07-12 20:45:51 +02:00
|
|
|
void initializeLoopIdiomRecognizeLegacyPassPass(PassRegistry&);
|
2015-01-17 15:16:18 +01:00
|
|
|
void initializeLoopInfoWrapperPassPass(PassRegistry&);
|
2016-07-15 18:42:11 +02:00
|
|
|
void initializeLoopInstSimplifyLegacyPassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeLoopInterchangePass(PassRegistry &);
|
|
|
|
|
void initializeLoopLoadEliminationPass(PassRegistry&);
|
|
|
|
|
void initializeLoopPassPass(PassRegistry&);
|
|
|
|
|
void initializeLoopRerollPass(PassRegistry&);
|
2016-05-04 00:02:31 +02:00
|
|
|
void initializeLoopRotateLegacyPassPass(PassRegistry&);
|
2016-05-03 23:47:32 +02:00
|
|
|
void initializeLoopSimplifyCFGLegacyPassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeLoopSimplifyPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeLoopStrengthReducePass(PassRegistry&);
|
|
|
|
|
void initializeLoopUnrollPass(PassRegistry&);
|
|
|
|
|
void initializeLoopUnswitchPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeLoopVectorizePass(PassRegistry&);
|
New Loop Versioning LICM Pass
Summary:
When alias analysis is uncertain about the aliasing between any two accesses,
it will return MayAlias. This uncertainty from alias analysis restricts LICM
from proceeding further. In cases where alias analysis is uncertain we might
use loop versioning as an alternative.
Loop Versioning will create a version of the loop with aggressive aliasing
assumptions in addition to the original with conservative (default) aliasing
assumptions. The version of the loop making aggressive aliasing assumptions
will have all the memory accesses marked as no-alias. These two versions of
loop will be preceded by a memory runtime check. This runtime check consists
of bound checks for all unique memory accessed in loop, and it ensures the
lack of memory aliasing. The result of the runtime check determines which of
the loop versions is executed: If the runtime check detects any memory
aliasing, then the original loop is executed. Otherwise, the version with
aggressive aliasing assumptions is used.
The pass is off by default and can be enabled with command line option
-enable-loop-versioning-licm.
Reviewers: hfinkel, anemet, chatur01, reames
Subscribers: MatzeB, grosser, joker.eph, sanjoy, javed.absar, sbaranga,
llvm-commits
Differential Revision: http://reviews.llvm.org/D9151
llvm-svn: 259986
2016-02-06 08:47:48 +01:00
|
|
|
void initializeLoopVersioningLICMPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeLoopVersioningPassPass(PassRegistry &);
|
2016-05-14 00:52:35 +02:00
|
|
|
void initializeLowerAtomicLegacyPassPass(PassRegistry &);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeLowerEmuTLSPass(PassRegistry&);
|
2011-07-06 20:22:43 +02:00
|
|
|
void initializeLowerExpectIntrinsicPass(PassRegistry&);
|
2016-03-31 02:18:46 +02:00
|
|
|
void initializeLowerGuardIntrinsicPass(PassRegistry&);
|
2010-10-19 19:21:58 +02:00
|
|
|
void initializeLowerIntrinsicsPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeLowerInvokePass(PassRegistry&);
|
|
|
|
|
void initializeLowerSwitchPass(PassRegistry&);
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-24 23:21:32 +02:00
|
|
|
void initializeLowerTypeTestsPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeMIRPrintingPassPass(PassRegistry&);
|
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&);
|
2011-11-02 08:17:12 +01:00
|
|
|
void initializeMachineBlockPlacementStatsPass(PassRegistry&);
|
2011-06-16 22:22:37 +02:00
|
|
|
void initializeMachineBranchProbabilityInfoPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeMachineCSEPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeMachineCombinerPass(PassRegistry &);
|
|
|
|
|
void initializeMachineCopyPropagationPass(PassRegistry&);
|
2014-07-12 23:59:52 +02:00
|
|
|
void initializeMachineDominanceFrontierPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeMachineDominatorTreePass(PassRegistry&);
|
|
|
|
|
void initializeMachineFunctionPrinterPassPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeMachineLICMPass(PassRegistry&);
|
|
|
|
|
void initializeMachineLoopInfoPass(PassRegistry&);
|
|
|
|
|
void initializeMachineModuleInfoPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeMachinePostDominatorTreePass(PassRegistry&);
|
2014-07-19 20:29:29 +02:00
|
|
|
void initializeMachineRegionInfoPassPass(PassRegistry&);
|
2012-01-17 07:55:03 +01:00
|
|
|
void initializeMachineSchedulerPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeMachineSinkingPass(PassRegistry&);
|
2012-07-26 20:38:11 +02:00
|
|
|
void initializeMachineTraceMetricsPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeMachineVerifierPassPass(PassRegistry&);
|
2016-06-14 04:44:55 +02:00
|
|
|
void initializeMemCpyOptLegacyPassPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeMemDepPrinterPass(PassRegistry&);
|
2015-02-06 02:46:42 +01:00
|
|
|
void initializeMemDerefPrinterPass(PassRegistry&);
|
2016-03-10 01:55:30 +01:00
|
|
|
void initializeMemoryDependenceWrapperPassPass(PassRegistry&);
|
2016-06-01 23:30:40 +02:00
|
|
|
void initializeMemorySSAWrapperPassPass(PassRegistry&);
|
2016-07-06 23:20:47 +02:00
|
|
|
void initializeMemorySSAPrinterLegacyPassPass(PassRegistry &);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeMemorySanitizerPass(PassRegistry&);
|
|
|
|
|
void initializeMergeFunctionsPass(PassRegistry&);
|
2016-06-17 21:10:09 +02:00
|
|
|
void initializeMergedLoadStoreMotionLegacyPassPass(PassRegistry &);
|
2012-09-11 04:46:18 +02:00
|
|
|
void initializeMetaRenamerPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeModuleDebugInfoPrinterPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeModuleSummaryIndexWrapperPassPass(PassRegistry &);
|
2016-04-12 23:35:28 +02:00
|
|
|
void initializeNameAnonFunctionPass(PassRegistry &);
|
2015-04-14 06:59:22 +02:00
|
|
|
void initializeNaryReassociatePass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeNoAAPass(PassRegistry&);
|
[PM/AA] Rebuild LLVM's alias analysis infrastructure in a way compatible
with the new pass manager, and no longer relying on analysis groups.
This builds essentially a ground-up new AA infrastructure stack for
LLVM. The core ideas are the same that are used throughout the new pass
manager: type erased polymorphism and direct composition. The design is
as follows:
- FunctionAAResults is a type-erasing alias analysis results aggregation
interface to walk a single query across a range of results from
different alias analyses. Currently this is function-specific as we
always assume that aliasing queries are *within* a function.
- AAResultBase is a CRTP utility providing stub implementations of
various parts of the alias analysis result concept, notably in several
cases in terms of other more general parts of the interface. This can
be used to implement only a narrow part of the interface rather than
the entire interface. This isn't really ideal, this logic should be
hoisted into FunctionAAResults as currently it will cause
a significant amount of redundant work, but it faithfully models the
behavior of the prior infrastructure.
- All the alias analysis passes are ported to be wrapper passes for the
legacy PM and new-style analysis passes for the new PM with a shared
result object. In some cases (most notably CFL), this is an extremely
naive approach that we should revisit when we can specialize for the
new pass manager.
- BasicAA has been restructured to reflect that it is much more
fundamentally a function analysis because it uses dominator trees and
loop info that need to be constructed for each function.
All of the references to getting alias analysis results have been
updated to use the new aggregation interface. All the preservation and
other pass management code has been updated accordingly.
The way the FunctionAAResultsWrapperPass works is to detect the
available alias analyses when run, and add them to the results object.
This means that we should be able to continue to respect when various
passes are added to the pipeline, for example adding CFL or adding TBAA
passes should just cause their results to be available and to get folded
into this. The exception to this rule is BasicAA which really needs to
be a function pass due to using dominator trees and loop info. As
a consequence, the FunctionAAResultsWrapperPass directly depends on
BasicAA and always includes it in the aggregation.
This has significant implications for preserving analyses. Generally,
most passes shouldn't bother preserving FunctionAAResultsWrapperPass
because rebuilding the results just updates the set of known AA passes.
The exception to this rule are LoopPass instances which need to preserve
all the function analyses that the loop pass manager will end up
needing. This means preserving both BasicAAWrapperPass and the
aggregating FunctionAAResultsWrapperPass.
Now, when preserving an alias analysis, you do so by directly preserving
that analysis. This is only necessary for non-immutable-pass-provided
alias analyses though, and there are only three of interest: BasicAA,
GlobalsAA (formerly GlobalsModRef), and SCEVAA. Usually BasicAA is
preserved when needed because it (like DominatorTree and LoopInfo) is
marked as a CFG-only pass. I've expanded GlobalsAA into the preserved
set everywhere we previously were preserving all of AliasAnalysis, and
I've added SCEVAA in the intersection of that with where we preserve
SCEV itself.
One significant challenge to all of this is that the CGSCC passes were
actually using the alias analysis implementations by taking advantage of
a pretty amazing set of loop holes in the old pass manager's analysis
management code which allowed analysis groups to slide through in many
cases. Moving away from analysis groups makes this problem much more
obvious. To fix it, I've leveraged the flexibility the design of the new
PM components provides to just directly construct the relevant alias
analyses for the relevant functions in the IPO passes that need them.
This is a bit hacky, but should go away with the new pass manager, and
is already in many ways cleaner than the prior state.
Another significant challenge is that various facilities of the old
alias analysis infrastructure just don't fit any more. The most
significant of these is the alias analysis 'counter' pass. That pass
relied on the ability to snoop on AA queries at different points in the
analysis group chain. Instead, I'm planning to build printing
functionality directly into the aggregation layer. I've not included
that in this patch merely to keep it smaller.
Note that all of this needs a nearly complete rewrite of the AA
documentation. I'm planning to do that, but I'd like to make sure the
new design settles, and to flesh out a bit more of what it looks like in
the new pass manager first.
Differential Revision: http://reviews.llvm.org/D12080
llvm-svn: 247167
2015-09-09 19:55:00 +02:00
|
|
|
void initializeObjCARCAAWrapperPassPass(PassRegistry&);
|
2012-01-17 21:52:24 +01:00
|
|
|
void initializeObjCARCAPElimPass(PassRegistry&);
|
2011-06-16 01:37:01 +02:00
|
|
|
void initializeObjCARCContractPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeObjCARCExpandPass(PassRegistry&);
|
2011-06-16 01:37:01 +02:00
|
|
|
void initializeObjCARCOptPass(PassRegistry&);
|
2016-07-15 19:23:20 +02:00
|
|
|
void initializeOptimizationRemarkEmitterPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeOptimizePHIsPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializePAEvalPass(PassRegistry &);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializePEIPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializePGOIndirectCallPromotionLegacyPassPass(PassRegistry&);
|
|
|
|
|
void initializePGOInstrumentationGenLegacyPassPass(PassRegistry&);
|
|
|
|
|
void initializePGOInstrumentationUseLegacyPassPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializePHIEliminationPass(PassRegistry&);
|
2016-06-10 18:19:46 +02:00
|
|
|
void initializePhysicalRegisterUsageInfoPass(PassRegistry &);
|
2016-06-27 18:50:18 +02:00
|
|
|
void initializePartialInlinerLegacyPassPass(PassRegistry &);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializePartiallyInlineLibCallsLegacyPassPass(PassRegistry &);
|
|
|
|
|
void initializePatchableFunctionPass(PassRegistry &);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializePeepholeOptimizerPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializePlaceBackedgeSafepointsImplPass(PassRegistry&);
|
|
|
|
|
void initializePlaceSafepointsPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializePostDomOnlyPrinterPass(PassRegistry&);
|
|
|
|
|
void initializePostDomOnlyViewerPass(PassRegistry&);
|
|
|
|
|
void initializePostDomPrinterPass(PassRegistry&);
|
|
|
|
|
void initializePostDomViewerPass(PassRegistry&);
|
2016-02-25 18:54:07 +01:00
|
|
|
void initializePostDominatorTreeWrapperPassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializePostMachineSchedulerPass(PassRegistry&);
|
2016-02-18 12:03:11 +01:00
|
|
|
void initializePostOrderFunctionAttrsLegacyPassPass(PassRegistry&);
|
2016-04-22 16:43:50 +02:00
|
|
|
void initializePostRAHazardRecognizerPass(PassRegistry&);
|
2012-02-08 22:23:13 +01:00
|
|
|
void initializePostRASchedulerPass(PassRegistry&);
|
2016-06-24 22:13:42 +02:00
|
|
|
void initializePreISelIntrinsicLoweringLegacyPassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializePrintBasicBlockPassPass(PassRegistry&);
|
2014-01-12 13:15:39 +01:00
|
|
|
void initializePrintFunctionPassWrapperPass(PassRegistry&);
|
|
|
|
|
void initializePrintModulePassWrapperPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeProcessImplicitDefsPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeProfileSummaryInfoWrapperPassPass(PassRegistry &);
|
2016-06-14 05:22:22 +02:00
|
|
|
void initializePromoteLegacyPassPass(PassRegistry &);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializePruneEHPass(PassRegistry&);
|
2016-04-27 01:39:29 +02:00
|
|
|
void initializeReassociateLegacyPassPass(PassRegistry&);
|
2016-04-05 21:06:01 +02:00
|
|
|
void initializeRegBankSelectPass(PassRegistry &);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeRegToMemPass(PassRegistry&);
|
2014-07-19 20:29:29 +02:00
|
|
|
void initializeRegionInfoPassPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeRegionOnlyPrinterPass(PassRegistry&);
|
|
|
|
|
void initializeRegionOnlyViewerPass(PassRegistry&);
|
|
|
|
|
void initializeRegionPrinterPass(PassRegistry&);
|
|
|
|
|
void initializeRegionViewerPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeRegisterCoalescerPass(PassRegistry&);
|
2016-06-01 00:38:06 +02:00
|
|
|
void initializeRenameIndependentSubregsPass(PassRegistry&);
|
[PM] Port ReversePostOrderFunctionAttrs to the new PM
Below are my super rough notes when porting. They can probably serve as
a basic guide for porting other passes to the new PM. As I port more
passes I'll expand and generalize this and make a proper
docs/HowToPortToNewPassManager.rst document. There is also missing
documentation for general concepts and API's in the new PM which will
require some documentation.
Once there is proper documentation in place we can put up a list of
passes that have to be ported and game-ify/crowdsource the rest of the
porting (at least of the middle end; the backend is still unclear).
I will however be taking personal responsibility for ensuring that the
LLD/ELF LTO pipeline is ported in a timely fashion. The remaining passes
to be ported are (do something like
`git grep "<the string in the bullet point below>"` to find the pass):
General Scalar:
[ ] Simplify the CFG
[ ] Jump Threading
[ ] MemCpy Optimization
[ ] Promote Memory to Register
[ ] MergedLoadStoreMotion
[ ] Lazy Value Information Analysis
General IPO:
[ ] Dead Argument Elimination
[ ] Deduce function attributes in RPO
Loop stuff / vectorization stuff:
[ ] Alignment from assumptions
[ ] Canonicalize natural loops
[ ] Delete dead loops
[ ] Loop Access Analysis
[ ] Loop Invariant Code Motion
[ ] Loop Vectorization
[ ] SLP Vectorizer
[ ] Unroll loops
Devirtualization / CFI:
[ ] Cross-DSO CFI
[ ] Whole program devirtualization
[ ] Lower bitset metadata
CGSCC passes:
[ ] Function Integration/Inlining
[ ] Remove unused exception handling info
[ ] Promote 'by reference' arguments to scalars
Please let me know if you are interested in working on any of the passes
in the above list (e.g. reply to the post-commit thread for this patch).
I'll probably be tackling "General Scalar" and "General IPO" first FWIW.
Steps as I port "Deduce function attributes in RPO"
---------------------------------------------------
(note: if you are doing any work based on these notes, please leave a
note in the post-commit review thread for this commit with any
improvements / suggestions / incompleteness you ran into!)
Note: "Deduce function attributes in RPO" is a module pass.
1. Do preparatory refactoring.
Do preparatory factoring. In this case all I had to do was to pull out a static helper (r272503).
(TODO: give more advice here e.g. if pass holds state or something)
2. Rename the old pass class.
llvm/lib/Transforms/IPO/FunctionAttrs.cpp
Rename class ReversePostOrderFunctionAttrs -> ReversePostOrderFunctionAttrsLegacyPass
in preparation for adding a class ReversePostOrderFunctionAttrs as the pass in the new PM.
(edit: actually wait what? The new class name will be
ReversePostOrderFunctionAttrsPass, so it doesn't conflict. So this step is
sort of useless churn).
llvm/include/llvm/InitializePasses.h
llvm/lib/LTO/LTOCodeGenerator.cpp
llvm/lib/Transforms/IPO/IPO.cpp
llvm/lib/Transforms/IPO/FunctionAttrs.cpp
Rename initializeReversePostOrderFunctionAttrsPass -> initializeReversePostOrderFunctionAttrsLegacyPassPass
(note that the "PassPass" thing falls out of `s/ReversePostOrderFunctionAttrs/ReversePostOrderFunctionAttrsLegacyPass/`)
Note that the INITIALIZE_PASS macro is what creates this identifier name, so renaming the class requires this renaming too.
Note that createReversePostOrderFunctionAttrsPass does not need to be
renamed since its name is not generated from the class name.
3. Add the new PM pass class.
In the new PM all passes need to have their
declaration in a header somewhere, so you will often need to add a header.
In this case
llvm/include/llvm/Transforms/IPO/FunctionAttrs.h is already there because
PostOrderFunctionAttrsPass was already ported.
The file-level comment from the .cpp file can be used as the file-level
comment for the new header. You may want to tweak the wording slightly
from "this file implements" to "this file provides" or similar.
Add declaration for the new PM pass in this header:
class ReversePostOrderFunctionAttrsPass
: public PassInfoMixin<ReversePostOrderFunctionAttrsPass> {
public:
PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM);
};
Its name should end with `Pass` for consistency (note that this doesn't
collide with the names of most old PM passes). E.g. call it
`<name of the old PM pass>Pass`.
Also, move the doxygen comment from the old PM pass to the declaration of
this class in the header.
Also, include the declaration for the new PM class
`llvm/Transforms/IPO/FunctionAttrs.h` at the top of the file (in this case,
it was already done when the other pass in this file was ported).
Now define the `run` method for the new class.
The main things here are:
a) Use AM.getResult<...>(M) to get results instead of `getAnalysis<...>()`
b) If the old PM pass would have returned "false" (i.e. `Changed ==
false`), then you should return PreservedAnalyses::all();
c) In the old PM getAnalysisUsage method, observe the calls
`AU.addPreserved<...>();`.
In the case `Changed == true`, for each preserved analysis you should do
call `PA.preserve<...>()` on a PreservedAnalyses object and return it.
E.g.:
PreservedAnalyses PA;
PA.preserve<CallGraphAnalysis>();
return PA;
Note that calls to skipModule/skipFunction are not supported in the new PM
currently, so optnone and optimization bisect support do not work. You can
just drop those calls for now.
4. Add the pass to the new PM pass registry to make it available in opt.
In llvm/lib/Passes/PassBuilder.cpp add a #include for your header.
`#include "llvm/Transforms/IPO/FunctionAttrs.h"`
In this case there is already an include (from when
PostOrderFunctionAttrsPass was ported).
Add your pass to llvm/lib/Passes/PassRegistry.def
In this case, I added
`MODULE_PASS("rpo-functionattrs", ReversePostOrderFunctionAttrsPass())`
The string is from the `INITIALIZE_PASS*` macros used in the old pass
manager.
Then choose a test that uses the pass and use the new PM `-passes=...` to
run it.
E.g. in this case there is a test that does:
; RUN: opt < %s -basicaa -functionattrs -rpo-functionattrs -S | FileCheck %s
I have added the line:
; RUN: opt < %s -aa-pipeline=basic-aa -passes='require<targetlibinfo>,cgscc(function-attrs),rpo-functionattrs' -S | FileCheck %s
The `-aa-pipeline=basic-aa` and
`require<targetlibinfo>,cgscc(function-attrs)` are what is needed to run
functionattrs in the new PM (note that in the new PM "functionattrs"
becomes "function-attrs" for some reason). This is just pulled from
`readattrs.ll` which contains the change from when functionattrs was ported
to the new PM.
Adding rpo-functionattrs causes the pass that was just ported to run.
llvm-svn: 272505
2016-06-12 09:48:51 +02:00
|
|
|
void initializeReversePostOrderFunctionAttrsLegacyPassPass(PassRegistry&);
|
Add a pass for constructing gc.statepoint sequences w/explicit relocations
This patch consists of a single pass whose only purpose is to visit previous inserted gc.statepoints which do not have gc.relocates inserted yet, and insert them. This can be used either immediately after IR generation to perform 'early safepoint insertion' or late in the pass order to perform 'late insertion'.
This patch is setting the stage for work to continue in tree. In particular, there are known naming and style violations in the current patch. I'll try to get those resolved over the next week or so. As I touch each area to make style changes, I need to make sure we have adequate testing in place. As part of the cleanup, I will be cleaning up a collection of test cases we have out of tree and submitting them upstream. The tests included in this change are very basic and mostly to provide examples of usage.
The pass has several main subproblems it needs to address:
- First, it has identify any live pointers. In the current code, the use of address spaces to distinguish pointers to GC managed objects is hard coded, but this will become parametrizable in the near future. Note that the current change doesn't actually contain a useful liveness analysis. It was seperated into a followup change as the code wasn't ready to be shared. Instead, the current implementation just considers any dominating def of appropriate pointer type to be live.
- Second, it has to identify base pointers for each live pointer. This is a fairly straight forward data flow algorithm.
- Third, the information in the previous steps is used to actually introduce rewrites. Rather than trying to do this by hand, we simply re-purpose the code behind Mem2Reg to do this for us.
llvm-svn: 229945
2015-02-20 02:06:44 +01:00
|
|
|
void initializeRewriteStatepointsForGCPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeRewriteSymbolsPass(PassRegistry&);
|
2016-05-18 17:18:25 +02:00
|
|
|
void initializeSCCPLegacyPassPass(PassRegistry &);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeSCEVAAWrapperPassPass(PassRegistry&);
|
|
|
|
|
void initializeSLPVectorizerPass(PassRegistry&);
|
2015-09-12 11:09:14 +02:00
|
|
|
void initializeSROALegacyPassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeSafeStackPass(PassRegistry&);
|
|
|
|
|
void initializeSampleProfileLoaderLegacyPassPass(PassRegistry&);
|
|
|
|
|
void initializeSanitizerCoverageModulePass(PassRegistry&);
|
[PM] Port ScalarEvolution to the new pass manager.
This change makes ScalarEvolution a stand-alone object and just produces
one from a pass as needed. Making this work well requires making the
object movable, using references instead of overwritten pointers in
a number of places, and other refactorings.
I've also wired it up to the new pass manager and added a RUN line to
a test to exercise it under the new pass manager. This includes basic
printing support much like with other analyses.
But there is a big and somewhat scary change here. Prior to this patch
ScalarEvolution was never *actually* invalidated!!! Re-running the pass
just re-wired up the various other analyses and didn't remove any of the
existing entries in the SCEV caches or clear out anything at all. This
might seem OK as everything in SCEV that can uses ValueHandles to track
updates to the values that serve as SCEV keys. However, this still means
that as we ran SCEV over each function in the module, we kept
accumulating more and more SCEVs into the cache. At the end, we would
have a SCEV cache with every value that we ever needed a SCEV for in the
entire module!!! Yowzers. The releaseMemory routine would dump all of
this, but that isn't realy called during normal runs of the pipeline as
far as I can see.
To make matters worse, there *is* actually a key that we don't update
with value handles -- there is a map keyed off of Loop*s. Because
LoopInfo *does* release its memory from run to run, it is entirely
possible to run SCEV over one function, then over another function, and
then lookup a Loop* from the second function but find an entry inserted
for the first function! Ouch.
To make matters still worse, there are plenty of updates that *don't*
trip a value handle. It seems incredibly unlikely that today GVN or
another pass that invalidates SCEV can update values in *just* such
a way that a subsequent run of SCEV will incorrectly find lookups in
a cache, but it is theoretically possible and would be a nightmare to
debug.
With this refactoring, I've fixed all this by actually destroying and
recreating the ScalarEvolution object from run to run. Technically, this
could increase the amount of malloc traffic we see, but then again it is
also technically correct. ;] I don't actually think we're suffering from
tons of malloc traffic from SCEV because if we were, the fact that we
never clear the memory would seem more likely to have come up as an
actual problem before now. So, I've made the simple fix here. If in fact
there are serious issues with too much allocation and deallocation,
I can work on a clever fix that preserves the allocations (while
clearing the data) between each run, but I'd prefer to do that kind of
optimization with a test case / benchmark that shows why we need such
cleverness (and that can test that we actually make it faster). It's
possible that this will make some things faster by making the SCEV
caches have higher locality (due to being significantly smaller) so
until there is a clear benchmark, I think the simple change is best.
Differential Revision: http://reviews.llvm.org/D12063
llvm-svn: 245193
2015-08-17 04:08:17 +02:00
|
|
|
void initializeScalarEvolutionWrapperPassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeScalarizerPass(PassRegistry&);
|
|
|
|
|
void initializeScopedNoAliasAAWrapperPassPass(PassRegistry&);
|
|
|
|
|
void initializeSeparateConstOffsetFromGEPPass(PassRegistry &);
|
|
|
|
|
void initializeShadowStackGCLoweringPass(PassRegistry&);
|
[ShrinkWrap] Add (a simplified version) of shrink-wrapping.
This patch introduces a new pass that computes the safe point to insert the
prologue and epilogue of the function.
The interest is to find safe points that are cheaper than the entry and exits
blocks.
As an example and to avoid regressions to be introduce, this patch also
implements the required bits to enable the shrink-wrapping pass for AArch64.
** Context **
Currently we insert the prologue and epilogue of the method/function in the
entry and exits blocks. Although this is correct, we can do a better job when
those are not immediately required and insert them at less frequently executed
places.
The job of the shrink-wrapping pass is to identify such places.
** Motivating example **
Let us consider the following function that perform a call only in one branch of
a if:
define i32 @f(i32 %a, i32 %b) {
%tmp = alloca i32, align 4
%tmp2 = icmp slt i32 %a, %b
br i1 %tmp2, label %true, label %false
true:
store i32 %a, i32* %tmp, align 4
%tmp4 = call i32 @doSomething(i32 0, i32* %tmp)
br label %false
false:
%tmp.0 = phi i32 [ %tmp4, %true ], [ %a, %0 ]
ret i32 %tmp.0
}
On AArch64 this code generates (removing the cfi directives to ease
readabilities):
_f: ; @f
; BB#0:
stp x29, x30, [sp, #-16]!
mov x29, sp
sub sp, sp, #16 ; =16
cmp w0, w1
b.ge LBB0_2
; BB#1: ; %true
stur w0, [x29, #-4]
sub x1, x29, #4 ; =4
mov w0, wzr
bl _doSomething
LBB0_2: ; %false
mov sp, x29
ldp x29, x30, [sp], #16
ret
With shrink-wrapping we could generate:
_f: ; @f
; BB#0:
cmp w0, w1
b.ge LBB0_2
; BB#1: ; %true
stp x29, x30, [sp, #-16]!
mov x29, sp
sub sp, sp, #16 ; =16
stur w0, [x29, #-4]
sub x1, x29, #4 ; =4
mov w0, wzr
bl _doSomething
add sp, x29, #16 ; =16
ldp x29, x30, [sp], #16
LBB0_2: ; %false
ret
Therefore, we would pay the overhead of setting up/destroying the frame only if
we actually do the call.
** Proposed Solution **
This patch introduces a new machine pass that perform the shrink-wrapping
analysis (See the comments at the beginning of ShrinkWrap.cpp for more details).
It then stores the safe save and restore point into the MachineFrameInfo
attached to the MachineFunction.
This information is then used by the PrologEpilogInserter (PEI) to place the
related code at the right place. This pass runs right before the PEI.
Unlike the original paper of Chow from PLDI’88, this implementation of
shrink-wrapping does not use expensive data-flow analysis and does not need hack
to properly avoid frequently executed point. Instead, it relies on dominance and
loop properties.
The pass is off by default and each target can opt-in by setting the
EnableShrinkWrap boolean to true in their derived class of TargetPassConfig.
This setting can also be overwritten on the command line by using
-enable-shrink-wrap.
Before you try out the pass for your target, make sure you properly fix your
emitProlog/emitEpilog/adjustForXXX method to cope with basic blocks that are not
necessarily the entry block.
** Design Decisions **
1. ShrinkWrap is its own pass right now. It could frankly be merged into PEI but
for debugging and clarity I thought it was best to have its own file.
2. Right now, we only support one save point and one restore point. At some
point we can expand this to several save point and restore point, the impacted
component would then be:
- The pass itself: New algorithm needed.
- MachineFrameInfo: Hold a list or set of Save/Restore point instead of one
pointer.
- PEI: Should loop over the save point and restore point.
Anyhow, at least for this first iteration, I do not believe this is interesting
to support the complex cases. We should revisit that when we motivating
examples.
Differential Revision: http://reviews.llvm.org/D9210
<rdar://problem/3201744>
llvm-svn: 236507
2015-05-05 19:38:16 +02:00
|
|
|
void initializeShrinkWrapPass(PassRegistry &);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeSimpleInlinerPass(PassRegistry&);
|
|
|
|
|
void initializeSingleLoopExtractorPass(PassRegistry&);
|
2016-04-22 21:54:10 +02:00
|
|
|
void initializeSinkingLegacyPassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeSjLjEHPreparePass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeSlotIndexesPass(PassRegistry&);
|
2015-05-15 19:54:48 +02:00
|
|
|
void initializeSpeculativeExecutionPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeSpillPlacementPass(PassRegistry&);
|
2012-09-06 11:17:37 +02:00
|
|
|
void initializeStackColoringPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeStackMapLivenessPass(PassRegistry&);
|
|
|
|
|
void initializeStackProtectorPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeStackSlotColoringPass(PassRegistry&);
|
Add straight-line strength reduction to LLVM
Summary:
Straight-line strength reduction (SLSR) is implemented in GCC but not yet in
LLVM. It has proven to effectively simplify statements derived from an unrolled
loop, and can potentially benefit many other cases too. For example,
LLVM unrolls
#pragma unroll
foo (int i = 0; i < 3; ++i) {
sum += foo((b + i) * s);
}
into
sum += foo(b * s);
sum += foo((b + 1) * s);
sum += foo((b + 2) * s);
However, no optimizations yet reduce the internal redundancy of the three
expressions:
b * s
(b + 1) * s
(b + 2) * s
With SLSR, LLVM can optimize these three expressions into:
t1 = b * s
t2 = t1 + s
t3 = t2 + s
This commit is only an initial step towards implementing a series of such
optimizations. I will implement more (see TODO in the file commentary) in the
near future. This optimization is enabled for the NVPTX backend for now.
However, I am more than happy to push it to the standard optimization pipeline
after more thorough performance tests.
Test Plan: test/StraightLineStrengthReduce/slsr.ll
Reviewers: eliben, HaoLiu, meheff, hfinkel, jholewinski, atrick
Reviewed By: jholewinski, atrick
Subscribers: karthikthecool, jholewinski, llvm-commits
Differential Revision: http://reviews.llvm.org/D7310
llvm-svn: 228016
2015-02-03 20:37:06 +01:00
|
|
|
void initializeStraightLineStrengthReducePass(PassRegistry &);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeStripDeadDebugInfoPass(PassRegistry&);
|
2015-10-31 00:28:12 +01:00
|
|
|
void initializeStripDeadPrototypesLegacyPassPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeStripDebugDeclarePass(PassRegistry&);
|
|
|
|
|
void initializeStripNonDebugSymbolsPass(PassRegistry&);
|
|
|
|
|
void initializeStripSymbolsPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeStructurizeCFGPass(PassRegistry&);
|
2010-10-07 06:17:38 +02:00
|
|
|
void initializeTailCallElimPass(PassRegistry&);
|
2012-02-08 22:23:13 +01:00
|
|
|
void initializeTailDuplicatePassPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeTargetLibraryInfoWrapperPassPass(PassRegistry &);
|
2012-02-04 03:56:45 +01:00
|
|
|
void initializeTargetPassConfigPass(PassRegistry&);
|
[PM] Change the core design of the TTI analysis to use a polymorphic
type erased interface and a single analysis pass rather than an
extremely complex analysis group.
The end result is that the TTI analysis can contain a type erased
implementation that supports the polymorphic TTI interface. We can build
one from a target-specific implementation or from a dummy one in the IR.
I've also factored all of the code into "mix-in"-able base classes,
including CRTP base classes to facilitate calling back up to the most
specialized form when delegating horizontally across the surface. These
aren't as clean as I would like and I'm planning to work on cleaning
some of this up, but I wanted to start by putting into the right form.
There are a number of reasons for this change, and this particular
design. The first and foremost reason is that an analysis group is
complete overkill, and the chaining delegation strategy was so opaque,
confusing, and high overhead that TTI was suffering greatly for it.
Several of the TTI functions had failed to be implemented in all places
because of the chaining-based delegation making there be no checking of
this. A few other functions were implemented with incorrect delegation.
The message to me was very clear working on this -- the delegation and
analysis group structure was too confusing to be useful here.
The other reason of course is that this is *much* more natural fit for
the new pass manager. This will lay the ground work for a type-erased
per-function info object that can look up the correct subtarget and even
cache it.
Yet another benefit is that this will significantly simplify the
interaction of the pass managers and the TargetMachine. See the future
work below.
The downside of this change is that it is very, very verbose. I'm going
to work to improve that, but it is somewhat an implementation necessity
in C++ to do type erasure. =/ I discussed this design really extensively
with Eric and Hal prior to going down this path, and afterward showed
them the result. No one was really thrilled with it, but there doesn't
seem to be a substantially better alternative. Using a base class and
virtual method dispatch would make the code much shorter, but as
discussed in the update to the programmer's manual and elsewhere,
a polymorphic interface feels like the more principled approach even if
this is perhaps the least compelling example of it. ;]
Ultimately, there is still a lot more to be done here, but this was the
huge chunk that I couldn't really split things out of because this was
the interface change to TTI. I've tried to minimize all the other parts
of this. The follow up work should include at least:
1) Improving the TargetMachine interface by having it directly return
a TTI object. Because we have a non-pass object with value semantics
and an internal type erasure mechanism, we can narrow the interface
of the TargetMachine to *just* do what we need: build and return
a TTI object that we can then insert into the pass pipeline.
2) Make the TTI object be fully specialized for a particular function.
This will include splitting off a minimal form of it which is
sufficient for the inliner and the old pass manager.
3) Add a new pass manager analysis which produces TTI objects from the
target machine for each function. This may actually be done as part
of #2 in order to use the new analysis to implement #2.
4) Work on narrowing the API between TTI and the targets so that it is
easier to understand and less verbose to type erase.
5) Work on narrowing the API between TTI and its clients so that it is
easier to understand and less verbose to forward.
6) Try to improve the CRTP-based delegation. I feel like this code is
just a bit messy and exacerbating the complexity of implementing
the TTI in each target.
Many thanks to Eric and Hal for their help here. I ended up blocked on
this somewhat more abruptly than I expected, and so I appreciate getting
it sorted out very quickly.
Differential Revision: http://reviews.llvm.org/D7293
llvm-svn: 227669
2015-01-31 04:43:40 +01:00
|
|
|
void initializeTargetTransformInfoWrapperPassPass(PassRegistry &);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeThreadSanitizerPass(PassRegistry&);
|
2015-02-19 20:14:34 +01:00
|
|
|
void initializeTwoAddressInstructionPassPass(PassRegistry&);
|
[PM/AA] Rebuild LLVM's alias analysis infrastructure in a way compatible
with the new pass manager, and no longer relying on analysis groups.
This builds essentially a ground-up new AA infrastructure stack for
LLVM. The core ideas are the same that are used throughout the new pass
manager: type erased polymorphism and direct composition. The design is
as follows:
- FunctionAAResults is a type-erasing alias analysis results aggregation
interface to walk a single query across a range of results from
different alias analyses. Currently this is function-specific as we
always assume that aliasing queries are *within* a function.
- AAResultBase is a CRTP utility providing stub implementations of
various parts of the alias analysis result concept, notably in several
cases in terms of other more general parts of the interface. This can
be used to implement only a narrow part of the interface rather than
the entire interface. This isn't really ideal, this logic should be
hoisted into FunctionAAResults as currently it will cause
a significant amount of redundant work, but it faithfully models the
behavior of the prior infrastructure.
- All the alias analysis passes are ported to be wrapper passes for the
legacy PM and new-style analysis passes for the new PM with a shared
result object. In some cases (most notably CFL), this is an extremely
naive approach that we should revisit when we can specialize for the
new pass manager.
- BasicAA has been restructured to reflect that it is much more
fundamentally a function analysis because it uses dominator trees and
loop info that need to be constructed for each function.
All of the references to getting alias analysis results have been
updated to use the new aggregation interface. All the preservation and
other pass management code has been updated accordingly.
The way the FunctionAAResultsWrapperPass works is to detect the
available alias analyses when run, and add them to the results object.
This means that we should be able to continue to respect when various
passes are added to the pipeline, for example adding CFL or adding TBAA
passes should just cause their results to be available and to get folded
into this. The exception to this rule is BasicAA which really needs to
be a function pass due to using dominator trees and loop info. As
a consequence, the FunctionAAResultsWrapperPass directly depends on
BasicAA and always includes it in the aggregation.
This has significant implications for preserving analyses. Generally,
most passes shouldn't bother preserving FunctionAAResultsWrapperPass
because rebuilding the results just updates the set of known AA passes.
The exception to this rule are LoopPass instances which need to preserve
all the function analyses that the loop pass manager will end up
needing. This means preserving both BasicAAWrapperPass and the
aggregating FunctionAAResultsWrapperPass.
Now, when preserving an alias analysis, you do so by directly preserving
that analysis. This is only necessary for non-immutable-pass-provided
alias analyses though, and there are only three of interest: BasicAA,
GlobalsAA (formerly GlobalsModRef), and SCEVAA. Usually BasicAA is
preserved when needed because it (like DominatorTree and LoopInfo) is
marked as a CFG-only pass. I've expanded GlobalsAA into the preserved
set everywhere we previously were preserving all of AliasAnalysis, and
I've added SCEVAA in the intersection of that with where we preserve
SCEV itself.
One significant challenge to all of this is that the CGSCC passes were
actually using the alias analysis implementations by taking advantage of
a pretty amazing set of loop holes in the old pass manager's analysis
management code which allowed analysis groups to slide through in many
cases. Moving away from analysis groups makes this problem much more
obvious. To fix it, I've leveraged the flexibility the design of the new
PM components provides to just directly construct the relevant alias
analyses for the relevant functions in the IPO passes that need them.
This is a bit hacky, but should go away with the new pass manager, and
is already in many ways cleaner than the prior state.
Another significant challenge is that various facilities of the old
alias analysis infrastructure just don't fit any more. The most
significant of these is the alias analysis 'counter' pass. That pass
relied on the ability to snoop on AA queries at different points in the
analysis group chain. Instead, I'm planning to build printing
functionality directly into the aggregation layer. I've not included
that in this patch merely to keep it smaller.
Note that all of this needs a nearly complete rewrite of the AA
documentation. I'm planning to do that, but I'd like to make sure the
new design settles, and to flesh out a bit more of what it looks like in
the new pass manager first.
Differential Revision: http://reviews.llvm.org/D12080
llvm-svn: 247167
2015-09-09 19:55:00 +02:00
|
|
|
void initializeTypeBasedAAWrapperPassPass(PassRegistry&);
|
2015-02-19 20:14:34 +01:00
|
|
|
void initializeUnifyFunctionExitNodesPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeUnpackMachineBundlesPass(PassRegistry&);
|
2016-07-08 05:32:49 +02:00
|
|
|
void initializeUnreachableBlockElimLegacyPassPass(PassRegistry&);
|
2015-02-19 20:14:34 +01:00
|
|
|
void initializeUnreachableMachineBlockElimPass(PassRegistry&);
|
|
|
|
|
void initializeVerifierLegacyPassPass(PassRegistry&);
|
|
|
|
|
void initializeVirtRegMapPass(PassRegistry&);
|
|
|
|
|
void initializeVirtRegRewriterPass(PassRegistry&);
|
2016-06-09 21:58:30 +02:00
|
|
|
void initializeWholeProgramDevirtPass(PassRegistry &);
|
2015-01-29 01:41:44 +01:00
|
|
|
void initializeWinEHPreparePass(PassRegistry&);
|
2016-04-11 15:58:45 +02:00
|
|
|
void initializeWriteBitcodePassPass(PassRegistry &);
|
XRay: Add entry and exit sleds
Summary:
In this patch we implement the following parts of XRay:
- Supporting a function attribute named 'function-instrument' which currently only supports 'xray-always'. We should be able to use this attribute for other instrumentation approaches.
- Supporting a function attribute named 'xray-instruction-threshold' used to determine whether a function is instrumented with a minimum number of instructions (IR instruction counts).
- X86-specific nop sleds as described in the white paper.
- A machine function pass that adds the different instrumentation marker instructions at a very late stage.
- A way of identifying which return opcode is considered "normal" for each architecture.
There are some caveats here:
1) We don't handle PATCHABLE_RET in platforms other than x86_64 yet -- this means if IR used PATCHABLE_RET directly instead of a normal ret, instruction lowering for that platform might do the wrong thing. We think this should be handled at instruction selection time to by default be unpacked for platforms where XRay is not availble yet.
2) The generated section for X86 is different from what is described from the white paper for the sole reason that LLVM allows us to do this neatly. We're taking the opportunity to deviate from the white paper from this perspective to allow us to get richer information from the runtime library.
Reviewers: sanjoy, eugenis, kcc, pcc, echristo, rnk
Subscribers: niravd, majnemer, atrick, rnk, emaste, bmakam, mcrosier, mehdi_amini, llvm-commits
Differential Revision: http://reviews.llvm.org/D19904
llvm-svn: 275367
2016-07-14 06:06:33 +02:00
|
|
|
void initializeXRayInstrumentationPass(PassRegistry &);
|
2015-06-23 11:49:53 +02:00
|
|
|
}
|
2010-10-07 06:17:38 +02:00
|
|
|
|
|
|
|
|
#endif
|
