/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/PassAnalysisSupport.h
Line | Count | Source (jump to first uncovered line) |
1 | | //===- llvm/PassAnalysisSupport.h - Analysis Pass Support code --*- C++ -*-===// |
2 | | // |
3 | | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | | // See https://llvm.org/LICENSE.txt for license information. |
5 | | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | | // |
7 | | //===----------------------------------------------------------------------===// |
8 | | // |
9 | | // This file defines stuff that is used to define and "use" Analysis Passes. |
10 | | // This file is automatically #included by Pass.h, so: |
11 | | // |
12 | | // NO .CPP FILES SHOULD INCLUDE THIS FILE DIRECTLY |
13 | | // |
14 | | // Instead, #include Pass.h |
15 | | // |
16 | | //===----------------------------------------------------------------------===// |
17 | | |
18 | | #ifndef LLVM_PASSANALYSISSUPPORT_H |
19 | | #define LLVM_PASSANALYSISSUPPORT_H |
20 | | |
21 | | #include "Pass.h" |
22 | | #include "llvm/ADT/SmallVector.h" |
23 | | #include "llvm/ADT/StringRef.h" |
24 | | #include <cassert> |
25 | | #include <utility> |
26 | | #include <vector> |
27 | | |
28 | | namespace llvm { |
29 | | |
30 | | class Function; |
31 | | class Pass; |
32 | | class PMDataManager; |
33 | | |
34 | | //===----------------------------------------------------------------------===// |
35 | | /// Represent the analysis usage information of a pass. This tracks analyses |
36 | | /// that the pass REQUIRES (must be available when the pass runs), REQUIRES |
37 | | /// TRANSITIVE (must be available throughout the lifetime of the pass), and |
38 | | /// analyses that the pass PRESERVES (the pass does not invalidate the results |
39 | | /// of these analyses). This information is provided by a pass to the Pass |
40 | | /// infrastructure through the getAnalysisUsage virtual function. |
41 | | /// |
42 | | class AnalysisUsage { |
43 | | public: |
44 | | using VectorType = SmallVectorImpl<AnalysisID>; |
45 | | |
46 | | private: |
47 | | /// Sets of analyses required and preserved by a pass |
48 | | // TODO: It's not clear that SmallVector is an appropriate data structure for |
49 | | // this usecase. The sizes were picked to minimize wasted space, but are |
50 | | // otherwise fairly meaningless. |
51 | | SmallVector<AnalysisID, 8> Required; |
52 | | SmallVector<AnalysisID, 2> RequiredTransitive; |
53 | | SmallVector<AnalysisID, 2> Preserved; |
54 | | SmallVector<AnalysisID, 0> Used; |
55 | | bool PreservesAll = false; |
56 | | |
57 | | public: |
58 | 9.64M | AnalysisUsage() = default; |
59 | | |
60 | | ///@{ |
61 | | /// Add the specified ID to the required set of the usage info for a pass. |
62 | | AnalysisUsage &addRequiredID(const void *ID); |
63 | | AnalysisUsage &addRequiredID(char &ID); |
64 | | template<class PassClass> |
65 | 19.1M | AnalysisUsage &addRequired() { |
66 | 19.1M | return addRequiredID(PassClass::ID); |
67 | 19.1M | } llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineDominatorTree>() Line | Count | Source | 65 | 473k | AnalysisUsage &addRequired() { | 66 | 473k | return addRequiredID(PassClass::ID); | 67 | 473k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ReachingDefAnalysis>() Line | Count | Source | 65 | 30.8k | AnalysisUsage &addRequired() { | 66 | 30.8k | return addRequiredID(PassClass::ID); | 67 | 30.8k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AAResultsWrapperPass>() Line | Count | Source | 65 | 835k | AnalysisUsage &addRequired() { | 66 | 835k | return addRequiredID(PassClass::ID); | 67 | 835k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineLoopInfo>() Line | Count | Source | 65 | 577k | AnalysisUsage &addRequired() { | 66 | 577k | return addRequiredID(PassClass::ID); | 67 | 577k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveIntervals>() Line | Count | Source | 65 | 171k | AnalysisUsage &addRequired() { | 66 | 171k | return addRequiredID(PassClass::ID); | 67 | 171k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineBranchProbabilityInfo>() Line | Count | Source | 65 | 470k | AnalysisUsage &addRequired() { | 66 | 470k | return addRequiredID(PassClass::ID); | 67 | 470k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineTraceMetrics>() Line | Count | Source | 65 | 59.1k | AnalysisUsage &addRequired() { | 66 | 59.1k | return addRequiredID(PassClass::ID); | 67 | 59.1k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::TargetPassConfig>() Line | Count | Source | 65 | 284k | AnalysisUsage &addRequired() { | 66 | 284k | return addRequiredID(PassClass::ID); | 67 | 284k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LoopInfoWrapperPass>() Line | Count | Source | 65 | 2.07M | AnalysisUsage &addRequired() { | 66 | 2.07M | return addRequiredID(PassClass::ID); | 67 | 2.07M | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ScalarEvolutionWrapperPass>() Line | Count | Source | 65 | 366k | AnalysisUsage &addRequired() { | 66 | 366k | return addRequiredID(PassClass::ID); | 67 | 366k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DominatorTreeWrapperPass>() Line | Count | Source | 65 | 2.55M | AnalysisUsage &addRequired() { | 66 | 2.55M | return addRequiredID(PassClass::ID); | 67 | 2.55M | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LegacyDivergenceAnalysis>() Line | Count | Source | 65 | 13.0k | AnalysisUsage &addRequired() { | 66 | 13.0k | return addRequiredID(PassClass::ID); | 67 | 13.0k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MemoryDependenceWrapperPass>() Line | Count | Source | 65 | 41.7k | AnalysisUsage &addRequired() { | 66 | 41.7k | return addRequiredID(PassClass::ID); | 67 | 41.7k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AssumptionCacheTracker>() Line | Count | Source | 65 | 1.21M | AnalysisUsage &addRequired() { | 66 | 1.21M | return addRequiredID(PassClass::ID); | 67 | 1.21M | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AMDGPUArgumentUsageInfo>() Line | Count | Source | 65 | 2.37k | AnalysisUsage &addRequired() { | 66 | 2.37k | return addRequiredID(PassClass::ID); | 67 | 2.37k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AMDGPUPerfHintAnalysis>() Line | Count | Source | 65 | 2.37k | AnalysisUsage &addRequired() { | 66 | 2.37k | return addRequiredID(PassClass::ID); | 67 | 2.37k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::TargetTransformInfoWrapperPass>() Line | Count | Source | 65 | 760k | AnalysisUsage &addRequired() { | 66 | 760k | return addRequiredID(PassClass::ID); | 67 | 760k | } |
Unexecuted instantiation: llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineRegionInfoPass>() llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::PostDominatorTreeWrapperPass>() Line | Count | Source | 65 | 30.4k | AnalysisUsage &addRequired() { | 66 | 30.4k | return addRequiredID(PassClass::ID); | 67 | 30.4k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachinePostDominatorTree>() Line | Count | Source | 65 | 98.6k | AnalysisUsage &addRequired() { | 66 | 98.6k | return addRequiredID(PassClass::ID); | 67 | 98.6k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::TargetLibraryInfoWrapperPass>() Line | Count | Source | 65 | 2.21M | AnalysisUsage &addRequired() { | 66 | 2.21M | return addRequiredID(PassClass::ID); | 67 | 2.21M | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineDominanceFrontier>() Line | Count | Source | 65 | 2.06k | AnalysisUsage &addRequired() { | 66 | 2.06k | return addRequiredID(PassClass::ID); | 67 | 2.06k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::SlotIndexes>() Line | Count | Source | 65 | 194k | AnalysisUsage &addRequired() { | 66 | 194k | return addRequiredID(PassClass::ID); | 67 | 194k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::WebAssemblyExceptionInfo>() Line | Count | Source | 65 | 722 | AnalysisUsage &addRequired() { | 66 | 722 | return addRequiredID(PassClass::ID); | 67 | 722 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineBlockFrequencyInfo>() Line | Count | Source | 65 | 232k | AnalysisUsage &addRequired() { | 66 | 232k | return addRequiredID(PassClass::ID); | 67 | 232k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::EdgeBundles>() Line | Count | Source | 65 | 43.1k | AnalysisUsage &addRequired() { | 66 | 43.1k | return addRequiredID(PassClass::ID); | 67 | 43.1k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineModuleInfo>() Line | Count | Source | 65 | 3.54M | AnalysisUsage &addRequired() { | 66 | 3.54M | return addRequiredID(PassClass::ID); | 67 | 3.54M | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::BasicAAWrapperPass>() Line | Count | Source | 65 | 352k | AnalysisUsage &addRequired() { | 66 | 352k | return addRequiredID(PassClass::ID); | 67 | 352k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::BranchProbabilityInfoWrapperPass>() Line | Count | Source | 65 | 144k | AnalysisUsage &addRequired() { | 66 | 144k | return addRequiredID(PassClass::ID); | 67 | 144k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::CallGraphWrapperPass>() Line | Count | Source | 65 | 131k | AnalysisUsage &addRequired() { | 66 | 131k | return addRequiredID(PassClass::ID); | 67 | 131k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyBranchProbabilityInfoPass>() Line | Count | Source | 65 | 421k | AnalysisUsage &addRequired() { | 66 | 421k | return addRequiredID(PassClass::ID); | 67 | 421k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyBlockFrequencyInfoPass>() Line | Count | Source | 65 | 218k | AnalysisUsage &addRequired() { | 66 | 218k | return addRequiredID(PassClass::ID); | 67 | 218k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyValueInfoWrapperPass>() Line | Count | Source | 65 | 51.8k | AnalysisUsage &addRequired() { | 66 | 51.8k | return addRequiredID(PassClass::ID); | 67 | 51.8k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::PhiValuesWrapperPass>() Line | Count | Source | 65 | 41.3k | AnalysisUsage &addRequired() { | 66 | 41.3k | return addRequiredID(PassClass::ID); | 67 | 41.3k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MemorySSAWrapperPass>() Line | Count | Source | 65 | 21.5k | AnalysisUsage &addRequired() { | 66 | 21.5k | return addRequiredID(PassClass::ID); | 67 | 21.5k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::BlockFrequencyInfoWrapperPass>() Line | Count | Source | 65 | 97.1k | AnalysisUsage &addRequired() { | 66 | 97.1k | return addRequiredID(PassClass::ID); | 67 | 97.1k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ProfileSummaryInfoWrapperPass>() Line | Count | Source | 65 | 57.9k | AnalysisUsage &addRequired() { | 66 | 57.9k | return addRequiredID(PassClass::ID); | 67 | 57.9k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DominanceFrontierWrapperPass>() Line | Count | Source | 65 | 3.68k | AnalysisUsage &addRequired() { | 66 | 3.68k | return addRequiredID(PassClass::ID); | 67 | 3.68k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::RegionInfoPass>() Line | Count | Source | 65 | 5.00k | AnalysisUsage &addRequired() { | 66 | 5.00k | return addRequiredID(PassClass::ID); | 67 | 5.00k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::StackSafetyInfoWrapperPass>() Line | Count | Source | 65 | 5 | AnalysisUsage &addRequired() { | 66 | 5 | return addRequiredID(PassClass::ID); | 67 | 5 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::GCModuleInfo>() Line | Count | Source | 65 | 135k | AnalysisUsage &addRequired() { | 66 | 135k | return addRequiredID(PassClass::ID); | 67 | 135k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyMachineBlockFrequencyInfoPass>() Line | Count | Source | 65 | 99.4k | AnalysisUsage &addRequired() { | 66 | 99.4k | return addRequiredID(PassClass::ID); | 67 | 99.4k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineOptimizationRemarkEmitterPass>() Line | Count | Source | 65 | 131k | AnalysisUsage &addRequired() { | 66 | 131k | return addRequiredID(PassClass::ID); | 67 | 131k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveDebugVariables>() Line | Count | Source | 65 | 63.4k | AnalysisUsage &addRequired() { | 66 | 63.4k | return addRequiredID(PassClass::ID); | 67 | 63.4k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveStacks>() Line | Count | Source | 65 | 95.3k | AnalysisUsage &addRequired() { | 66 | 95.3k | return addRequiredID(PassClass::ID); | 67 | 95.3k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::VirtRegMap>() Line | Count | Source | 65 | 63.4k | AnalysisUsage &addRequired() { | 66 | 63.4k | return addRequiredID(PassClass::ID); | 67 | 63.4k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveRegMatrix>() Line | Count | Source | 65 | 31.7k | AnalysisUsage &addRequired() { | 66 | 31.7k | return addRequiredID(PassClass::ID); | 67 | 31.7k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::SpillPlacement>() Line | Count | Source | 65 | 31.6k | AnalysisUsage &addRequired() { | 66 | 31.6k | return addRequiredID(PassClass::ID); | 67 | 31.6k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::PhysicalRegisterUsageInfo>() Line | Count | Source | 65 | 4.19k | AnalysisUsage &addRequired() { | 66 | 4.19k | return addRequiredID(PassClass::ID); | 67 | 4.19k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ModuleSummaryIndexWrapperPass>() Line | Count | Source | 65 | 354 | AnalysisUsage &addRequired() { | 66 | 354 | return addRequiredID(PassClass::ID); | 67 | 354 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::OptimizationRemarkEmitterWrapperPass>() Line | Count | Source | 65 | 219k | AnalysisUsage &addRequired() { | 66 | 219k | return addRequiredID(PassClass::ID); | 67 | 219k | } |
AddressSanitizer.cpp:llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<(anonymous namespace)::ASanGlobalsMetadataWrapperPass>() Line | Count | Source | 65 | 332 | AnalysisUsage &addRequired() { | 66 | 332 | return addRequiredID(PassClass::ID); | 67 | 332 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::objcarc::ObjCARCAAWrapperPass>() Line | Count | Source | 65 | 31 | AnalysisUsage &addRequired() { | 66 | 31 | return addRequiredID(PassClass::ID); | 67 | 31 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DemandedBitsWrapperPass>() Line | Count | Source | 65 | 39.6k | AnalysisUsage &addRequired() { | 66 | 39.6k | return addRequiredID(PassClass::ID); | 67 | 39.6k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LoopAccessLegacyAnalysis>() Line | Count | Source | 65 | 38.9k | AnalysisUsage &addRequired() { | 66 | 38.9k | return addRequiredID(PassClass::ID); | 67 | 38.9k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DependenceAnalysisWrapperPass>() Line | Count | Source | 65 | 22 | AnalysisUsage &addRequired() { | 66 | 22 | return addRequiredID(PassClass::ID); | 67 | 22 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::IVUsersWrapperPass>() Line | Count | Source | 65 | 32.4k | AnalysisUsage &addRequired() { | 66 | 32.4k | return addRequiredID(PassClass::ID); | 67 | 32.4k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LCSSAVerificationPass>() Line | Count | Source | 65 | 254k | AnalysisUsage &addRequired() { | 66 | 254k | return addRequiredID(PassClass::ID); | 67 | 254k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<polly::ScopDetectionWrapperPass>() Line | Count | Source | 65 | 316 | AnalysisUsage &addRequired() { | 66 | 316 | return addRequiredID(PassClass::ID); | 67 | 316 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<polly::ScopInfoRegionPass>() Line | Count | Source | 65 | 1.27k | AnalysisUsage &addRequired() { | 66 | 1.27k | return addRequiredID(PassClass::ID); | 67 | 1.27k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<polly::DependenceInfo>() Line | Count | Source | 65 | 647 | AnalysisUsage &addRequired() { | 66 | 647 | return addRequiredID(PassClass::ID); | 67 | 647 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<polly::IslAstInfoWrapperPass>() Line | Count | Source | 65 | 315 | AnalysisUsage &addRequired() { | 66 | 315 | return addRequiredID(PassClass::ID); | 67 | 315 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::StackProtector>() Line | Count | Source | 65 | 42.7k | AnalysisUsage &addRequired() { | 66 | 42.7k | return addRequiredID(PassClass::ID); | 67 | 42.7k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::GISelCSEAnalysisWrapperPass>() Line | Count | Source | 65 | 14.0k | AnalysisUsage &addRequired() { | 66 | 14.0k | return addRequiredID(PassClass::ID); | 67 | 14.0k | } |
|
68 | | |
69 | | AnalysisUsage &addRequiredTransitiveID(char &ID); |
70 | | template<class PassClass> |
71 | 1.10M | AnalysisUsage &addRequiredTransitive() { |
72 | 1.10M | return addRequiredTransitiveID(PassClass::ID); |
73 | 1.10M | } llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::CallGraphWrapperPass>() Line | Count | Source | 71 | 5 | AnalysisUsage &addRequiredTransitive() { | 72 | 5 | return addRequiredTransitiveID(PassClass::ID); | 73 | 5 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::AAResultsWrapperPass>() Line | Count | Source | 71 | 64.3k | AnalysisUsage &addRequiredTransitive() { | 72 | 64.3k | return addRequiredTransitiveID(PassClass::ID); | 73 | 64.3k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::ScalarEvolutionWrapperPass>() Line | Count | Source | 71 | 2.50k | AnalysisUsage &addRequiredTransitive() { | 72 | 2.50k | return addRequiredTransitiveID(PassClass::ID); | 73 | 2.50k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::LoopInfoWrapperPass>() Line | Count | Source | 71 | 184k | AnalysisUsage &addRequiredTransitive() { | 72 | 184k | return addRequiredTransitiveID(PassClass::ID); | 73 | 184k | } |
Unexecuted instantiation: llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::MemoryDependenceWrapperPass>() llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::TargetLibraryInfoWrapperPass>() Line | Count | Source | 71 | 225k | AnalysisUsage &addRequiredTransitive() { | 72 | 225k | return addRequiredTransitiveID(PassClass::ID); | 73 | 225k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::DominatorTreeWrapperPass>() Line | Count | Source | 71 | 209k | AnalysisUsage &addRequiredTransitive() { | 72 | 209k | return addRequiredTransitiveID(PassClass::ID); | 73 | 209k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::AssumptionCacheTracker>() Line | Count | Source | 71 | 184k | AnalysisUsage &addRequiredTransitive() { | 72 | 184k | return addRequiredTransitiveID(PassClass::ID); | 73 | 184k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::LiveIntervals>() Line | Count | Source | 71 | 63.4k | AnalysisUsage &addRequiredTransitive() { | 72 | 63.4k | return addRequiredTransitiveID(PassClass::ID); | 73 | 63.4k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::SlotIndexes>() Line | Count | Source | 71 | 68.4k | AnalysisUsage &addRequiredTransitive() { | 72 | 68.4k | return addRequiredTransitiveID(PassClass::ID); | 73 | 68.4k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::VirtRegMap>() Line | Count | Source | 71 | 31.7k | AnalysisUsage &addRequiredTransitive() { | 72 | 31.7k | return addRequiredTransitiveID(PassClass::ID); | 73 | 31.7k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::EdgeBundles>() Line | Count | Source | 71 | 31.6k | AnalysisUsage &addRequiredTransitive() { | 72 | 31.6k | return addRequiredTransitiveID(PassClass::ID); | 73 | 31.6k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::MachineLoopInfo>() Line | Count | Source | 71 | 31.6k | AnalysisUsage &addRequiredTransitive() { | 72 | 31.6k | return addRequiredTransitiveID(PassClass::ID); | 73 | 31.6k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<polly::ScopInfoRegionPass>() Line | Count | Source | 71 | 1.21k | AnalysisUsage &addRequiredTransitive() { | 72 | 1.21k | return addRequiredTransitiveID(PassClass::ID); | 73 | 1.21k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<polly::ScopInfoWrapperPass>() Line | Count | Source | 71 | 45 | AnalysisUsage &addRequiredTransitive() { | 72 | 45 | return addRequiredTransitiveID(PassClass::ID); | 73 | 45 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<polly::DependenceInfoWrapperPass>() Line | Count | Source | 71 | 19 | AnalysisUsage &addRequiredTransitive() { | 72 | 19 | return addRequiredTransitiveID(PassClass::ID); | 73 | 19 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::RegionInfoPass>() Line | Count | Source | 71 | 1.28k | AnalysisUsage &addRequiredTransitive() { | 72 | 1.28k | return addRequiredTransitiveID(PassClass::ID); | 73 | 1.28k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<polly::ScopDetectionWrapperPass>() Line | Count | Source | 71 | 1.16k | AnalysisUsage &addRequiredTransitive() { | 72 | 1.16k | return addRequiredTransitiveID(PassClass::ID); | 73 | 1.16k | } |
|
74 | | ///@} |
75 | | |
76 | | ///@{ |
77 | | /// Add the specified ID to the set of analyses preserved by this pass. |
78 | 0 | AnalysisUsage &addPreservedID(const void *ID) { |
79 | 0 | Preserved.push_back(ID); |
80 | 0 | return *this; |
81 | 0 | } |
82 | 1.09M | AnalysisUsage &addPreservedID(char &ID) { |
83 | 1.09M | Preserved.push_back(&ID); |
84 | 1.09M | return *this; |
85 | 1.09M | } |
86 | | /// Add the specified Pass class to the set of analyses preserved by this pass. |
87 | | template<class PassClass> |
88 | 44.4M | AnalysisUsage &addPreserved() { |
89 | 44.4M | Preserved.push_back(&PassClass::ID); |
90 | 44.4M | return *this; |
91 | 44.4M | } llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineDominatorTree>() Line | Count | Source | 88 | 392k | AnalysisUsage &addPreserved() { | 89 | 392k | Preserved.push_back(&PassClass::ID); | 90 | 392k | return *this; | 91 | 392k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineLoopInfo>() Line | Count | Source | 88 | 404k | AnalysisUsage &addPreserved() { | 89 | 404k | Preserved.push_back(&PassClass::ID); | 90 | 404k | return *this; | 91 | 404k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineTraceMetrics>() Line | Count | Source | 88 | 59.1k | AnalysisUsage &addPreserved() { | 89 | 59.1k | Preserved.push_back(&PassClass::ID); | 90 | 59.1k | return *this; | 91 | 59.1k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::AAResultsWrapperPass>() Line | Count | Source | 88 | 4.04M | AnalysisUsage &addPreserved() { | 89 | 4.04M | Preserved.push_back(&PassClass::ID); | 90 | 4.04M | return *this; | 91 | 4.04M | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::DominatorTreeWrapperPass>() Line | Count | Source | 88 | 4.28M | AnalysisUsage &addPreserved() { | 89 | 4.28M | Preserved.push_back(&PassClass::ID); | 90 | 4.28M | return *this; | 91 | 4.28M | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LoopInfoWrapperPass>() Line | Count | Source | 88 | 3.87M | AnalysisUsage &addPreserved() { | 89 | 3.87M | Preserved.push_back(&PassClass::ID); | 90 | 3.87M | return *this; | 91 | 3.87M | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::ScalarEvolutionWrapperPass>() Line | Count | Source | 88 | 3.86M | AnalysisUsage &addPreserved() { | 89 | 3.86M | Preserved.push_back(&PassClass::ID); | 90 | 3.86M | return *this; | 91 | 3.86M | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LegacyDivergenceAnalysis>() Line | Count | Source | 88 | 2.10k | AnalysisUsage &addPreserved() { | 89 | 2.10k | Preserved.push_back(&PassClass::ID); | 90 | 2.10k | return *this; | 91 | 2.10k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::SlotIndexes>() Line | Count | Source | 88 | 336k | AnalysisUsage &addPreserved() { | 89 | 336k | Preserved.push_back(&PassClass::ID); | 90 | 336k | return *this; | 91 | 336k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveIntervals>() Line | Count | Source | 88 | 204k | AnalysisUsage &addPreserved() { | 89 | 204k | Preserved.push_back(&PassClass::ID); | 90 | 204k | return *this; | 91 | 204k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::PostDominatorTreeWrapperPass>() Line | Count | Source | 88 | 26.3k | AnalysisUsage &addPreserved() { | 89 | 26.3k | Preserved.push_back(&PassClass::ID); | 90 | 26.3k | return *this; | 91 | 26.3k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::TargetLibraryInfoWrapperPass>() Line | Count | Source | 88 | 15.8k | AnalysisUsage &addPreserved() { | 89 | 15.8k | Preserved.push_back(&PassClass::ID); | 90 | 15.8k | return *this; | 91 | 15.8k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::StackProtector>() Line | Count | Source | 88 | 47.0k | AnalysisUsage &addPreserved() { | 89 | 47.0k | Preserved.push_back(&PassClass::ID); | 90 | 47.0k | return *this; | 91 | 47.0k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineBlockFrequencyInfo>() Line | Count | Source | 88 | 66.1k | AnalysisUsage &addPreserved() { | 89 | 66.1k | Preserved.push_back(&PassClass::ID); | 90 | 66.1k | return *this; | 91 | 66.1k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::WebAssemblyExceptionInfo>() Line | Count | Source | 88 | 361 | AnalysisUsage &addPreserved() { | 89 | 361 | Preserved.push_back(&PassClass::ID); | 90 | 361 | return *this; | 91 | 361 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineModuleInfo>() Line | Count | Source | 88 | 3.46M | AnalysisUsage &addPreserved() { | 89 | 3.46M | Preserved.push_back(&PassClass::ID); | 90 | 3.46M | return *this; | 91 | 3.46M | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::CallGraphWrapperPass>() Line | Count | Source | 88 | 77.5k | AnalysisUsage &addPreserved() { | 89 | 77.5k | Preserved.push_back(&PassClass::ID); | 90 | 77.5k | return *this; | 91 | 77.5k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveVariables>() Line | Count | Source | 88 | 104k | AnalysisUsage &addPreserved() { | 89 | 104k | Preserved.push_back(&PassClass::ID); | 90 | 104k | return *this; | 91 | 104k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::BasicAAWrapperPass>() Line | Count | Source | 88 | 3.93M | AnalysisUsage &addPreserved() { | 89 | 3.93M | Preserved.push_back(&PassClass::ID); | 90 | 3.93M | return *this; | 91 | 3.93M | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::DominanceFrontierWrapperPass>() Line | Count | Source | 88 | 3.40M | AnalysisUsage &addPreserved() { | 89 | 3.40M | Preserved.push_back(&PassClass::ID); | 90 | 3.40M | return *this; | 91 | 3.40M | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::GlobalsAAWrapperPass>() Line | Count | Source | 88 | 4.45M | AnalysisUsage &addPreserved() { | 89 | 4.45M | Preserved.push_back(&PassClass::ID); | 90 | 4.45M | return *this; | 91 | 4.45M | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::IVUsersWrapperPass>() Line | Count | Source | 88 | 3.44M | AnalysisUsage &addPreserved() { | 89 | 3.44M | Preserved.push_back(&PassClass::ID); | 90 | 3.44M | return *this; | 91 | 3.44M | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MemoryDependenceWrapperPass>() Line | Count | Source | 88 | 3.43M | AnalysisUsage &addPreserved() { | 89 | 3.43M | Preserved.push_back(&PassClass::ID); | 90 | 3.43M | return *this; | 91 | 3.43M | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::SCEVAAWrapperPass>() Line | Count | Source | 88 | 3.80M | AnalysisUsage &addPreserved() { | 89 | 3.80M | Preserved.push_back(&PassClass::ID); | 90 | 3.80M | return *this; | 91 | 3.80M | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachinePostDominatorTree>() Line | Count | Source | 88 | 32.2k | AnalysisUsage &addPreserved() { | 89 | 32.2k | Preserved.push_back(&PassClass::ID); | 90 | 32.2k | return *this; | 91 | 32.2k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveDebugVariables>() Line | Count | Source | 88 | 31.7k | AnalysisUsage &addPreserved() { | 89 | 31.7k | Preserved.push_back(&PassClass::ID); | 90 | 31.7k | return *this; | 91 | 31.7k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveStacks>() Line | Count | Source | 88 | 63.4k | AnalysisUsage &addPreserved() { | 89 | 63.4k | Preserved.push_back(&PassClass::ID); | 90 | 63.4k | return *this; | 91 | 63.4k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::VirtRegMap>() Line | Count | Source | 88 | 31.7k | AnalysisUsage &addPreserved() { | 89 | 31.7k | Preserved.push_back(&PassClass::ID); | 90 | 31.7k | return *this; | 91 | 31.7k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveRegMatrix>() Line | Count | Source | 88 | 31.7k | AnalysisUsage &addPreserved() { | 89 | 31.7k | Preserved.push_back(&PassClass::ID); | 90 | 31.7k | return *this; | 91 | 31.7k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MemorySSAWrapperPass>() Line | Count | Source | 88 | 12.8k | AnalysisUsage &addPreserved() { | 89 | 12.8k | Preserved.push_back(&PassClass::ID); | 90 | 12.8k | return *this; | 91 | 12.8k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LazyValueInfoWrapperPass>() Line | Count | Source | 88 | 26.3k | AnalysisUsage &addPreserved() { | 89 | 26.3k | Preserved.push_back(&PassClass::ID); | 90 | 26.3k | return *this; | 91 | 26.3k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::DependenceAnalysisWrapperPass>() Line | Count | Source | 88 | 138k | AnalysisUsage &addPreserved() { | 89 | 138k | Preserved.push_back(&PassClass::ID); | 90 | 138k | return *this; | 91 | 138k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LCSSAVerificationPass>() Line | Count | Source | 88 | 254k | AnalysisUsage &addPreserved() { | 89 | 254k | Preserved.push_back(&PassClass::ID); | 90 | 254k | return *this; | 91 | 254k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<polly::ScopDetectionWrapperPass>() Line | Count | Source | 88 | 962 | AnalysisUsage &addPreserved() { | 89 | 962 | Preserved.push_back(&PassClass::ID); | 90 | 962 | return *this; | 91 | 962 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::OptimizationRemarkEmitterWrapperPass>() Line | Count | Source | 88 | 962 | AnalysisUsage &addPreserved() { | 89 | 962 | Preserved.push_back(&PassClass::ID); | 90 | 962 | return *this; | 91 | 962 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::RegionInfoPass>() Line | Count | Source | 88 | 974 | AnalysisUsage &addPreserved() { | 89 | 974 | Preserved.push_back(&PassClass::ID); | 90 | 974 | return *this; | 91 | 974 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<polly::ScopInfoRegionPass>() Line | Count | Source | 88 | 962 | AnalysisUsage &addPreserved() { | 89 | 962 | Preserved.push_back(&PassClass::ID); | 90 | 962 | return *this; | 91 | 962 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::TargetTransformInfoWrapperPass>() Line | Count | Source | 88 | 962 | AnalysisUsage &addPreserved() { | 89 | 962 | Preserved.push_back(&PassClass::ID); | 90 | 962 | return *this; | 91 | 962 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<polly::DependenceInfo>() Line | Count | Source | 88 | 937 | AnalysisUsage &addPreserved() { | 89 | 937 | Preserved.push_back(&PassClass::ID); | 90 | 937 | return *this; | 91 | 937 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<polly::IslAstInfoWrapperPass>() Line | Count | Source | 88 | 315 | AnalysisUsage &addPreserved() { | 89 | 315 | Preserved.push_back(&PassClass::ID); | 90 | 315 | return *this; | 91 | 315 | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::GISelCSEAnalysisWrapperPass>() Line | Count | Source | 88 | 7.15k | AnalysisUsage &addPreserved() { | 89 | 7.15k | Preserved.push_back(&PassClass::ID); | 90 | 7.15k | return *this; | 91 | 7.15k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::GCModuleInfo>() Line | Count | Source | 88 | 35.8k | AnalysisUsage &addPreserved() { | 89 | 35.8k | Preserved.push_back(&PassClass::ID); | 90 | 35.8k | return *this; | 91 | 35.8k | } |
|
92 | | ///@} |
93 | | |
94 | | ///@{ |
95 | | /// Add the specified ID to the set of analyses used by this pass if they are |
96 | | /// available.. |
97 | 0 | AnalysisUsage &addUsedIfAvailableID(const void *ID) { |
98 | 0 | Used.push_back(ID); |
99 | 0 | return *this; |
100 | 0 | } |
101 | 0 | AnalysisUsage &addUsedIfAvailableID(char &ID) { |
102 | 0 | Used.push_back(&ID); |
103 | 0 | return *this; |
104 | 0 | } |
105 | | /// Add the specified Pass class to the set of analyses used by this pass. |
106 | | template<class PassClass> |
107 | 3.23M | AnalysisUsage &addUsedIfAvailable() { |
108 | 3.23M | Used.push_back(&PassClass::ID); |
109 | 3.23M | return *this; |
110 | 3.23M | } llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::ScopedNoAliasAAWrapperPass>() Line | Count | Source | 107 | 401k | AnalysisUsage &addUsedIfAvailable() { | 108 | 401k | Used.push_back(&PassClass::ID); | 109 | 401k | return *this; | 110 | 401k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::TypeBasedAAWrapperPass>() Line | Count | Source | 107 | 401k | AnalysisUsage &addUsedIfAvailable() { | 108 | 401k | Used.push_back(&PassClass::ID); | 109 | 401k | return *this; | 110 | 401k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::objcarc::ObjCARCAAWrapperPass>() Line | Count | Source | 107 | 401k | AnalysisUsage &addUsedIfAvailable() { | 108 | 401k | Used.push_back(&PassClass::ID); | 109 | 401k | return *this; | 110 | 401k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::GlobalsAAWrapperPass>() Line | Count | Source | 107 | 401k | AnalysisUsage &addUsedIfAvailable() { | 108 | 401k | Used.push_back(&PassClass::ID); | 109 | 401k | return *this; | 110 | 401k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::SCEVAAWrapperPass>() Line | Count | Source | 107 | 352k | AnalysisUsage &addUsedIfAvailable() { | 108 | 352k | Used.push_back(&PassClass::ID); | 109 | 352k | return *this; | 110 | 352k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::CFLAndersAAWrapperPass>() Line | Count | Source | 107 | 401k | AnalysisUsage &addUsedIfAvailable() { | 108 | 401k | Used.push_back(&PassClass::ID); | 109 | 401k | return *this; | 110 | 401k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::CFLSteensAAWrapperPass>() Line | Count | Source | 107 | 401k | AnalysisUsage &addUsedIfAvailable() { | 108 | 401k | Used.push_back(&PassClass::ID); | 109 | 401k | return *this; | 110 | 401k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::PhiValuesWrapperPass>() Line | Count | Source | 107 | 372k | AnalysisUsage &addUsedIfAvailable() { | 108 | 372k | Used.push_back(&PassClass::ID); | 109 | 372k | return *this; | 110 | 372k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::SlotIndexes>() Line | Count | Source | 107 | 1.03k | AnalysisUsage &addUsedIfAvailable() { | 108 | 1.03k | Used.push_back(&PassClass::ID); | 109 | 1.03k | return *this; | 110 | 1.03k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::LiveVariables>() Line | Count | Source | 107 | 67.9k | AnalysisUsage &addUsedIfAvailable() { | 108 | 67.9k | Used.push_back(&PassClass::ID); | 109 | 67.9k | return *this; | 110 | 67.9k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::AAResultsWrapperPass>() Line | Count | Source | 107 | 33.9k | AnalysisUsage &addUsedIfAvailable() { | 108 | 33.9k | Used.push_back(&PassClass::ID); | 109 | 33.9k | return *this; | 110 | 33.9k | } |
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::AssumptionCacheTracker>() Line | Count | Source | 107 | 38 | AnalysisUsage &addUsedIfAvailable() { | 108 | 38 | Used.push_back(&PassClass::ID); | 109 | 38 | return *this; | 110 | 38 | } |
|
111 | | ///@} |
112 | | |
113 | | /// Add the Pass with the specified argument string to the set of analyses |
114 | | /// preserved by this pass. If no such Pass exists, do nothing. This can be |
115 | | /// useful when a pass is trivially preserved, but may not be linked in. Be |
116 | | /// careful about spelling! |
117 | | AnalysisUsage &addPreserved(StringRef Arg); |
118 | | |
119 | | /// Set by analyses that do not transform their input at all |
120 | 5.21M | void setPreservesAll() { PreservesAll = true; } |
121 | | |
122 | | /// Determine whether a pass said it does not transform its input at all |
123 | 196M | bool getPreservesAll() const { return PreservesAll; } |
124 | | |
125 | | /// This function should be called by the pass, iff they do not: |
126 | | /// |
127 | | /// 1. Add or remove basic blocks from the function |
128 | | /// 2. Modify terminator instructions in any way. |
129 | | /// |
130 | | /// This function annotates the AnalysisUsage info object to say that analyses |
131 | | /// that only depend on the CFG are preserved by this pass. |
132 | | void setPreservesCFG(); |
133 | | |
134 | 206M | const VectorType &getRequiredSet() const { return Required; } |
135 | 54.4M | const VectorType &getRequiredTransitiveSet() const { |
136 | 54.4M | return RequiredTransitive; |
137 | 54.4M | } |
138 | 95.2M | const VectorType &getPreservedSet() const { return Preserved; } |
139 | 28.6M | const VectorType &getUsedSet() const { return Used; } |
140 | | }; |
141 | | |
142 | | //===----------------------------------------------------------------------===// |
143 | | /// AnalysisResolver - Simple interface used by Pass objects to pull all |
144 | | /// analysis information out of pass manager that is responsible to manage |
145 | | /// the pass. |
146 | | /// |
147 | | class AnalysisResolver { |
148 | | public: |
149 | | AnalysisResolver() = delete; |
150 | 9.66M | explicit AnalysisResolver(PMDataManager &P) : PM(P) {} |
151 | | |
152 | 109M | PMDataManager &getPMDataManager() { return PM; } |
153 | | |
154 | | /// Find pass that is implementing PI. |
155 | 746M | Pass *findImplPass(AnalysisID PI) { |
156 | 746M | Pass *ResultPass = nullptr; |
157 | 1.73G | for (const auto &AnalysisImpl : AnalysisImpls) { |
158 | 1.73G | if (AnalysisImpl.first == PI) { |
159 | 723M | ResultPass = AnalysisImpl.second; |
160 | 723M | break; |
161 | 723M | } |
162 | 1.73G | } |
163 | 746M | return ResultPass; |
164 | 746M | } |
165 | | |
166 | | /// Find pass that is implementing PI. Initialize pass for Function F. |
167 | | Pass *findImplPass(Pass *P, AnalysisID PI, Function &F); |
168 | | |
169 | 417M | void addAnalysisImplsPair(AnalysisID PI, Pass *P) { |
170 | 417M | if (findImplPass(PI) == P) |
171 | 394M | return; |
172 | 22.6M | std::pair<AnalysisID, Pass*> pir = std::make_pair(PI,P); |
173 | 22.6M | AnalysisImpls.push_back(pir); |
174 | 22.6M | } |
175 | | |
176 | | /// Clear cache that is used to connect a pass to the analysis (PassInfo). |
177 | 4.48M | void clearAnalysisImpls() { |
178 | 4.48M | AnalysisImpls.clear(); |
179 | 4.48M | } |
180 | | |
181 | | /// Return analysis result or null if it doesn't exist. |
182 | | Pass *getAnalysisIfAvailable(AnalysisID ID, bool Direction) const; |
183 | | |
184 | | private: |
185 | | /// This keeps track of which passes implements the interfaces that are |
186 | | /// required by the current pass (to implement getAnalysis()). |
187 | | std::vector<std::pair<AnalysisID, Pass *>> AnalysisImpls; |
188 | | |
189 | | /// PassManager that is used to resolve analysis info |
190 | | PMDataManager &PM; |
191 | | }; |
192 | | |
193 | | /// getAnalysisIfAvailable<AnalysisType>() - Subclasses use this function to |
194 | | /// get analysis information that might be around, for example to update it. |
195 | | /// This is different than getAnalysis in that it can fail (if the analysis |
196 | | /// results haven't been computed), so should only be used if you can handle |
197 | | /// the case when the analysis is not available. This method is often used by |
198 | | /// transformation APIs to update analysis results for a pass automatically as |
199 | | /// the transform is performed. |
200 | | template<typename AnalysisType> |
201 | 138M | AnalysisType *Pass::getAnalysisIfAvailable() const { |
202 | 138M | assert(Resolver && "Pass not resident in a PassManager object!"); |
203 | 138M | |
204 | 138M | const void *PI = &AnalysisType::ID; |
205 | 138M | |
206 | 138M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); |
207 | 138M | if (!ResultPass) return nullptr83.1M ; |
208 | 55.0M | |
209 | 55.0M | // Because the AnalysisType may not be a subclass of pass (for |
210 | 55.0M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially |
211 | 55.0M | // adjust the return pointer (because the class may multiply inherit, once |
212 | 55.0M | // from pass, once from AnalysisType). |
213 | 55.0M | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); |
214 | 55.0M | } llvm::MachineLoopInfo* llvm::Pass::getAnalysisIfAvailable<llvm::MachineLoopInfo>() const Line | Count | Source | 201 | 1.92M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 1.92M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 1.92M | | 204 | 1.92M | const void *PI = &AnalysisType::ID; | 205 | 1.92M | | 206 | 1.92M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 1.92M | if (!ResultPass) return nullptr376k ; | 208 | 1.54M | | 209 | 1.54M | // Because the AnalysisType may not be a subclass of pass (for | 210 | 1.54M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 1.54M | // adjust the return pointer (because the class may multiply inherit, once | 212 | 1.54M | // from pass, once from AnalysisType). | 213 | 1.54M | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 1.54M | } |
llvm::AMDGPUAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::AMDGPUAAWrapperPass>() const Line | Count | Source | 201 | 166k | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 166k | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 166k | | 204 | 166k | const void *PI = &AnalysisType::ID; | 205 | 166k | | 206 | 166k | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 166k | if (!ResultPass) return nullptr0 ; | 208 | 166k | | 209 | 166k | // Because the AnalysisType may not be a subclass of pass (for | 210 | 166k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 166k | // adjust the return pointer (because the class may multiply inherit, once | 212 | 166k | // from pass, once from AnalysisType). | 213 | 166k | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 166k | } |
llvm::TargetPassConfig* llvm::Pass::getAnalysisIfAvailable<llvm::TargetPassConfig>() const Line | Count | Source | 201 | 2.28M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 2.28M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 2.28M | | 204 | 2.28M | const void *PI = &AnalysisType::ID; | 205 | 2.28M | | 206 | 2.28M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 2.28M | if (!ResultPass) return nullptr22 ; | 208 | 2.28M | | 209 | 2.28M | // Because the AnalysisType may not be a subclass of pass (for | 210 | 2.28M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 2.28M | // adjust the return pointer (because the class may multiply inherit, once | 212 | 2.28M | // from pass, once from AnalysisType). | 213 | 2.28M | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 2.28M | } |
llvm::DominatorTreeWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::DominatorTreeWrapperPass>() const Line | Count | Source | 201 | 5.23M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 5.23M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 5.23M | | 204 | 5.23M | const void *PI = &AnalysisType::ID; | 205 | 5.23M | | 206 | 5.23M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 5.23M | if (!ResultPass) return nullptr944k ; | 208 | 4.28M | | 209 | 4.28M | // Because the AnalysisType may not be a subclass of pass (for | 210 | 4.28M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 4.28M | // adjust the return pointer (because the class may multiply inherit, once | 212 | 4.28M | // from pass, once from AnalysisType). | 213 | 4.28M | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 4.28M | } |
llvm::LiveIntervals* llvm::Pass::getAnalysisIfAvailable<llvm::LiveIntervals>() const Line | Count | Source | 201 | 3.14M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 3.14M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 3.14M | | 204 | 3.14M | const void *PI = &AnalysisType::ID; | 205 | 3.14M | | 206 | 3.14M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 3.14M | if (!ResultPass) return nullptr2.92M ; | 208 | 221k | | 209 | 221k | // Because the AnalysisType may not be a subclass of pass (for | 210 | 221k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 221k | // adjust the return pointer (because the class may multiply inherit, once | 212 | 221k | // from pass, once from AnalysisType). | 213 | 221k | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 221k | } |
llvm::TargetLibraryInfoWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::TargetLibraryInfoWrapperPass>() const Line | Count | Source | 201 | 2.95M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 2.95M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 2.95M | | 204 | 2.95M | const void *PI = &AnalysisType::ID; | 205 | 2.95M | | 206 | 2.95M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 2.95M | if (!ResultPass) return nullptr0 ; | 208 | 2.95M | | 209 | 2.95M | // Because the AnalysisType may not be a subclass of pass (for | 210 | 2.95M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 2.95M | // adjust the return pointer (because the class may multiply inherit, once | 212 | 2.95M | // from pass, once from AnalysisType). | 213 | 2.95M | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 2.95M | } |
llvm::ScopedNoAliasAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::ScopedNoAliasAAWrapperPass>() const Line | Count | Source | 201 | 10.3M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 10.3M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 10.3M | | 204 | 10.3M | const void *PI = &AnalysisType::ID; | 205 | 10.3M | | 206 | 10.3M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 10.3M | if (!ResultPass) return nullptr51.9k ; | 208 | 10.3M | | 209 | 10.3M | // Because the AnalysisType may not be a subclass of pass (for | 210 | 10.3M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 10.3M | // adjust the return pointer (because the class may multiply inherit, once | 212 | 10.3M | // from pass, once from AnalysisType). | 213 | 10.3M | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 10.3M | } |
llvm::TypeBasedAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::TypeBasedAAWrapperPass>() const Line | Count | Source | 201 | 10.3M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 10.3M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 10.3M | | 204 | 10.3M | const void *PI = &AnalysisType::ID; | 205 | 10.3M | | 206 | 10.3M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 10.3M | if (!ResultPass) return nullptr51.7k ; | 208 | 10.3M | | 209 | 10.3M | // Because the AnalysisType may not be a subclass of pass (for | 210 | 10.3M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 10.3M | // adjust the return pointer (because the class may multiply inherit, once | 212 | 10.3M | // from pass, once from AnalysisType). | 213 | 10.3M | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 10.3M | } |
llvm::objcarc::ObjCARCAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::objcarc::ObjCARCAAWrapperPass>() const Line | Count | Source | 201 | 10.3M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 10.3M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 10.3M | | 204 | 10.3M | const void *PI = &AnalysisType::ID; | 205 | 10.3M | | 206 | 10.3M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 10.3M | if (!ResultPass) return nullptr10.3M ; | 208 | 967 | | 209 | 967 | // Because the AnalysisType may not be a subclass of pass (for | 210 | 967 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 967 | // adjust the return pointer (because the class may multiply inherit, once | 212 | 967 | // from pass, once from AnalysisType). | 213 | 967 | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 967 | } |
llvm::GlobalsAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::GlobalsAAWrapperPass>() const Line | Count | Source | 201 | 10.3M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 10.3M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 10.3M | | 204 | 10.3M | const void *PI = &AnalysisType::ID; | 205 | 10.3M | | 206 | 10.3M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 10.3M | if (!ResultPass) return nullptr2.40M ; | 208 | 7.99M | | 209 | 7.99M | // Because the AnalysisType may not be a subclass of pass (for | 210 | 7.99M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 7.99M | // adjust the return pointer (because the class may multiply inherit, once | 212 | 7.99M | // from pass, once from AnalysisType). | 213 | 7.99M | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 7.99M | } |
llvm::SCEVAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::SCEVAAWrapperPass>() const Line | Count | Source | 201 | 9.24M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 9.24M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 9.24M | | 204 | 9.24M | const void *PI = &AnalysisType::ID; | 205 | 9.24M | | 206 | 9.24M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 9.24M | if (!ResultPass) return nullptr9.24M ; | 208 | 7 | | 209 | 7 | // Because the AnalysisType may not be a subclass of pass (for | 210 | 7 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 7 | // adjust the return pointer (because the class may multiply inherit, once | 212 | 7 | // from pass, once from AnalysisType). | 213 | 7 | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 7 | } |
llvm::CFLAndersAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::CFLAndersAAWrapperPass>() const Line | Count | Source | 201 | 10.3M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 10.3M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 10.3M | | 204 | 10.3M | const void *PI = &AnalysisType::ID; | 205 | 10.3M | | 206 | 10.3M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 10.3M | if (!ResultPass) return nullptr10.3M ; | 208 | 42 | | 209 | 42 | // Because the AnalysisType may not be a subclass of pass (for | 210 | 42 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 42 | // adjust the return pointer (because the class may multiply inherit, once | 212 | 42 | // from pass, once from AnalysisType). | 213 | 42 | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 42 | } |
llvm::CFLSteensAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::CFLSteensAAWrapperPass>() const Line | Count | Source | 201 | 10.3M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 10.3M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 10.3M | | 204 | 10.3M | const void *PI = &AnalysisType::ID; | 205 | 10.3M | | 206 | 10.3M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 10.3M | if (!ResultPass) return nullptr10.3M ; | 208 | 61 | | 209 | 61 | // Because the AnalysisType may not be a subclass of pass (for | 210 | 61 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 61 | // adjust the return pointer (because the class may multiply inherit, once | 212 | 61 | // from pass, once from AnalysisType). | 213 | 61 | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 61 | } |
llvm::ExternalAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::ExternalAAWrapperPass>() const Line | Count | Source | 201 | 9.24M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 9.24M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 9.24M | | 204 | 9.24M | const void *PI = &AnalysisType::ID; | 205 | 9.24M | | 206 | 9.24M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 9.24M | if (!ResultPass) return nullptr9.07M ; | 208 | 166k | | 209 | 166k | // Because the AnalysisType may not be a subclass of pass (for | 210 | 166k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 166k | // adjust the return pointer (because the class may multiply inherit, once | 212 | 166k | // from pass, once from AnalysisType). | 213 | 166k | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 166k | } |
llvm::LoopInfoWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::LoopInfoWrapperPass>() const Line | Count | Source | 201 | 13.2M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 13.2M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 13.2M | | 204 | 13.2M | const void *PI = &AnalysisType::ID; | 205 | 13.2M | | 206 | 13.2M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 13.2M | if (!ResultPass) return nullptr6.31M ; | 208 | 6.96M | | 209 | 6.96M | // Because the AnalysisType may not be a subclass of pass (for | 210 | 6.96M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 6.96M | // adjust the return pointer (because the class may multiply inherit, once | 212 | 6.96M | // from pass, once from AnalysisType). | 213 | 6.96M | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 6.96M | } |
llvm::PhiValuesWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::PhiValuesWrapperPass>() const Line | Count | Source | 201 | 9.43M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 9.43M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 9.43M | | 204 | 9.43M | const void *PI = &AnalysisType::ID; | 205 | 9.43M | | 206 | 9.43M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 9.43M | if (!ResultPass) return nullptr8.50M ; | 208 | 934k | | 209 | 934k | // Because the AnalysisType may not be a subclass of pass (for | 210 | 934k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 934k | // adjust the return pointer (because the class may multiply inherit, once | 212 | 934k | // from pass, once from AnalysisType). | 213 | 934k | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 934k | } |
llvm::TargetTransformInfoWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::TargetTransformInfoWrapperPass>() const Line | Count | Source | 201 | 339k | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 339k | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 339k | | 204 | 339k | const void *PI = &AnalysisType::ID; | 205 | 339k | | 206 | 339k | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 339k | if (!ResultPass) return nullptr0 ; | 208 | 339k | | 209 | 339k | // Because the AnalysisType may not be a subclass of pass (for | 210 | 339k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 339k | // adjust the return pointer (because the class may multiply inherit, once | 212 | 339k | // from pass, once from AnalysisType). | 213 | 339k | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 339k | } |
llvm::AssumptionCacheTracker* llvm::Pass::getAnalysisIfAvailable<llvm::AssumptionCacheTracker>() const Line | Count | Source | 201 | 1.32M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 1.32M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 1.32M | | 204 | 1.32M | const void *PI = &AnalysisType::ID; | 205 | 1.32M | | 206 | 1.32M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 1.32M | if (!ResultPass) return nullptr41 ; | 208 | 1.32M | | 209 | 1.32M | // Because the AnalysisType may not be a subclass of pass (for | 210 | 1.32M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 1.32M | // adjust the return pointer (because the class may multiply inherit, once | 212 | 1.32M | // from pass, once from AnalysisType). | 213 | 1.32M | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 1.32M | } |
llvm::MachineModuleInfo* llvm::Pass::getAnalysisIfAvailable<llvm::MachineModuleInfo>() const Line | Count | Source | 201 | 1.13M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 1.13M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 1.13M | | 204 | 1.13M | const void *PI = &AnalysisType::ID; | 205 | 1.13M | | 206 | 1.13M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 1.13M | if (!ResultPass) return nullptr0 ; | 208 | 1.13M | | 209 | 1.13M | // Because the AnalysisType may not be a subclass of pass (for | 210 | 1.13M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 1.13M | // adjust the return pointer (because the class may multiply inherit, once | 212 | 1.13M | // from pass, once from AnalysisType). | 213 | 1.13M | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 1.13M | } |
llvm::GCModuleInfo* llvm::Pass::getAnalysisIfAvailable<llvm::GCModuleInfo>() const Line | Count | Source | 201 | 123k | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 123k | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 123k | | 204 | 123k | const void *PI = &AnalysisType::ID; | 205 | 123k | | 206 | 123k | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 123k | if (!ResultPass) return nullptr0 ; | 208 | 123k | | 209 | 123k | // Because the AnalysisType may not be a subclass of pass (for | 210 | 123k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 123k | // adjust the return pointer (because the class may multiply inherit, once | 212 | 123k | // from pass, once from AnalysisType). | 213 | 123k | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 123k | } |
llvm::MachineBlockFrequencyInfo* llvm::Pass::getAnalysisIfAvailable<llvm::MachineBlockFrequencyInfo>() const Line | Count | Source | 201 | 60 | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 60 | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 60 | | 204 | 60 | const void *PI = &AnalysisType::ID; | 205 | 60 | | 206 | 60 | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 60 | if (!ResultPass) return nullptr20 ; | 208 | 40 | | 209 | 40 | // Because the AnalysisType may not be a subclass of pass (for | 210 | 40 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 40 | // adjust the return pointer (because the class may multiply inherit, once | 212 | 40 | // from pass, once from AnalysisType). | 213 | 40 | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 40 | } |
llvm::MachineDominatorTree* llvm::Pass::getAnalysisIfAvailable<llvm::MachineDominatorTree>() const Line | Count | Source | 201 | 928k | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 928k | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 928k | | 204 | 928k | const void *PI = &AnalysisType::ID; | 205 | 928k | | 206 | 928k | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 928k | if (!ResultPass) return nullptr371k ; | 208 | 557k | | 209 | 557k | // Because the AnalysisType may not be a subclass of pass (for | 210 | 557k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 557k | // adjust the return pointer (because the class may multiply inherit, once | 212 | 557k | // from pass, once from AnalysisType). | 213 | 557k | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 557k | } |
llvm::SlotIndexes* llvm::Pass::getAnalysisIfAvailable<llvm::SlotIndexes>() const Line | Count | Source | 201 | 2.15M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 2.15M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 2.15M | | 204 | 2.15M | const void *PI = &AnalysisType::ID; | 205 | 2.15M | | 206 | 2.15M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 2.15M | if (!ResultPass) return nullptr1.89M ; | 208 | 262k | | 209 | 262k | // Because the AnalysisType may not be a subclass of pass (for | 210 | 262k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 262k | // adjust the return pointer (because the class may multiply inherit, once | 212 | 262k | // from pass, once from AnalysisType). | 213 | 262k | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 262k | } |
llvm::LiveVariables* llvm::Pass::getAnalysisIfAvailable<llvm::LiveVariables>() const Line | Count | Source | 201 | 2.88M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 2.88M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 2.88M | | 204 | 2.88M | const void *PI = &AnalysisType::ID; | 205 | 2.88M | | 206 | 2.88M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 2.88M | if (!ResultPass) return nullptr1.80M ; | 208 | 1.08M | | 209 | 1.08M | // Because the AnalysisType may not be a subclass of pass (for | 210 | 1.08M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 1.08M | // adjust the return pointer (because the class may multiply inherit, once | 212 | 1.08M | // from pass, once from AnalysisType). | 213 | 1.08M | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 1.08M | } |
llvm::LiveStacks* llvm::Pass::getAnalysisIfAvailable<llvm::LiveStacks>() const Line | Count | Source | 201 | 1.89M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 1.89M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 1.89M | | 204 | 1.89M | const void *PI = &AnalysisType::ID; | 205 | 1.89M | | 206 | 1.89M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 1.89M | if (!ResultPass) return nullptr1.80M ; | 208 | 82.4k | | 209 | 82.4k | // Because the AnalysisType may not be a subclass of pass (for | 210 | 82.4k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 82.4k | // adjust the return pointer (because the class may multiply inherit, once | 212 | 82.4k | // from pass, once from AnalysisType). | 213 | 82.4k | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 82.4k | } |
llvm::AAResultsWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::AAResultsWrapperPass>() const Line | Count | Source | 201 | 475k | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 475k | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 475k | | 204 | 475k | const void *PI = &AnalysisType::ID; | 205 | 475k | | 206 | 475k | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 475k | if (!ResultPass) return nullptr7.82k ; | 208 | 467k | | 209 | 467k | // Because the AnalysisType may not be a subclass of pass (for | 210 | 467k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 467k | // adjust the return pointer (because the class may multiply inherit, once | 212 | 467k | // from pass, once from AnalysisType). | 213 | 467k | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 467k | } |
llvm::CallGraphWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::CallGraphWrapperPass>() const Line | Count | Source | 201 | 13 | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 13 | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 13 | | 204 | 13 | const void *PI = &AnalysisType::ID; | 205 | 13 | | 206 | 13 | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 13 | if (!ResultPass) return nullptr; | 208 | 0 | | 209 | 0 | // Because the AnalysisType may not be a subclass of pass (for | 210 | 0 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 0 | // adjust the return pointer (because the class may multiply inherit, once | 212 | 0 | // from pass, once from AnalysisType). | 213 | 0 | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 0 | } |
llvm::PostDominatorTreeWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::PostDominatorTreeWrapperPass>() const Line | Count | Source | 201 | 457k | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 457k | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 457k | | 204 | 457k | const void *PI = &AnalysisType::ID; | 205 | 457k | | 206 | 457k | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 457k | if (!ResultPass) return nullptr457k ; | 208 | 2 | | 209 | 2 | // Because the AnalysisType may not be a subclass of pass (for | 210 | 2 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 2 | // adjust the return pointer (because the class may multiply inherit, once | 212 | 2 | // from pass, once from AnalysisType). | 213 | 2 | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 2 | } |
llvm::ScalarEvolutionWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::ScalarEvolutionWrapperPass>() const Line | Count | Source | 201 | 6.98M | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 6.98M | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 6.98M | | 204 | 6.98M | const void *PI = &AnalysisType::ID; | 205 | 6.98M | | 206 | 6.98M | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 6.98M | if (!ResultPass) return nullptr5.50M ; | 208 | 1.48M | | 209 | 1.48M | // Because the AnalysisType may not be a subclass of pass (for | 210 | 1.48M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 1.48M | // adjust the return pointer (because the class may multiply inherit, once | 212 | 1.48M | // from pass, once from AnalysisType). | 213 | 1.48M | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 1.48M | } |
llvm::RegionInfoPass* llvm::Pass::getAnalysisIfAvailable<llvm::RegionInfoPass>() const Line | Count | Source | 201 | 13 | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 13 | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 13 | | 204 | 13 | const void *PI = &AnalysisType::ID; | 205 | 13 | | 206 | 13 | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 13 | if (!ResultPass) return nullptr; | 208 | 0 | | 209 | 0 | // Because the AnalysisType may not be a subclass of pass (for | 210 | 0 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 0 | // adjust the return pointer (because the class may multiply inherit, once | 212 | 0 | // from pass, once from AnalysisType). | 213 | 0 | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 0 | } |
Unexecuted instantiation: llvm::MachineBranchProbabilityInfo* llvm::Pass::getAnalysisIfAvailable<llvm::MachineBranchProbabilityInfo>() const llvm::LegacyDivergenceAnalysis* llvm::Pass::getAnalysisIfAvailable<llvm::LegacyDivergenceAnalysis>() const Line | Count | Source | 201 | 259k | AnalysisType *Pass::getAnalysisIfAvailable() const { | 202 | 259k | assert(Resolver && "Pass not resident in a PassManager object!"); | 203 | 259k | | 204 | 259k | const void *PI = &AnalysisType::ID; | 205 | 259k | | 206 | 259k | Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true); | 207 | 259k | if (!ResultPass) return nullptr235k ; | 208 | 23.5k | | 209 | 23.5k | // Because the AnalysisType may not be a subclass of pass (for | 210 | 23.5k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 211 | 23.5k | // adjust the return pointer (because the class may multiply inherit, once | 212 | 23.5k | // from pass, once from AnalysisType). | 213 | 23.5k | return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 214 | 23.5k | } |
|
215 | | |
216 | | /// getAnalysis<AnalysisType>() - This function is used by subclasses to get |
217 | | /// to the analysis information that they claim to use by overriding the |
218 | | /// getAnalysisUsage function. |
219 | | template<typename AnalysisType> |
220 | 328M | AnalysisType &Pass::getAnalysis() const { |
221 | 328M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); |
222 | 328M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); |
223 | 328M | } llvm::MachineDominatorTree& llvm::Pass::getAnalysis<llvm::MachineDominatorTree>() const Line | Count | Source | 220 | 7.63M | AnalysisType &Pass::getAnalysis() const { | 221 | 7.63M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 7.63M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 7.63M | } |
llvm::MachineBranchProbabilityInfo& llvm::Pass::getAnalysis<llvm::MachineBranchProbabilityInfo>() const Line | Count | Source | 220 | 4.23M | AnalysisType &Pass::getAnalysis() const { | 221 | 4.23M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 4.23M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 4.23M | } |
llvm::MachineTraceMetrics& llvm::Pass::getAnalysis<llvm::MachineTraceMetrics>() const Line | Count | Source | 220 | 1.17M | AnalysisType &Pass::getAnalysis() const { | 221 | 1.17M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 1.17M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 1.17M | } |
llvm::TargetPassConfig& llvm::Pass::getAnalysis<llvm::TargetPassConfig>() const Line | Count | Source | 220 | 3.62M | AnalysisType &Pass::getAnalysis() const { | 221 | 3.62M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 3.62M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 3.62M | } |
llvm::LoopInfoWrapperPass& llvm::Pass::getAnalysis<llvm::LoopInfoWrapperPass>() const Line | Count | Source | 220 | 34.5M | AnalysisType &Pass::getAnalysis() const { | 221 | 34.5M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 34.5M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 34.5M | } |
llvm::ScalarEvolutionWrapperPass& llvm::Pass::getAnalysis<llvm::ScalarEvolutionWrapperPass>() const Line | Count | Source | 220 | 3.80M | AnalysisType &Pass::getAnalysis() const { | 221 | 3.80M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 3.80M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 3.80M | } |
llvm::MachineLoopInfo& llvm::Pass::getAnalysis<llvm::MachineLoopInfo>() const Line | Count | Source | 220 | 8.60M | AnalysisType &Pass::getAnalysis() const { | 221 | 8.60M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 8.60M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 8.60M | } |
llvm::AAResultsWrapperPass& llvm::Pass::getAnalysis<llvm::AAResultsWrapperPass>() const Line | Count | Source | 220 | 16.7M | AnalysisType &Pass::getAnalysis() const { | 221 | 16.7M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 16.7M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 16.7M | } |
llvm::LegacyDivergenceAnalysis& llvm::Pass::getAnalysis<llvm::LegacyDivergenceAnalysis>() const Line | Count | Source | 220 | 65.0k | AnalysisType &Pass::getAnalysis() const { | 221 | 65.0k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 65.0k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 65.0k | } |
llvm::MemoryDependenceWrapperPass& llvm::Pass::getAnalysis<llvm::MemoryDependenceWrapperPass>() const Line | Count | Source | 220 | 1.39M | AnalysisType &Pass::getAnalysis() const { | 221 | 1.39M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 1.39M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 1.39M | } |
llvm::AssumptionCacheTracker& llvm::Pass::getAnalysis<llvm::AssumptionCacheTracker>() const Line | Count | Source | 220 | 35.1M | AnalysisType &Pass::getAnalysis() const { | 221 | 35.1M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 35.1M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 35.1M | } |
llvm::TargetTransformInfoWrapperPass& llvm::Pass::getAnalysis<llvm::TargetTransformInfoWrapperPass>() const Line | Count | Source | 220 | 14.1M | AnalysisType &Pass::getAnalysis() const { | 221 | 14.1M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 14.1M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 14.1M | } |
Unexecuted instantiation: llvm::MachineRegionInfoPass& llvm::Pass::getAnalysis<llvm::MachineRegionInfoPass>() const llvm::PostDominatorTreeWrapperPass& llvm::Pass::getAnalysis<llvm::PostDominatorTreeWrapperPass>() const Line | Count | Source | 220 | 612k | AnalysisType &Pass::getAnalysis() const { | 221 | 612k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 612k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 612k | } |
llvm::MachinePostDominatorTree& llvm::Pass::getAnalysis<llvm::MachinePostDominatorTree>() const Line | Count | Source | 220 | 990k | AnalysisType &Pass::getAnalysis() const { | 221 | 990k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 990k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 990k | } |
llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysis<llvm::DominatorTreeWrapperPass>() const Line | Count | Source | 220 | 46.3M | AnalysisType &Pass::getAnalysis() const { | 221 | 46.3M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 46.3M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 46.3M | } |
llvm::LiveIntervals& llvm::Pass::getAnalysis<llvm::LiveIntervals>() const Line | Count | Source | 220 | 3.34M | AnalysisType &Pass::getAnalysis() const { | 221 | 3.34M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 3.34M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 3.34M | } |
llvm::AMDGPUArgumentUsageInfo& llvm::Pass::getAnalysis<llvm::AMDGPUArgumentUsageInfo>() const Line | Count | Source | 220 | 21.8k | AnalysisType &Pass::getAnalysis() const { | 221 | 21.8k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 21.8k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 21.8k | } |
llvm::TargetLibraryInfoWrapperPass& llvm::Pass::getAnalysis<llvm::TargetLibraryInfoWrapperPass>() const Line | Count | Source | 220 | 48.0M | AnalysisType &Pass::getAnalysis() const { | 221 | 48.0M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 48.0M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 48.0M | } |
llvm::MachineDominanceFrontier& llvm::Pass::getAnalysis<llvm::MachineDominanceFrontier>() const Line | Count | Source | 220 | 10.2k | AnalysisType &Pass::getAnalysis() const { | 221 | 10.2k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 10.2k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 10.2k | } |
llvm::WebAssemblyExceptionInfo& llvm::Pass::getAnalysis<llvm::WebAssemblyExceptionInfo>() const Line | Count | Source | 220 | 3.72k | AnalysisType &Pass::getAnalysis() const { | 221 | 3.72k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 3.72k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 3.72k | } |
llvm::MachineBlockFrequencyInfo& llvm::Pass::getAnalysis<llvm::MachineBlockFrequencyInfo>() const Line | Count | Source | 220 | 3.79M | AnalysisType &Pass::getAnalysis() const { | 221 | 3.79M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 3.79M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 3.79M | } |
llvm::EdgeBundles& llvm::Pass::getAnalysis<llvm::EdgeBundles>() const Line | Count | Source | 220 | 926k | AnalysisType &Pass::getAnalysis() const { | 221 | 926k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 926k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 926k | } |
llvm::MachineModuleInfo& llvm::Pass::getAnalysis<llvm::MachineModuleInfo>() const Line | Count | Source | 220 | 49.9M | AnalysisType &Pass::getAnalysis() const { | 221 | 49.9M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 49.9M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 49.9M | } |
llvm::BasicAAWrapperPass& llvm::Pass::getAnalysis<llvm::BasicAAWrapperPass>() const Line | Count | Source | 220 | 9.24M | AnalysisType &Pass::getAnalysis() const { | 221 | 9.24M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 9.24M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 9.24M | } |
llvm::BranchProbabilityInfoWrapperPass& llvm::Pass::getAnalysis<llvm::BranchProbabilityInfoWrapperPass>() const Line | Count | Source | 220 | 2.04M | AnalysisType &Pass::getAnalysis() const { | 221 | 2.04M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 2.04M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 2.04M | } |
llvm::CallGraphWrapperPass& llvm::Pass::getAnalysis<llvm::CallGraphWrapperPass>() const Line | Count | Source | 220 | 2.15M | AnalysisType &Pass::getAnalysis() const { | 221 | 2.15M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 2.15M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 2.15M | } |
llvm::LazyBranchProbabilityInfoPass& llvm::Pass::getAnalysis<llvm::LazyBranchProbabilityInfoPass>() const Line | Count | Source | 220 | 5.87M | AnalysisType &Pass::getAnalysis() const { | 221 | 5.87M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 5.87M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 5.87M | } |
llvm::LazyValueInfoWrapperPass& llvm::Pass::getAnalysis<llvm::LazyValueInfoWrapperPass>() const Line | Count | Source | 220 | 1.83M | AnalysisType &Pass::getAnalysis() const { | 221 | 1.83M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 1.83M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 1.83M | } |
llvm::PhiValuesWrapperPass& llvm::Pass::getAnalysis<llvm::PhiValuesWrapperPass>() const Line | Count | Source | 220 | 1.39M | AnalysisType &Pass::getAnalysis() const { | 221 | 1.39M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 1.39M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 1.39M | } |
llvm::MemorySSAWrapperPass& llvm::Pass::getAnalysis<llvm::MemorySSAWrapperPass>() const Line | Count | Source | 220 | 714k | AnalysisType &Pass::getAnalysis() const { | 221 | 714k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 714k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 714k | } |
llvm::ProfileSummaryInfoWrapperPass& llvm::Pass::getAnalysis<llvm::ProfileSummaryInfoWrapperPass>() const Line | Count | Source | 220 | 1.30M | AnalysisType &Pass::getAnalysis() const { | 221 | 1.30M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 1.30M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 1.30M | } |
llvm::LazyBlockFrequencyInfoPass& llvm::Pass::getAnalysis<llvm::LazyBlockFrequencyInfoPass>() const Line | Count | Source | 220 | 217 | AnalysisType &Pass::getAnalysis() const { | 221 | 217 | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 217 | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 217 | } |
llvm::DominanceFrontierWrapperPass& llvm::Pass::getAnalysis<llvm::DominanceFrontierWrapperPass>() const Line | Count | Source | 220 | 24.6k | AnalysisType &Pass::getAnalysis() const { | 221 | 24.6k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 24.6k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 24.6k | } |
llvm::RegionInfoPass& llvm::Pass::getAnalysis<llvm::RegionInfoPass>() const Line | Count | Source | 220 | 26.1k | AnalysisType &Pass::getAnalysis() const { | 221 | 26.1k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 26.1k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 26.1k | } |
llvm::ReachingDefAnalysis& llvm::Pass::getAnalysis<llvm::ReachingDefAnalysis>() const Line | Count | Source | 220 | 268k | AnalysisType &Pass::getAnalysis() const { | 221 | 268k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 268k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 268k | } |
llvm::GCModuleInfo& llvm::Pass::getAnalysis<llvm::GCModuleInfo>() const Line | Count | Source | 220 | 240 | AnalysisType &Pass::getAnalysis() const { | 221 | 240 | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 240 | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 240 | } |
llvm::LiveStacks& llvm::Pass::getAnalysis<llvm::LiveStacks>() const Line | Count | Source | 220 | 1.38M | AnalysisType &Pass::getAnalysis() const { | 221 | 1.38M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 1.38M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 1.38M | } |
llvm::SlotIndexes& llvm::Pass::getAnalysis<llvm::SlotIndexes>() const Line | Count | Source | 220 | 1.89M | AnalysisType &Pass::getAnalysis() const { | 221 | 1.89M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 1.89M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 1.89M | } |
llvm::VirtRegMap& llvm::Pass::getAnalysis<llvm::VirtRegMap>() const Line | Count | Source | 220 | 1.38M | AnalysisType &Pass::getAnalysis() const { | 221 | 1.38M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 1.38M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 1.38M | } |
llvm::LazyMachineBlockFrequencyInfoPass& llvm::Pass::getAnalysis<llvm::LazyMachineBlockFrequencyInfoPass>() const Line | Count | Source | 220 | 60 | AnalysisType &Pass::getAnalysis() const { | 221 | 60 | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 60 | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 60 | } |
llvm::MachineOptimizationRemarkEmitterPass& llvm::Pass::getAnalysis<llvm::MachineOptimizationRemarkEmitterPass>() const Line | Count | Source | 220 | 1.76M | AnalysisType &Pass::getAnalysis() const { | 221 | 1.76M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 1.76M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 1.76M | } |
llvm::LiveRegMatrix& llvm::Pass::getAnalysis<llvm::LiveRegMatrix>() const Line | Count | Source | 220 | 462k | AnalysisType &Pass::getAnalysis() const { | 221 | 462k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 462k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 462k | } |
llvm::SpillPlacement& llvm::Pass::getAnalysis<llvm::SpillPlacement>() const Line | Count | Source | 220 | 462k | AnalysisType &Pass::getAnalysis() const { | 221 | 462k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 462k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 462k | } |
llvm::LiveDebugVariables& llvm::Pass::getAnalysis<llvm::LiveDebugVariables>() const Line | Count | Source | 220 | 924k | AnalysisType &Pass::getAnalysis() const { | 221 | 924k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 924k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 924k | } |
llvm::PhysicalRegisterUsageInfo& llvm::Pass::getAnalysis<llvm::PhysicalRegisterUsageInfo>() const Line | Count | Source | 220 | 41.9k | AnalysisType &Pass::getAnalysis() const { | 221 | 41.9k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 41.9k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 41.9k | } |
llvm::ModuleSummaryIndexWrapperPass& llvm::Pass::getAnalysis<llvm::ModuleSummaryIndexWrapperPass>() const Line | Count | Source | 220 | 354 | AnalysisType &Pass::getAnalysis() const { | 221 | 354 | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 354 | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 354 | } |
llvm::OptimizationRemarkEmitterWrapperPass& llvm::Pass::getAnalysis<llvm::OptimizationRemarkEmitterWrapperPass>() const Line | Count | Source | 220 | 6.15M | AnalysisType &Pass::getAnalysis() const { | 221 | 6.15M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 6.15M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 6.15M | } |
AddressSanitizer.cpp:(anonymous namespace)::ASanGlobalsMetadataWrapperPass& llvm::Pass::getAnalysis<(anonymous namespace)::ASanGlobalsMetadataWrapperPass>() const Line | Count | Source | 220 | 947 | AnalysisType &Pass::getAnalysis() const { | 221 | 947 | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 947 | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 947 | } |
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysis<llvm::BlockFrequencyInfoWrapperPass>() const Line | Count | Source | 220 | 1.38M | AnalysisType &Pass::getAnalysis() const { | 221 | 1.38M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 1.38M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 1.38M | } |
llvm::DemandedBitsWrapperPass& llvm::Pass::getAnalysis<llvm::DemandedBitsWrapperPass>() const Line | Count | Source | 220 | 1.01M | AnalysisType &Pass::getAnalysis() const { | 221 | 1.01M | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 1.01M | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 1.01M | } |
llvm::LoopAccessLegacyAnalysis& llvm::Pass::getAnalysis<llvm::LoopAccessLegacyAnalysis>() const Line | Count | Source | 220 | 832k | AnalysisType &Pass::getAnalysis() const { | 221 | 832k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 832k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 832k | } |
llvm::DependenceAnalysisWrapperPass& llvm::Pass::getAnalysis<llvm::DependenceAnalysisWrapperPass>() const Line | Count | Source | 220 | 156 | AnalysisType &Pass::getAnalysis() const { | 221 | 156 | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 156 | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 156 | } |
llvm::IVUsersWrapperPass& llvm::Pass::getAnalysis<llvm::IVUsersWrapperPass>() const Line | Count | Source | 220 | 206k | AnalysisType &Pass::getAnalysis() const { | 221 | 206k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 206k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 206k | } |
polly::ScopInfoWrapperPass& llvm::Pass::getAnalysis<polly::ScopInfoWrapperPass>() const Line | Count | Source | 220 | 45 | AnalysisType &Pass::getAnalysis() const { | 221 | 45 | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 45 | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 45 | } |
polly::DependenceInfoWrapperPass& llvm::Pass::getAnalysis<polly::DependenceInfoWrapperPass>() const Line | Count | Source | 220 | 19 | AnalysisType &Pass::getAnalysis() const { | 221 | 19 | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 19 | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 19 | } |
polly::ScopDetectionWrapperPass& llvm::Pass::getAnalysis<polly::ScopDetectionWrapperPass>() const Line | Count | Source | 220 | 4.25k | AnalysisType &Pass::getAnalysis() const { | 221 | 4.25k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 4.25k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 4.25k | } |
polly::ScopInfoRegionPass& llvm::Pass::getAnalysis<polly::ScopInfoRegionPass>() const Line | Count | Source | 220 | 6.56k | AnalysisType &Pass::getAnalysis() const { | 221 | 6.56k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 6.56k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 6.56k | } |
polly::DependenceInfo& llvm::Pass::getAnalysis<polly::DependenceInfo>() const Line | Count | Source | 220 | 609 | AnalysisType &Pass::getAnalysis() const { | 221 | 609 | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 609 | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 609 | } |
polly::IslAstInfoWrapperPass& llvm::Pass::getAnalysis<polly::IslAstInfoWrapperPass>() const Line | Count | Source | 220 | 294 | AnalysisType &Pass::getAnalysis() const { | 221 | 294 | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 294 | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 294 | } |
llvm::GISelCSEAnalysisWrapperPass& llvm::Pass::getAnalysis<llvm::GISelCSEAnalysisWrapperPass>() const Line | Count | Source | 220 | 473k | AnalysisType &Pass::getAnalysis() const { | 221 | 473k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 473k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 473k | } |
llvm::StackProtector& llvm::Pass::getAnalysis<llvm::StackProtector>() const Line | Count | Source | 220 | 494k | AnalysisType &Pass::getAnalysis() const { | 221 | 494k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 222 | 494k | return getAnalysisID<AnalysisType>(&AnalysisType::ID); | 223 | 494k | } |
|
224 | | |
225 | | template<typename AnalysisType> |
226 | 329M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { |
227 | 329M | assert(PI && "getAnalysis for unregistered pass!"); |
228 | 329M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); |
229 | 329M | // PI *must* appear in AnalysisImpls. Because the number of passes used |
230 | 329M | // should be a small number, we just do a linear search over a (dense) |
231 | 329M | // vector. |
232 | 329M | Pass *ResultPass = Resolver->findImplPass(PI); |
233 | 329M | assert(ResultPass && |
234 | 329M | "getAnalysis*() called on an analysis that was not " |
235 | 329M | "'required' by pass!"); |
236 | 329M | |
237 | 329M | // Because the AnalysisType may not be a subclass of pass (for |
238 | 329M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially |
239 | 329M | // adjust the return pointer (because the class may multiply inherit, once |
240 | 329M | // from pass, once from AnalysisType). |
241 | 329M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); |
242 | 329M | } llvm::MachineDominatorTree& llvm::Pass::getAnalysisID<llvm::MachineDominatorTree>(void const*) const Line | Count | Source | 226 | 7.63M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 7.63M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 7.63M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 7.63M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 7.63M | // should be a small number, we just do a linear search over a (dense) | 231 | 7.63M | // vector. | 232 | 7.63M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 7.63M | assert(ResultPass && | 234 | 7.63M | "getAnalysis*() called on an analysis that was not " | 235 | 7.63M | "'required' by pass!"); | 236 | 7.63M | | 237 | 7.63M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 7.63M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 7.63M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 7.63M | // from pass, once from AnalysisType). | 241 | 7.63M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 7.63M | } |
llvm::MachineBranchProbabilityInfo& llvm::Pass::getAnalysisID<llvm::MachineBranchProbabilityInfo>(void const*) const Line | Count | Source | 226 | 4.23M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 4.23M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 4.23M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 4.23M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 4.23M | // should be a small number, we just do a linear search over a (dense) | 231 | 4.23M | // vector. | 232 | 4.23M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 4.23M | assert(ResultPass && | 234 | 4.23M | "getAnalysis*() called on an analysis that was not " | 235 | 4.23M | "'required' by pass!"); | 236 | 4.23M | | 237 | 4.23M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 4.23M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 4.23M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 4.23M | // from pass, once from AnalysisType). | 241 | 4.23M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 4.23M | } |
llvm::MachineTraceMetrics& llvm::Pass::getAnalysisID<llvm::MachineTraceMetrics>(void const*) const Line | Count | Source | 226 | 1.17M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 1.17M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 1.17M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 1.17M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 1.17M | // should be a small number, we just do a linear search over a (dense) | 231 | 1.17M | // vector. | 232 | 1.17M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 1.17M | assert(ResultPass && | 234 | 1.17M | "getAnalysis*() called on an analysis that was not " | 235 | 1.17M | "'required' by pass!"); | 236 | 1.17M | | 237 | 1.17M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 1.17M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 1.17M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 1.17M | // from pass, once from AnalysisType). | 241 | 1.17M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 1.17M | } |
llvm::TargetPassConfig& llvm::Pass::getAnalysisID<llvm::TargetPassConfig>(void const*) const Line | Count | Source | 226 | 3.62M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 3.62M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 3.62M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 3.62M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 3.62M | // should be a small number, we just do a linear search over a (dense) | 231 | 3.62M | // vector. | 232 | 3.62M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 3.62M | assert(ResultPass && | 234 | 3.62M | "getAnalysis*() called on an analysis that was not " | 235 | 3.62M | "'required' by pass!"); | 236 | 3.62M | | 237 | 3.62M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 3.62M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 3.62M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 3.62M | // from pass, once from AnalysisType). | 241 | 3.62M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 3.62M | } |
llvm::LoopInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::LoopInfoWrapperPass>(void const*) const Line | Count | Source | 226 | 34.5M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 34.5M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 34.5M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 34.5M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 34.5M | // should be a small number, we just do a linear search over a (dense) | 231 | 34.5M | // vector. | 232 | 34.5M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 34.5M | assert(ResultPass && | 234 | 34.5M | "getAnalysis*() called on an analysis that was not " | 235 | 34.5M | "'required' by pass!"); | 236 | 34.5M | | 237 | 34.5M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 34.5M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 34.5M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 34.5M | // from pass, once from AnalysisType). | 241 | 34.5M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 34.5M | } |
llvm::ScalarEvolutionWrapperPass& llvm::Pass::getAnalysisID<llvm::ScalarEvolutionWrapperPass>(void const*) const Line | Count | Source | 226 | 3.80M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 3.80M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 3.80M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 3.80M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 3.80M | // should be a small number, we just do a linear search over a (dense) | 231 | 3.80M | // vector. | 232 | 3.80M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 3.80M | assert(ResultPass && | 234 | 3.80M | "getAnalysis*() called on an analysis that was not " | 235 | 3.80M | "'required' by pass!"); | 236 | 3.80M | | 237 | 3.80M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 3.80M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 3.80M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 3.80M | // from pass, once from AnalysisType). | 241 | 3.80M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 3.80M | } |
llvm::MachineLoopInfo& llvm::Pass::getAnalysisID<llvm::MachineLoopInfo>(void const*) const Line | Count | Source | 226 | 8.60M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 8.60M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 8.60M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 8.60M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 8.60M | // should be a small number, we just do a linear search over a (dense) | 231 | 8.60M | // vector. | 232 | 8.60M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 8.60M | assert(ResultPass && | 234 | 8.60M | "getAnalysis*() called on an analysis that was not " | 235 | 8.60M | "'required' by pass!"); | 236 | 8.60M | | 237 | 8.60M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 8.60M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 8.60M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 8.60M | // from pass, once from AnalysisType). | 241 | 8.60M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 8.60M | } |
llvm::AAResultsWrapperPass& llvm::Pass::getAnalysisID<llvm::AAResultsWrapperPass>(void const*) const Line | Count | Source | 226 | 16.7M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 16.7M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 16.7M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 16.7M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 16.7M | // should be a small number, we just do a linear search over a (dense) | 231 | 16.7M | // vector. | 232 | 16.7M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 16.7M | assert(ResultPass && | 234 | 16.7M | "getAnalysis*() called on an analysis that was not " | 235 | 16.7M | "'required' by pass!"); | 236 | 16.7M | | 237 | 16.7M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 16.7M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 16.7M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 16.7M | // from pass, once from AnalysisType). | 241 | 16.7M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 16.7M | } |
llvm::LegacyDivergenceAnalysis& llvm::Pass::getAnalysisID<llvm::LegacyDivergenceAnalysis>(void const*) const Line | Count | Source | 226 | 65.0k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 65.0k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 65.0k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 65.0k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 65.0k | // should be a small number, we just do a linear search over a (dense) | 231 | 65.0k | // vector. | 232 | 65.0k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 65.0k | assert(ResultPass && | 234 | 65.0k | "getAnalysis*() called on an analysis that was not " | 235 | 65.0k | "'required' by pass!"); | 236 | 65.0k | | 237 | 65.0k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 65.0k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 65.0k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 65.0k | // from pass, once from AnalysisType). | 241 | 65.0k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 65.0k | } |
llvm::MemoryDependenceWrapperPass& llvm::Pass::getAnalysisID<llvm::MemoryDependenceWrapperPass>(void const*) const Line | Count | Source | 226 | 1.39M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 1.39M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 1.39M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 1.39M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 1.39M | // should be a small number, we just do a linear search over a (dense) | 231 | 1.39M | // vector. | 232 | 1.39M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 1.39M | assert(ResultPass && | 234 | 1.39M | "getAnalysis*() called on an analysis that was not " | 235 | 1.39M | "'required' by pass!"); | 236 | 1.39M | | 237 | 1.39M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 1.39M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 1.39M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 1.39M | // from pass, once from AnalysisType). | 241 | 1.39M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 1.39M | } |
llvm::AssumptionCacheTracker& llvm::Pass::getAnalysisID<llvm::AssumptionCacheTracker>(void const*) const Line | Count | Source | 226 | 35.1M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 35.1M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 35.1M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 35.1M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 35.1M | // should be a small number, we just do a linear search over a (dense) | 231 | 35.1M | // vector. | 232 | 35.1M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 35.1M | assert(ResultPass && | 234 | 35.1M | "getAnalysis*() called on an analysis that was not " | 235 | 35.1M | "'required' by pass!"); | 236 | 35.1M | | 237 | 35.1M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 35.1M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 35.1M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 35.1M | // from pass, once from AnalysisType). | 241 | 35.1M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 35.1M | } |
llvm::TargetTransformInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::TargetTransformInfoWrapperPass>(void const*) const Line | Count | Source | 226 | 14.1M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 14.1M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 14.1M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 14.1M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 14.1M | // should be a small number, we just do a linear search over a (dense) | 231 | 14.1M | // vector. | 232 | 14.1M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 14.1M | assert(ResultPass && | 234 | 14.1M | "getAnalysis*() called on an analysis that was not " | 235 | 14.1M | "'required' by pass!"); | 236 | 14.1M | | 237 | 14.1M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 14.1M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 14.1M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 14.1M | // from pass, once from AnalysisType). | 241 | 14.1M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 14.1M | } |
Unexecuted instantiation: llvm::MachineRegionInfoPass& llvm::Pass::getAnalysisID<llvm::MachineRegionInfoPass>(void const*) const llvm::PostDominatorTreeWrapperPass& llvm::Pass::getAnalysisID<llvm::PostDominatorTreeWrapperPass>(void const*) const Line | Count | Source | 226 | 612k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 612k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 612k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 612k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 612k | // should be a small number, we just do a linear search over a (dense) | 231 | 612k | // vector. | 232 | 612k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 612k | assert(ResultPass && | 234 | 612k | "getAnalysis*() called on an analysis that was not " | 235 | 612k | "'required' by pass!"); | 236 | 612k | | 237 | 612k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 612k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 612k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 612k | // from pass, once from AnalysisType). | 241 | 612k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 612k | } |
llvm::MachinePostDominatorTree& llvm::Pass::getAnalysisID<llvm::MachinePostDominatorTree>(void const*) const Line | Count | Source | 226 | 990k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 990k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 990k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 990k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 990k | // should be a small number, we just do a linear search over a (dense) | 231 | 990k | // vector. | 232 | 990k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 990k | assert(ResultPass && | 234 | 990k | "getAnalysis*() called on an analysis that was not " | 235 | 990k | "'required' by pass!"); | 236 | 990k | | 237 | 990k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 990k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 990k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 990k | // from pass, once from AnalysisType). | 241 | 990k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 990k | } |
llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysisID<llvm::DominatorTreeWrapperPass>(void const*) const Line | Count | Source | 226 | 46.3M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 46.3M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 46.3M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 46.3M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 46.3M | // should be a small number, we just do a linear search over a (dense) | 231 | 46.3M | // vector. | 232 | 46.3M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 46.3M | assert(ResultPass && | 234 | 46.3M | "getAnalysis*() called on an analysis that was not " | 235 | 46.3M | "'required' by pass!"); | 236 | 46.3M | | 237 | 46.3M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 46.3M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 46.3M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 46.3M | // from pass, once from AnalysisType). | 241 | 46.3M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 46.3M | } |
llvm::LiveIntervals& llvm::Pass::getAnalysisID<llvm::LiveIntervals>(void const*) const Line | Count | Source | 226 | 3.34M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 3.34M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 3.34M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 3.34M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 3.34M | // should be a small number, we just do a linear search over a (dense) | 231 | 3.34M | // vector. | 232 | 3.34M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 3.34M | assert(ResultPass && | 234 | 3.34M | "getAnalysis*() called on an analysis that was not " | 235 | 3.34M | "'required' by pass!"); | 236 | 3.34M | | 237 | 3.34M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 3.34M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 3.34M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 3.34M | // from pass, once from AnalysisType). | 241 | 3.34M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 3.34M | } |
llvm::AMDGPUArgumentUsageInfo& llvm::Pass::getAnalysisID<llvm::AMDGPUArgumentUsageInfo>(void const*) const Line | Count | Source | 226 | 21.8k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 21.8k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 21.8k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 21.8k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 21.8k | // should be a small number, we just do a linear search over a (dense) | 231 | 21.8k | // vector. | 232 | 21.8k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 21.8k | assert(ResultPass && | 234 | 21.8k | "getAnalysis*() called on an analysis that was not " | 235 | 21.8k | "'required' by pass!"); | 236 | 21.8k | | 237 | 21.8k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 21.8k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 21.8k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 21.8k | // from pass, once from AnalysisType). | 241 | 21.8k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 21.8k | } |
llvm::TargetLibraryInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::TargetLibraryInfoWrapperPass>(void const*) const Line | Count | Source | 226 | 48.0M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 48.0M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 48.0M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 48.0M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 48.0M | // should be a small number, we just do a linear search over a (dense) | 231 | 48.0M | // vector. | 232 | 48.0M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 48.0M | assert(ResultPass && | 234 | 48.0M | "getAnalysis*() called on an analysis that was not " | 235 | 48.0M | "'required' by pass!"); | 236 | 48.0M | | 237 | 48.0M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 48.0M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 48.0M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 48.0M | // from pass, once from AnalysisType). | 241 | 48.0M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 48.0M | } |
llvm::MachineDominanceFrontier& llvm::Pass::getAnalysisID<llvm::MachineDominanceFrontier>(void const*) const Line | Count | Source | 226 | 10.2k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 10.2k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 10.2k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 10.2k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 10.2k | // should be a small number, we just do a linear search over a (dense) | 231 | 10.2k | // vector. | 232 | 10.2k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 10.2k | assert(ResultPass && | 234 | 10.2k | "getAnalysis*() called on an analysis that was not " | 235 | 10.2k | "'required' by pass!"); | 236 | 10.2k | | 237 | 10.2k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 10.2k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 10.2k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 10.2k | // from pass, once from AnalysisType). | 241 | 10.2k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 10.2k | } |
llvm::WebAssemblyExceptionInfo& llvm::Pass::getAnalysisID<llvm::WebAssemblyExceptionInfo>(void const*) const Line | Count | Source | 226 | 3.72k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 3.72k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 3.72k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 3.72k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 3.72k | // should be a small number, we just do a linear search over a (dense) | 231 | 3.72k | // vector. | 232 | 3.72k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 3.72k | assert(ResultPass && | 234 | 3.72k | "getAnalysis*() called on an analysis that was not " | 235 | 3.72k | "'required' by pass!"); | 236 | 3.72k | | 237 | 3.72k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 3.72k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 3.72k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 3.72k | // from pass, once from AnalysisType). | 241 | 3.72k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 3.72k | } |
llvm::MachineBlockFrequencyInfo& llvm::Pass::getAnalysisID<llvm::MachineBlockFrequencyInfo>(void const*) const Line | Count | Source | 226 | 3.79M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 3.79M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 3.79M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 3.79M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 3.79M | // should be a small number, we just do a linear search over a (dense) | 231 | 3.79M | // vector. | 232 | 3.79M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 3.79M | assert(ResultPass && | 234 | 3.79M | "getAnalysis*() called on an analysis that was not " | 235 | 3.79M | "'required' by pass!"); | 236 | 3.79M | | 237 | 3.79M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 3.79M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 3.79M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 3.79M | // from pass, once from AnalysisType). | 241 | 3.79M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 3.79M | } |
llvm::EdgeBundles& llvm::Pass::getAnalysisID<llvm::EdgeBundles>(void const*) const Line | Count | Source | 226 | 926k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 926k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 926k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 926k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 926k | // should be a small number, we just do a linear search over a (dense) | 231 | 926k | // vector. | 232 | 926k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 926k | assert(ResultPass && | 234 | 926k | "getAnalysis*() called on an analysis that was not " | 235 | 926k | "'required' by pass!"); | 236 | 926k | | 237 | 926k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 926k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 926k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 926k | // from pass, once from AnalysisType). | 241 | 926k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 926k | } |
llvm::MachineModuleInfo& llvm::Pass::getAnalysisID<llvm::MachineModuleInfo>(void const*) const Line | Count | Source | 226 | 49.9M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 49.9M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 49.9M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 49.9M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 49.9M | // should be a small number, we just do a linear search over a (dense) | 231 | 49.9M | // vector. | 232 | 49.9M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 49.9M | assert(ResultPass && | 234 | 49.9M | "getAnalysis*() called on an analysis that was not " | 235 | 49.9M | "'required' by pass!"); | 236 | 49.9M | | 237 | 49.9M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 49.9M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 49.9M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 49.9M | // from pass, once from AnalysisType). | 241 | 49.9M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 49.9M | } |
llvm::BasicAAWrapperPass& llvm::Pass::getAnalysisID<llvm::BasicAAWrapperPass>(void const*) const Line | Count | Source | 226 | 9.24M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 9.24M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 9.24M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 9.24M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 9.24M | // should be a small number, we just do a linear search over a (dense) | 231 | 9.24M | // vector. | 232 | 9.24M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 9.24M | assert(ResultPass && | 234 | 9.24M | "getAnalysis*() called on an analysis that was not " | 235 | 9.24M | "'required' by pass!"); | 236 | 9.24M | | 237 | 9.24M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 9.24M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 9.24M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 9.24M | // from pass, once from AnalysisType). | 241 | 9.24M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 9.24M | } |
llvm::BranchProbabilityInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::BranchProbabilityInfoWrapperPass>(void const*) const Line | Count | Source | 226 | 2.04M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 2.04M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 2.04M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 2.04M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 2.04M | // should be a small number, we just do a linear search over a (dense) | 231 | 2.04M | // vector. | 232 | 2.04M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 2.04M | assert(ResultPass && | 234 | 2.04M | "getAnalysis*() called on an analysis that was not " | 235 | 2.04M | "'required' by pass!"); | 236 | 2.04M | | 237 | 2.04M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 2.04M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 2.04M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 2.04M | // from pass, once from AnalysisType). | 241 | 2.04M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 2.04M | } |
llvm::CallGraphWrapperPass& llvm::Pass::getAnalysisID<llvm::CallGraphWrapperPass>(void const*) const Line | Count | Source | 226 | 2.15M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 2.15M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 2.15M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 2.15M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 2.15M | // should be a small number, we just do a linear search over a (dense) | 231 | 2.15M | // vector. | 232 | 2.15M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 2.15M | assert(ResultPass && | 234 | 2.15M | "getAnalysis*() called on an analysis that was not " | 235 | 2.15M | "'required' by pass!"); | 236 | 2.15M | | 237 | 2.15M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 2.15M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 2.15M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 2.15M | // from pass, once from AnalysisType). | 241 | 2.15M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 2.15M | } |
llvm::LazyBranchProbabilityInfoPass& llvm::Pass::getAnalysisID<llvm::LazyBranchProbabilityInfoPass>(void const*) const Line | Count | Source | 226 | 5.87M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 5.87M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 5.87M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 5.87M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 5.87M | // should be a small number, we just do a linear search over a (dense) | 231 | 5.87M | // vector. | 232 | 5.87M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 5.87M | assert(ResultPass && | 234 | 5.87M | "getAnalysis*() called on an analysis that was not " | 235 | 5.87M | "'required' by pass!"); | 236 | 5.87M | | 237 | 5.87M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 5.87M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 5.87M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 5.87M | // from pass, once from AnalysisType). | 241 | 5.87M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 5.87M | } |
llvm::LazyValueInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::LazyValueInfoWrapperPass>(void const*) const Line | Count | Source | 226 | 1.83M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 1.83M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 1.83M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 1.83M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 1.83M | // should be a small number, we just do a linear search over a (dense) | 231 | 1.83M | // vector. | 232 | 1.83M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 1.83M | assert(ResultPass && | 234 | 1.83M | "getAnalysis*() called on an analysis that was not " | 235 | 1.83M | "'required' by pass!"); | 236 | 1.83M | | 237 | 1.83M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 1.83M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 1.83M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 1.83M | // from pass, once from AnalysisType). | 241 | 1.83M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 1.83M | } |
llvm::PhiValuesWrapperPass& llvm::Pass::getAnalysisID<llvm::PhiValuesWrapperPass>(void const*) const Line | Count | Source | 226 | 1.39M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 1.39M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 1.39M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 1.39M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 1.39M | // should be a small number, we just do a linear search over a (dense) | 231 | 1.39M | // vector. | 232 | 1.39M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 1.39M | assert(ResultPass && | 234 | 1.39M | "getAnalysis*() called on an analysis that was not " | 235 | 1.39M | "'required' by pass!"); | 236 | 1.39M | | 237 | 1.39M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 1.39M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 1.39M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 1.39M | // from pass, once from AnalysisType). | 241 | 1.39M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 1.39M | } |
llvm::MemorySSAWrapperPass& llvm::Pass::getAnalysisID<llvm::MemorySSAWrapperPass>(void const*) const Line | Count | Source | 226 | 714k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 714k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 714k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 714k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 714k | // should be a small number, we just do a linear search over a (dense) | 231 | 714k | // vector. | 232 | 714k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 714k | assert(ResultPass && | 234 | 714k | "getAnalysis*() called on an analysis that was not " | 235 | 714k | "'required' by pass!"); | 236 | 714k | | 237 | 714k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 714k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 714k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 714k | // from pass, once from AnalysisType). | 241 | 714k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 714k | } |
llvm::ProfileSummaryInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::ProfileSummaryInfoWrapperPass>(void const*) const Line | Count | Source | 226 | 1.30M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 1.30M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 1.30M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 1.30M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 1.30M | // should be a small number, we just do a linear search over a (dense) | 231 | 1.30M | // vector. | 232 | 1.30M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 1.30M | assert(ResultPass && | 234 | 1.30M | "getAnalysis*() called on an analysis that was not " | 235 | 1.30M | "'required' by pass!"); | 236 | 1.30M | | 237 | 1.30M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 1.30M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 1.30M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 1.30M | // from pass, once from AnalysisType). | 241 | 1.30M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 1.30M | } |
llvm::LazyBlockFrequencyInfoPass& llvm::Pass::getAnalysisID<llvm::LazyBlockFrequencyInfoPass>(void const*) const Line | Count | Source | 226 | 217 | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 217 | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 217 | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 217 | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 217 | // should be a small number, we just do a linear search over a (dense) | 231 | 217 | // vector. | 232 | 217 | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 217 | assert(ResultPass && | 234 | 217 | "getAnalysis*() called on an analysis that was not " | 235 | 217 | "'required' by pass!"); | 236 | 217 | | 237 | 217 | // Because the AnalysisType may not be a subclass of pass (for | 238 | 217 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 217 | // adjust the return pointer (because the class may multiply inherit, once | 240 | 217 | // from pass, once from AnalysisType). | 241 | 217 | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 217 | } |
llvm::DominanceFrontierWrapperPass& llvm::Pass::getAnalysisID<llvm::DominanceFrontierWrapperPass>(void const*) const Line | Count | Source | 226 | 24.6k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 24.6k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 24.6k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 24.6k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 24.6k | // should be a small number, we just do a linear search over a (dense) | 231 | 24.6k | // vector. | 232 | 24.6k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 24.6k | assert(ResultPass && | 234 | 24.6k | "getAnalysis*() called on an analysis that was not " | 235 | 24.6k | "'required' by pass!"); | 236 | 24.6k | | 237 | 24.6k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 24.6k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 24.6k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 24.6k | // from pass, once from AnalysisType). | 241 | 24.6k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 24.6k | } |
llvm::RegionInfoPass& llvm::Pass::getAnalysisID<llvm::RegionInfoPass>(void const*) const Line | Count | Source | 226 | 26.1k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 26.1k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 26.1k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 26.1k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 26.1k | // should be a small number, we just do a linear search over a (dense) | 231 | 26.1k | // vector. | 232 | 26.1k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 26.1k | assert(ResultPass && | 234 | 26.1k | "getAnalysis*() called on an analysis that was not " | 235 | 26.1k | "'required' by pass!"); | 236 | 26.1k | | 237 | 26.1k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 26.1k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 26.1k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 26.1k | // from pass, once from AnalysisType). | 241 | 26.1k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 26.1k | } |
llvm::ReachingDefAnalysis& llvm::Pass::getAnalysisID<llvm::ReachingDefAnalysis>(void const*) const Line | Count | Source | 226 | 268k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 268k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 268k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 268k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 268k | // should be a small number, we just do a linear search over a (dense) | 231 | 268k | // vector. | 232 | 268k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 268k | assert(ResultPass && | 234 | 268k | "getAnalysis*() called on an analysis that was not " | 235 | 268k | "'required' by pass!"); | 236 | 268k | | 237 | 268k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 268k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 268k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 268k | // from pass, once from AnalysisType). | 241 | 268k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 268k | } |
llvm::GCModuleInfo& llvm::Pass::getAnalysisID<llvm::GCModuleInfo>(void const*) const Line | Count | Source | 226 | 240 | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 240 | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 240 | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 240 | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 240 | // should be a small number, we just do a linear search over a (dense) | 231 | 240 | // vector. | 232 | 240 | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 240 | assert(ResultPass && | 234 | 240 | "getAnalysis*() called on an analysis that was not " | 235 | 240 | "'required' by pass!"); | 236 | 240 | | 237 | 240 | // Because the AnalysisType may not be a subclass of pass (for | 238 | 240 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 240 | // adjust the return pointer (because the class may multiply inherit, once | 240 | 240 | // from pass, once from AnalysisType). | 241 | 240 | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 240 | } |
llvm::LiveStacks& llvm::Pass::getAnalysisID<llvm::LiveStacks>(void const*) const Line | Count | Source | 226 | 1.38M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 1.38M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 1.38M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 1.38M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 1.38M | // should be a small number, we just do a linear search over a (dense) | 231 | 1.38M | // vector. | 232 | 1.38M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 1.38M | assert(ResultPass && | 234 | 1.38M | "getAnalysis*() called on an analysis that was not " | 235 | 1.38M | "'required' by pass!"); | 236 | 1.38M | | 237 | 1.38M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 1.38M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 1.38M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 1.38M | // from pass, once from AnalysisType). | 241 | 1.38M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 1.38M | } |
llvm::SlotIndexes& llvm::Pass::getAnalysisID<llvm::SlotIndexes>(void const*) const Line | Count | Source | 226 | 1.89M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 1.89M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 1.89M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 1.89M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 1.89M | // should be a small number, we just do a linear search over a (dense) | 231 | 1.89M | // vector. | 232 | 1.89M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 1.89M | assert(ResultPass && | 234 | 1.89M | "getAnalysis*() called on an analysis that was not " | 235 | 1.89M | "'required' by pass!"); | 236 | 1.89M | | 237 | 1.89M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 1.89M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 1.89M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 1.89M | // from pass, once from AnalysisType). | 241 | 1.89M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 1.89M | } |
llvm::VirtRegMap& llvm::Pass::getAnalysisID<llvm::VirtRegMap>(void const*) const Line | Count | Source | 226 | 1.38M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 1.38M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 1.38M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 1.38M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 1.38M | // should be a small number, we just do a linear search over a (dense) | 231 | 1.38M | // vector. | 232 | 1.38M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 1.38M | assert(ResultPass && | 234 | 1.38M | "getAnalysis*() called on an analysis that was not " | 235 | 1.38M | "'required' by pass!"); | 236 | 1.38M | | 237 | 1.38M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 1.38M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 1.38M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 1.38M | // from pass, once from AnalysisType). | 241 | 1.38M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 1.38M | } |
llvm::LazyMachineBlockFrequencyInfoPass& llvm::Pass::getAnalysisID<llvm::LazyMachineBlockFrequencyInfoPass>(void const*) const Line | Count | Source | 226 | 60 | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 60 | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 60 | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 60 | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 60 | // should be a small number, we just do a linear search over a (dense) | 231 | 60 | // vector. | 232 | 60 | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 60 | assert(ResultPass && | 234 | 60 | "getAnalysis*() called on an analysis that was not " | 235 | 60 | "'required' by pass!"); | 236 | 60 | | 237 | 60 | // Because the AnalysisType may not be a subclass of pass (for | 238 | 60 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 60 | // adjust the return pointer (because the class may multiply inherit, once | 240 | 60 | // from pass, once from AnalysisType). | 241 | 60 | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 60 | } |
llvm::MachineOptimizationRemarkEmitterPass& llvm::Pass::getAnalysisID<llvm::MachineOptimizationRemarkEmitterPass>(void const*) const Line | Count | Source | 226 | 1.76M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 1.76M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 1.76M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 1.76M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 1.76M | // should be a small number, we just do a linear search over a (dense) | 231 | 1.76M | // vector. | 232 | 1.76M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 1.76M | assert(ResultPass && | 234 | 1.76M | "getAnalysis*() called on an analysis that was not " | 235 | 1.76M | "'required' by pass!"); | 236 | 1.76M | | 237 | 1.76M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 1.76M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 1.76M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 1.76M | // from pass, once from AnalysisType). | 241 | 1.76M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 1.76M | } |
llvm::LiveRegMatrix& llvm::Pass::getAnalysisID<llvm::LiveRegMatrix>(void const*) const Line | Count | Source | 226 | 462k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 462k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 462k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 462k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 462k | // should be a small number, we just do a linear search over a (dense) | 231 | 462k | // vector. | 232 | 462k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 462k | assert(ResultPass && | 234 | 462k | "getAnalysis*() called on an analysis that was not " | 235 | 462k | "'required' by pass!"); | 236 | 462k | | 237 | 462k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 462k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 462k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 462k | // from pass, once from AnalysisType). | 241 | 462k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 462k | } |
llvm::SpillPlacement& llvm::Pass::getAnalysisID<llvm::SpillPlacement>(void const*) const Line | Count | Source | 226 | 462k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 462k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 462k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 462k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 462k | // should be a small number, we just do a linear search over a (dense) | 231 | 462k | // vector. | 232 | 462k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 462k | assert(ResultPass && | 234 | 462k | "getAnalysis*() called on an analysis that was not " | 235 | 462k | "'required' by pass!"); | 236 | 462k | | 237 | 462k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 462k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 462k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 462k | // from pass, once from AnalysisType). | 241 | 462k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 462k | } |
llvm::LiveDebugVariables& llvm::Pass::getAnalysisID<llvm::LiveDebugVariables>(void const*) const Line | Count | Source | 226 | 924k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 924k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 924k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 924k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 924k | // should be a small number, we just do a linear search over a (dense) | 231 | 924k | // vector. | 232 | 924k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 924k | assert(ResultPass && | 234 | 924k | "getAnalysis*() called on an analysis that was not " | 235 | 924k | "'required' by pass!"); | 236 | 924k | | 237 | 924k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 924k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 924k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 924k | // from pass, once from AnalysisType). | 241 | 924k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 924k | } |
llvm::PhysicalRegisterUsageInfo& llvm::Pass::getAnalysisID<llvm::PhysicalRegisterUsageInfo>(void const*) const Line | Count | Source | 226 | 41.9k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 41.9k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 41.9k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 41.9k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 41.9k | // should be a small number, we just do a linear search over a (dense) | 231 | 41.9k | // vector. | 232 | 41.9k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 41.9k | assert(ResultPass && | 234 | 41.9k | "getAnalysis*() called on an analysis that was not " | 235 | 41.9k | "'required' by pass!"); | 236 | 41.9k | | 237 | 41.9k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 41.9k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 41.9k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 41.9k | // from pass, once from AnalysisType). | 241 | 41.9k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 41.9k | } |
llvm::ModuleSummaryIndexWrapperPass& llvm::Pass::getAnalysisID<llvm::ModuleSummaryIndexWrapperPass>(void const*) const Line | Count | Source | 226 | 354 | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 354 | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 354 | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 354 | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 354 | // should be a small number, we just do a linear search over a (dense) | 231 | 354 | // vector. | 232 | 354 | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 354 | assert(ResultPass && | 234 | 354 | "getAnalysis*() called on an analysis that was not " | 235 | 354 | "'required' by pass!"); | 236 | 354 | | 237 | 354 | // Because the AnalysisType may not be a subclass of pass (for | 238 | 354 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 354 | // adjust the return pointer (because the class may multiply inherit, once | 240 | 354 | // from pass, once from AnalysisType). | 241 | 354 | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 354 | } |
llvm::OptimizationRemarkEmitterWrapperPass& llvm::Pass::getAnalysisID<llvm::OptimizationRemarkEmitterWrapperPass>(void const*) const Line | Count | Source | 226 | 6.15M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 6.15M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 6.15M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 6.15M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 6.15M | // should be a small number, we just do a linear search over a (dense) | 231 | 6.15M | // vector. | 232 | 6.15M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 6.15M | assert(ResultPass && | 234 | 6.15M | "getAnalysis*() called on an analysis that was not " | 235 | 6.15M | "'required' by pass!"); | 236 | 6.15M | | 237 | 6.15M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 6.15M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 6.15M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 6.15M | // from pass, once from AnalysisType). | 241 | 6.15M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 6.15M | } |
AddressSanitizer.cpp:(anonymous namespace)::ASanGlobalsMetadataWrapperPass& llvm::Pass::getAnalysisID<(anonymous namespace)::ASanGlobalsMetadataWrapperPass>(void const*) const Line | Count | Source | 226 | 947 | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 947 | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 947 | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 947 | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 947 | // should be a small number, we just do a linear search over a (dense) | 231 | 947 | // vector. | 232 | 947 | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 947 | assert(ResultPass && | 234 | 947 | "getAnalysis*() called on an analysis that was not " | 235 | 947 | "'required' by pass!"); | 236 | 947 | | 237 | 947 | // Because the AnalysisType may not be a subclass of pass (for | 238 | 947 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 947 | // adjust the return pointer (because the class may multiply inherit, once | 240 | 947 | // from pass, once from AnalysisType). | 241 | 947 | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 947 | } |
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::BlockFrequencyInfoWrapperPass>(void const*) const Line | Count | Source | 226 | 1.38M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 1.38M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 1.38M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 1.38M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 1.38M | // should be a small number, we just do a linear search over a (dense) | 231 | 1.38M | // vector. | 232 | 1.38M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 1.38M | assert(ResultPass && | 234 | 1.38M | "getAnalysis*() called on an analysis that was not " | 235 | 1.38M | "'required' by pass!"); | 236 | 1.38M | | 237 | 1.38M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 1.38M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 1.38M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 1.38M | // from pass, once from AnalysisType). | 241 | 1.38M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 1.38M | } |
llvm::DemandedBitsWrapperPass& llvm::Pass::getAnalysisID<llvm::DemandedBitsWrapperPass>(void const*) const Line | Count | Source | 226 | 1.01M | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 1.01M | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 1.01M | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 1.01M | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 1.01M | // should be a small number, we just do a linear search over a (dense) | 231 | 1.01M | // vector. | 232 | 1.01M | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 1.01M | assert(ResultPass && | 234 | 1.01M | "getAnalysis*() called on an analysis that was not " | 235 | 1.01M | "'required' by pass!"); | 236 | 1.01M | | 237 | 1.01M | // Because the AnalysisType may not be a subclass of pass (for | 238 | 1.01M | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 1.01M | // adjust the return pointer (because the class may multiply inherit, once | 240 | 1.01M | // from pass, once from AnalysisType). | 241 | 1.01M | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 1.01M | } |
llvm::LoopAccessLegacyAnalysis& llvm::Pass::getAnalysisID<llvm::LoopAccessLegacyAnalysis>(void const*) const Line | Count | Source | 226 | 832k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 832k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 832k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 832k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 832k | // should be a small number, we just do a linear search over a (dense) | 231 | 832k | // vector. | 232 | 832k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 832k | assert(ResultPass && | 234 | 832k | "getAnalysis*() called on an analysis that was not " | 235 | 832k | "'required' by pass!"); | 236 | 832k | | 237 | 832k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 832k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 832k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 832k | // from pass, once from AnalysisType). | 241 | 832k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 832k | } |
llvm::DependenceAnalysisWrapperPass& llvm::Pass::getAnalysisID<llvm::DependenceAnalysisWrapperPass>(void const*) const Line | Count | Source | 226 | 156 | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 156 | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 156 | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 156 | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 156 | // should be a small number, we just do a linear search over a (dense) | 231 | 156 | // vector. | 232 | 156 | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 156 | assert(ResultPass && | 234 | 156 | "getAnalysis*() called on an analysis that was not " | 235 | 156 | "'required' by pass!"); | 236 | 156 | | 237 | 156 | // Because the AnalysisType may not be a subclass of pass (for | 238 | 156 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 156 | // adjust the return pointer (because the class may multiply inherit, once | 240 | 156 | // from pass, once from AnalysisType). | 241 | 156 | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 156 | } |
llvm::IVUsersWrapperPass& llvm::Pass::getAnalysisID<llvm::IVUsersWrapperPass>(void const*) const Line | Count | Source | 226 | 206k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 206k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 206k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 206k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 206k | // should be a small number, we just do a linear search over a (dense) | 231 | 206k | // vector. | 232 | 206k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 206k | assert(ResultPass && | 234 | 206k | "getAnalysis*() called on an analysis that was not " | 235 | 206k | "'required' by pass!"); | 236 | 206k | | 237 | 206k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 206k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 206k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 206k | // from pass, once from AnalysisType). | 241 | 206k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 206k | } |
polly::ScopInfoWrapperPass& llvm::Pass::getAnalysisID<polly::ScopInfoWrapperPass>(void const*) const Line | Count | Source | 226 | 45 | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 45 | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 45 | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 45 | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 45 | // should be a small number, we just do a linear search over a (dense) | 231 | 45 | // vector. | 232 | 45 | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 45 | assert(ResultPass && | 234 | 45 | "getAnalysis*() called on an analysis that was not " | 235 | 45 | "'required' by pass!"); | 236 | 45 | | 237 | 45 | // Because the AnalysisType may not be a subclass of pass (for | 238 | 45 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 45 | // adjust the return pointer (because the class may multiply inherit, once | 240 | 45 | // from pass, once from AnalysisType). | 241 | 45 | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 45 | } |
polly::DependenceInfoWrapperPass& llvm::Pass::getAnalysisID<polly::DependenceInfoWrapperPass>(void const*) const Line | Count | Source | 226 | 19 | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 19 | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 19 | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 19 | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 19 | // should be a small number, we just do a linear search over a (dense) | 231 | 19 | // vector. | 232 | 19 | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 19 | assert(ResultPass && | 234 | 19 | "getAnalysis*() called on an analysis that was not " | 235 | 19 | "'required' by pass!"); | 236 | 19 | | 237 | 19 | // Because the AnalysisType may not be a subclass of pass (for | 238 | 19 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 19 | // adjust the return pointer (because the class may multiply inherit, once | 240 | 19 | // from pass, once from AnalysisType). | 241 | 19 | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 19 | } |
polly::ScopDetectionWrapperPass& llvm::Pass::getAnalysisID<polly::ScopDetectionWrapperPass>(void const*) const Line | Count | Source | 226 | 4.25k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 4.25k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 4.25k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 4.25k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 4.25k | // should be a small number, we just do a linear search over a (dense) | 231 | 4.25k | // vector. | 232 | 4.25k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 4.25k | assert(ResultPass && | 234 | 4.25k | "getAnalysis*() called on an analysis that was not " | 235 | 4.25k | "'required' by pass!"); | 236 | 4.25k | | 237 | 4.25k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 4.25k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 4.25k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 4.25k | // from pass, once from AnalysisType). | 241 | 4.25k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 4.25k | } |
polly::ScopInfoRegionPass& llvm::Pass::getAnalysisID<polly::ScopInfoRegionPass>(void const*) const Line | Count | Source | 226 | 6.56k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 6.56k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 6.56k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 6.56k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 6.56k | // should be a small number, we just do a linear search over a (dense) | 231 | 6.56k | // vector. | 232 | 6.56k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 6.56k | assert(ResultPass && | 234 | 6.56k | "getAnalysis*() called on an analysis that was not " | 235 | 6.56k | "'required' by pass!"); | 236 | 6.56k | | 237 | 6.56k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 6.56k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 6.56k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 6.56k | // from pass, once from AnalysisType). | 241 | 6.56k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 6.56k | } |
polly::DependenceInfo& llvm::Pass::getAnalysisID<polly::DependenceInfo>(void const*) const Line | Count | Source | 226 | 609 | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 609 | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 609 | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 609 | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 609 | // should be a small number, we just do a linear search over a (dense) | 231 | 609 | // vector. | 232 | 609 | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 609 | assert(ResultPass && | 234 | 609 | "getAnalysis*() called on an analysis that was not " | 235 | 609 | "'required' by pass!"); | 236 | 609 | | 237 | 609 | // Because the AnalysisType may not be a subclass of pass (for | 238 | 609 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 609 | // adjust the return pointer (because the class may multiply inherit, once | 240 | 609 | // from pass, once from AnalysisType). | 241 | 609 | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 609 | } |
polly::IslAstInfoWrapperPass& llvm::Pass::getAnalysisID<polly::IslAstInfoWrapperPass>(void const*) const Line | Count | Source | 226 | 294 | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 294 | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 294 | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 294 | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 294 | // should be a small number, we just do a linear search over a (dense) | 231 | 294 | // vector. | 232 | 294 | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 294 | assert(ResultPass && | 234 | 294 | "getAnalysis*() called on an analysis that was not " | 235 | 294 | "'required' by pass!"); | 236 | 294 | | 237 | 294 | // Because the AnalysisType may not be a subclass of pass (for | 238 | 294 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 294 | // adjust the return pointer (because the class may multiply inherit, once | 240 | 294 | // from pass, once from AnalysisType). | 241 | 294 | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 294 | } |
llvm::GISelCSEAnalysisWrapperPass& llvm::Pass::getAnalysisID<llvm::GISelCSEAnalysisWrapperPass>(void const*) const Line | Count | Source | 226 | 473k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 473k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 473k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 473k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 473k | // should be a small number, we just do a linear search over a (dense) | 231 | 473k | // vector. | 232 | 473k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 473k | assert(ResultPass && | 234 | 473k | "getAnalysis*() called on an analysis that was not " | 235 | 473k | "'required' by pass!"); | 236 | 473k | | 237 | 473k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 473k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 473k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 473k | // from pass, once from AnalysisType). | 241 | 473k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 473k | } |
llvm::StackProtector& llvm::Pass::getAnalysisID<llvm::StackProtector>(void const*) const Line | Count | Source | 226 | 494k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 494k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 494k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 494k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 494k | // should be a small number, we just do a linear search over a (dense) | 231 | 494k | // vector. | 232 | 494k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 494k | assert(ResultPass && | 234 | 494k | "getAnalysis*() called on an analysis that was not " | 235 | 494k | "'required' by pass!"); | 236 | 494k | | 237 | 494k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 494k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 494k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 494k | // from pass, once from AnalysisType). | 241 | 494k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 494k | } |
llvm::Pass& llvm::Pass::getAnalysisID<llvm::Pass>(void const*) const Line | Count | Source | 226 | 14.9k | AnalysisType &Pass::getAnalysisID(AnalysisID PI) const { | 227 | 14.9k | assert(PI && "getAnalysis for unregistered pass!"); | 228 | 14.9k | assert(Resolver&&"Pass has not been inserted into a PassManager object!"); | 229 | 14.9k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 230 | 14.9k | // should be a small number, we just do a linear search over a (dense) | 231 | 14.9k | // vector. | 232 | 14.9k | Pass *ResultPass = Resolver->findImplPass(PI); | 233 | 14.9k | assert(ResultPass && | 234 | 14.9k | "getAnalysis*() called on an analysis that was not " | 235 | 14.9k | "'required' by pass!"); | 236 | 14.9k | | 237 | 14.9k | // Because the AnalysisType may not be a subclass of pass (for | 238 | 14.9k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 239 | 14.9k | // adjust the return pointer (because the class may multiply inherit, once | 240 | 14.9k | // from pass, once from AnalysisType). | 241 | 14.9k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 242 | 14.9k | } |
|
243 | | |
244 | | /// getAnalysis<AnalysisType>() - This function is used by subclasses to get |
245 | | /// to the analysis information that they claim to use by overriding the |
246 | | /// getAnalysisUsage function. |
247 | | template<typename AnalysisType> |
248 | 625k | AnalysisType &Pass::getAnalysis(Function &F) { |
249 | 625k | assert(Resolver &&"Pass has not been inserted into a PassManager object!"); |
250 | 625k | |
251 | 625k | return getAnalysisID<AnalysisType>(&AnalysisType::ID, F); |
252 | 625k | } llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysis<llvm::DominatorTreeWrapperPass>(llvm::Function&) Line | Count | Source | 248 | 588k | AnalysisType &Pass::getAnalysis(Function &F) { | 249 | 588k | assert(Resolver &&"Pass has not been inserted into a PassManager object!"); | 250 | 588k | | 251 | 588k | return getAnalysisID<AnalysisType>(&AnalysisType::ID, F); | 252 | 588k | } |
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysis<llvm::BlockFrequencyInfoWrapperPass>(llvm::Function&) Line | Count | Source | 248 | 37.2k | AnalysisType &Pass::getAnalysis(Function &F) { | 249 | 37.2k | assert(Resolver &&"Pass has not been inserted into a PassManager object!"); | 250 | 37.2k | | 251 | 37.2k | return getAnalysisID<AnalysisType>(&AnalysisType::ID, F); | 252 | 37.2k | } |
llvm::StackSafetyInfoWrapperPass& llvm::Pass::getAnalysis<llvm::StackSafetyInfoWrapperPass>(llvm::Function&) Line | Count | Source | 248 | 78 | AnalysisType &Pass::getAnalysis(Function &F) { | 249 | 78 | assert(Resolver &&"Pass has not been inserted into a PassManager object!"); | 250 | 78 | | 251 | 78 | return getAnalysisID<AnalysisType>(&AnalysisType::ID, F); | 252 | 78 | } |
llvm::BranchProbabilityInfoWrapperPass& llvm::Pass::getAnalysis<llvm::BranchProbabilityInfoWrapperPass>(llvm::Function&) Line | Count | Source | 248 | 80 | AnalysisType &Pass::getAnalysis(Function &F) { | 249 | 80 | assert(Resolver &&"Pass has not been inserted into a PassManager object!"); | 250 | 80 | | 251 | 80 | return getAnalysisID<AnalysisType>(&AnalysisType::ID, F); | 252 | 80 | } |
llvm::PostDominatorTreeWrapperPass& llvm::Pass::getAnalysis<llvm::PostDominatorTreeWrapperPass>(llvm::Function&) Line | Count | Source | 248 | 64 | AnalysisType &Pass::getAnalysis(Function &F) { | 249 | 64 | assert(Resolver &&"Pass has not been inserted into a PassManager object!"); | 250 | 64 | | 251 | 64 | return getAnalysisID<AnalysisType>(&AnalysisType::ID, F); | 252 | 64 | } |
|
253 | | |
254 | | template<typename AnalysisType> |
255 | 625k | AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) { |
256 | 625k | assert(PI && "getAnalysis for unregistered pass!"); |
257 | 625k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); |
258 | 625k | // PI *must* appear in AnalysisImpls. Because the number of passes used |
259 | 625k | // should be a small number, we just do a linear search over a (dense) |
260 | 625k | // vector. |
261 | 625k | Pass *ResultPass = Resolver->findImplPass(this, PI, F); |
262 | 625k | assert(ResultPass && "Unable to find requested analysis info"); |
263 | 625k | |
264 | 625k | // Because the AnalysisType may not be a subclass of pass (for |
265 | 625k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially |
266 | 625k | // adjust the return pointer (because the class may multiply inherit, once |
267 | 625k | // from pass, once from AnalysisType). |
268 | 625k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); |
269 | 625k | } llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysisID<llvm::DominatorTreeWrapperPass>(void const*, llvm::Function&) Line | Count | Source | 255 | 588k | AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) { | 256 | 588k | assert(PI && "getAnalysis for unregistered pass!"); | 257 | 588k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 258 | 588k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 259 | 588k | // should be a small number, we just do a linear search over a (dense) | 260 | 588k | // vector. | 261 | 588k | Pass *ResultPass = Resolver->findImplPass(this, PI, F); | 262 | 588k | assert(ResultPass && "Unable to find requested analysis info"); | 263 | 588k | | 264 | 588k | // Because the AnalysisType may not be a subclass of pass (for | 265 | 588k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 266 | 588k | // adjust the return pointer (because the class may multiply inherit, once | 267 | 588k | // from pass, once from AnalysisType). | 268 | 588k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 269 | 588k | } |
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::BlockFrequencyInfoWrapperPass>(void const*, llvm::Function&) Line | Count | Source | 255 | 37.2k | AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) { | 256 | 37.2k | assert(PI && "getAnalysis for unregistered pass!"); | 257 | 37.2k | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 258 | 37.2k | // PI *must* appear in AnalysisImpls. Because the number of passes used | 259 | 37.2k | // should be a small number, we just do a linear search over a (dense) | 260 | 37.2k | // vector. | 261 | 37.2k | Pass *ResultPass = Resolver->findImplPass(this, PI, F); | 262 | 37.2k | assert(ResultPass && "Unable to find requested analysis info"); | 263 | 37.2k | | 264 | 37.2k | // Because the AnalysisType may not be a subclass of pass (for | 265 | 37.2k | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 266 | 37.2k | // adjust the return pointer (because the class may multiply inherit, once | 267 | 37.2k | // from pass, once from AnalysisType). | 268 | 37.2k | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 269 | 37.2k | } |
llvm::StackSafetyInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::StackSafetyInfoWrapperPass>(void const*, llvm::Function&) Line | Count | Source | 255 | 78 | AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) { | 256 | 78 | assert(PI && "getAnalysis for unregistered pass!"); | 257 | 78 | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 258 | 78 | // PI *must* appear in AnalysisImpls. Because the number of passes used | 259 | 78 | // should be a small number, we just do a linear search over a (dense) | 260 | 78 | // vector. | 261 | 78 | Pass *ResultPass = Resolver->findImplPass(this, PI, F); | 262 | 78 | assert(ResultPass && "Unable to find requested analysis info"); | 263 | 78 | | 264 | 78 | // Because the AnalysisType may not be a subclass of pass (for | 265 | 78 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 266 | 78 | // adjust the return pointer (because the class may multiply inherit, once | 267 | 78 | // from pass, once from AnalysisType). | 268 | 78 | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 269 | 78 | } |
llvm::BranchProbabilityInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::BranchProbabilityInfoWrapperPass>(void const*, llvm::Function&) Line | Count | Source | 255 | 80 | AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) { | 256 | 80 | assert(PI && "getAnalysis for unregistered pass!"); | 257 | 80 | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 258 | 80 | // PI *must* appear in AnalysisImpls. Because the number of passes used | 259 | 80 | // should be a small number, we just do a linear search over a (dense) | 260 | 80 | // vector. | 261 | 80 | Pass *ResultPass = Resolver->findImplPass(this, PI, F); | 262 | 80 | assert(ResultPass && "Unable to find requested analysis info"); | 263 | 80 | | 264 | 80 | // Because the AnalysisType may not be a subclass of pass (for | 265 | 80 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 266 | 80 | // adjust the return pointer (because the class may multiply inherit, once | 267 | 80 | // from pass, once from AnalysisType). | 268 | 80 | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 269 | 80 | } |
llvm::PostDominatorTreeWrapperPass& llvm::Pass::getAnalysisID<llvm::PostDominatorTreeWrapperPass>(void const*, llvm::Function&) Line | Count | Source | 255 | 64 | AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) { | 256 | 64 | assert(PI && "getAnalysis for unregistered pass!"); | 257 | 64 | assert(Resolver && "Pass has not been inserted into a PassManager object!"); | 258 | 64 | // PI *must* appear in AnalysisImpls. Because the number of passes used | 259 | 64 | // should be a small number, we just do a linear search over a (dense) | 260 | 64 | // vector. | 261 | 64 | Pass *ResultPass = Resolver->findImplPass(this, PI, F); | 262 | 64 | assert(ResultPass && "Unable to find requested analysis info"); | 263 | 64 | | 264 | 64 | // Because the AnalysisType may not be a subclass of pass (for | 265 | 64 | // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially | 266 | 64 | // adjust the return pointer (because the class may multiply inherit, once | 267 | 64 | // from pass, once from AnalysisType). | 268 | 64 | return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI); | 269 | 64 | } |
|
270 | | |
271 | | } // end namespace llvm |
272 | | |
273 | | #endif // LLVM_PASSANALYSISSUPPORT_H |