Coverage Report

Created: 2018-11-16 02:38

/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
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
//
10
// This file defines stuff that is used to define and "use" Analysis Passes.
11
// This file is automatically #included by Pass.h, so:
12
//
13
//           NO .CPP FILES SHOULD INCLUDE THIS FILE DIRECTLY
14
//
15
// Instead, #include Pass.h
16
//
17
//===----------------------------------------------------------------------===//
18
19
#ifndef LLVM_PASSANALYSISSUPPORT_H
20
#define LLVM_PASSANALYSISSUPPORT_H
21
22
#include "Pass.h"
23
#include "llvm/ADT/SmallVector.h"
24
#include "llvm/ADT/StringRef.h"
25
#include <cassert>
26
#include <utility>
27
#include <vector>
28
29
namespace llvm {
30
31
class Function;
32
class Pass;
33
class PMDataManager;
34
35
//===----------------------------------------------------------------------===//
36
/// Represent the analysis usage information of a pass.  This tracks analyses
37
/// that the pass REQUIRES (must be available when the pass runs), REQUIRES
38
/// TRANSITIVE (must be available throughout the lifetime of the pass), and
39
/// analyses that the pass PRESERVES (the pass does not invalidate the results
40
/// of these analyses).  This information is provided by a pass to the Pass
41
/// infrastructure through the getAnalysisUsage virtual function.
42
///
43
class AnalysisUsage {
44
public:
45
  using VectorType = SmallVectorImpl<AnalysisID>;
46
47
private:
48
  /// Sets of analyses required and preserved by a pass
49
  // TODO: It's not clear that SmallVector is an appropriate data structure for
50
  // this usecase.  The sizes were picked to minimize wasted space, but are
51
  // otherwise fairly meaningless.
52
  SmallVector<AnalysisID, 8> Required;
53
  SmallVector<AnalysisID, 2> RequiredTransitive;
54
  SmallVector<AnalysisID, 2> Preserved;
55
  SmallVector<AnalysisID, 0> Used;
56
  bool PreservesAll = false;
57
58
public:
59
9.50M
  AnalysisUsage() = default;
60
61
  ///@{
62
  /// Add the specified ID to the required set of the usage info for a pass.
63
  AnalysisUsage &addRequiredID(const void *ID);
64
  AnalysisUsage &addRequiredID(char &ID);
65
  template<class PassClass>
66
18.8M
  AnalysisUsage &addRequired() {
67
18.8M
    return addRequiredID(PassClass::ID);
68
18.8M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineDominatorTree>()
Line
Count
Source
66
470k
  AnalysisUsage &addRequired() {
67
470k
    return addRequiredID(PassClass::ID);
68
470k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ReachingDefAnalysis>()
Line
Count
Source
66
31.1k
  AnalysisUsage &addRequired() {
67
31.1k
    return addRequiredID(PassClass::ID);
68
31.1k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineBranchProbabilityInfo>()
Line
Count
Source
66
477k
  AnalysisUsage &addRequired() {
67
477k
    return addRequiredID(PassClass::ID);
68
477k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineLoopInfo>()
Line
Count
Source
66
574k
  AnalysisUsage &addRequired() {
67
574k
    return addRequiredID(PassClass::ID);
68
574k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineTraceMetrics>()
Line
Count
Source
66
59.0k
  AnalysisUsage &addRequired() {
67
59.0k
    return addRequiredID(PassClass::ID);
68
59.0k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::TargetPassConfig>()
Line
Count
Source
66
281k
  AnalysisUsage &addRequired() {
67
281k
    return addRequiredID(PassClass::ID);
68
281k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LoopInfoWrapperPass>()
Line
Count
Source
66
2.02M
  AnalysisUsage &addRequired() {
67
2.02M
    return addRequiredID(PassClass::ID);
68
2.02M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ScalarEvolutionWrapperPass>()
Line
Count
Source
66
369k
  AnalysisUsage &addRequired() {
67
369k
    return addRequiredID(PassClass::ID);
68
369k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AAResultsWrapperPass>()
Line
Count
Source
66
833k
  AnalysisUsage &addRequired() {
67
833k
    return addRequiredID(PassClass::ID);
68
833k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DominatorTreeWrapperPass>()
Line
Count
Source
66
2.53M
  AnalysisUsage &addRequired() {
67
2.53M
    return addRequiredID(PassClass::ID);
68
2.53M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LegacyDivergenceAnalysis>()
Line
Count
Source
66
12.3k
  AnalysisUsage &addRequired() {
67
12.3k
    return addRequiredID(PassClass::ID);
68
12.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MemoryDependenceWrapperPass>()
Line
Count
Source
66
42.4k
  AnalysisUsage &addRequired() {
67
42.4k
    return addRequiredID(PassClass::ID);
68
42.4k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AssumptionCacheTracker>()
Line
Count
Source
66
1.21M
  AnalysisUsage &addRequired() {
67
1.21M
    return addRequiredID(PassClass::ID);
68
1.21M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AMDGPUArgumentUsageInfo>()
Line
Count
Source
66
2.27k
  AnalysisUsage &addRequired() {
67
2.27k
    return addRequiredID(PassClass::ID);
68
2.27k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AMDGPUPerfHintAnalysis>()
Line
Count
Source
66
2.27k
  AnalysisUsage &addRequired() {
67
2.27k
    return addRequiredID(PassClass::ID);
68
2.27k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::TargetTransformInfoWrapperPass>()
Line
Count
Source
66
751k
  AnalysisUsage &addRequired() {
67
751k
    return addRequiredID(PassClass::ID);
68
751k
  }
Unexecuted instantiation: llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineRegionInfoPass>()
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::PostDominatorTreeWrapperPass>()
Line
Count
Source
66
29.9k
  AnalysisUsage &addRequired() {
67
29.9k
    return addRequiredID(PassClass::ID);
68
29.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachinePostDominatorTree>()
Line
Count
Source
66
97.6k
  AnalysisUsage &addRequired() {
67
97.6k
    return addRequiredID(PassClass::ID);
68
97.6k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveIntervals>()
Line
Count
Source
66
170k
  AnalysisUsage &addRequired() {
67
170k
    return addRequiredID(PassClass::ID);
68
170k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::TargetLibraryInfoWrapperPass>()
Line
Count
Source
66
2.18M
  AnalysisUsage &addRequired() {
67
2.18M
    return addRequiredID(PassClass::ID);
68
2.18M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineDominanceFrontier>()
Line
Count
Source
66
2.00k
  AnalysisUsage &addRequired() {
67
2.00k
    return addRequiredID(PassClass::ID);
68
2.00k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::SlotIndexes>()
Line
Count
Source
66
192k
  AnalysisUsage &addRequired() {
67
192k
    return addRequiredID(PassClass::ID);
68
192k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::WebAssemblyExceptionInfo>()
Line
Count
Source
66
641
  AnalysisUsage &addRequired() {
67
641
    return addRequiredID(PassClass::ID);
68
641
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineBlockFrequencyInfo>()
Line
Count
Source
66
230k
  AnalysisUsage &addRequired() {
67
230k
    return addRequiredID(PassClass::ID);
68
230k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::EdgeBundles>()
Line
Count
Source
66
43.1k
  AnalysisUsage &addRequired() {
67
43.1k
    return addRequiredID(PassClass::ID);
68
43.1k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineModuleInfo>()
Line
Count
Source
66
3.45M
  AnalysisUsage &addRequired() {
67
3.45M
    return addRequiredID(PassClass::ID);
68
3.45M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::BasicAAWrapperPass>()
Line
Count
Source
66
348k
  AnalysisUsage &addRequired() {
67
348k
    return addRequiredID(PassClass::ID);
68
348k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::BranchProbabilityInfoWrapperPass>()
Line
Count
Source
66
144k
  AnalysisUsage &addRequired() {
67
144k
    return addRequiredID(PassClass::ID);
68
144k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::CallGraphWrapperPass>()
Line
Count
Source
66
132k
  AnalysisUsage &addRequired() {
67
132k
    return addRequiredID(PassClass::ID);
68
132k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyBranchProbabilityInfoPass>()
Line
Count
Source
66
403k
  AnalysisUsage &addRequired() {
67
403k
    return addRequiredID(PassClass::ID);
68
403k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyBlockFrequencyInfoPass>()
Line
Count
Source
66
209k
  AnalysisUsage &addRequired() {
67
209k
    return addRequiredID(PassClass::ID);
68
209k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyValueInfoWrapperPass>()
Line
Count
Source
66
52.9k
  AnalysisUsage &addRequired() {
67
52.9k
    return addRequiredID(PassClass::ID);
68
52.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::PhiValuesWrapperPass>()
Line
Count
Source
66
42.0k
  AnalysisUsage &addRequired() {
67
42.0k
    return addRequiredID(PassClass::ID);
68
42.0k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MemorySSAWrapperPass>()
Line
Count
Source
66
13.3k
  AnalysisUsage &addRequired() {
67
13.3k
    return addRequiredID(PassClass::ID);
68
13.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::BlockFrequencyInfoWrapperPass>()
Line
Count
Source
66
98.0k
  AnalysisUsage &addRequired() {
67
98.0k
    return addRequiredID(PassClass::ID);
68
98.0k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ProfileSummaryInfoWrapperPass>()
Line
Count
Source
66
57.3k
  AnalysisUsage &addRequired() {
67
57.3k
    return addRequiredID(PassClass::ID);
68
57.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DominanceFrontierWrapperPass>()
Line
Count
Source
66
3.58k
  AnalysisUsage &addRequired() {
67
3.58k
    return addRequiredID(PassClass::ID);
68
3.58k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::RegionInfoPass>()
Line
Count
Source
66
4.90k
  AnalysisUsage &addRequired() {
67
4.90k
    return addRequiredID(PassClass::ID);
68
4.90k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::GCModuleInfo>()
Line
Count
Source
66
133k
  AnalysisUsage &addRequired() {
67
133k
    return addRequiredID(PassClass::ID);
68
133k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyMachineBlockFrequencyInfoPass>()
Line
Count
Source
66
98.4k
  AnalysisUsage &addRequired() {
67
98.4k
    return addRequiredID(PassClass::ID);
68
98.4k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineOptimizationRemarkEmitterPass>()
Line
Count
Source
66
129k
  AnalysisUsage &addRequired() {
67
129k
    return addRequiredID(PassClass::ID);
68
129k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveDebugVariables>()
Line
Count
Source
66
62.9k
  AnalysisUsage &addRequired() {
67
62.9k
    return addRequiredID(PassClass::ID);
68
62.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveStacks>()
Line
Count
Source
66
94.5k
  AnalysisUsage &addRequired() {
67
94.5k
    return addRequiredID(PassClass::ID);
68
94.5k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::VirtRegMap>()
Line
Count
Source
66
62.9k
  AnalysisUsage &addRequired() {
67
62.9k
    return addRequiredID(PassClass::ID);
68
62.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveRegMatrix>()
Line
Count
Source
66
31.4k
  AnalysisUsage &addRequired() {
67
31.4k
    return addRequiredID(PassClass::ID);
68
31.4k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::SpillPlacement>()
Line
Count
Source
66
31.4k
  AnalysisUsage &addRequired() {
67
31.4k
    return addRequiredID(PassClass::ID);
68
31.4k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::PhysicalRegisterUsageInfo>()
Line
Count
Source
66
3.97k
  AnalysisUsage &addRequired() {
67
3.97k
    return addRequiredID(PassClass::ID);
68
3.97k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ModuleSummaryIndexWrapperPass>()
Line
Count
Source
66
307
  AnalysisUsage &addRequired() {
67
307
    return addRequiredID(PassClass::ID);
68
307
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::OptimizationRemarkEmitterWrapperPass>()
Line
Count
Source
66
210k
  AnalysisUsage &addRequired() {
67
210k
    return addRequiredID(PassClass::ID);
68
210k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::objcarc::ObjCARCAAWrapperPass>()
Line
Count
Source
66
31
  AnalysisUsage &addRequired() {
67
31
    return addRequiredID(PassClass::ID);
68
31
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DemandedBitsWrapperPass>()
Line
Count
Source
66
40.3k
  AnalysisUsage &addRequired() {
67
40.3k
    return addRequiredID(PassClass::ID);
68
40.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LoopAccessLegacyAnalysis>()
Line
Count
Source
66
39.7k
  AnalysisUsage &addRequired() {
67
39.7k
    return addRequiredID(PassClass::ID);
68
39.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DependenceAnalysisWrapperPass>()
Line
Count
Source
66
18
  AnalysisUsage &addRequired() {
67
18
    return addRequiredID(PassClass::ID);
68
18
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::IVUsersWrapperPass>()
Line
Count
Source
66
32.1k
  AnalysisUsage &addRequired() {
67
32.1k
    return addRequiredID(PassClass::ID);
68
32.1k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LCSSAVerificationPass>()
Line
Count
Source
66
258k
  AnalysisUsage &addRequired() {
67
258k
    return addRequiredID(PassClass::ID);
68
258k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<polly::ScopDetectionWrapperPass>()
Line
Count
Source
66
316
  AnalysisUsage &addRequired() {
67
316
    return addRequiredID(PassClass::ID);
68
316
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<polly::ScopInfoRegionPass>()
Line
Count
Source
66
1.27k
  AnalysisUsage &addRequired() {
67
1.27k
    return addRequiredID(PassClass::ID);
68
1.27k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<polly::DependenceInfo>()
Line
Count
Source
66
647
  AnalysisUsage &addRequired() {
67
647
    return addRequiredID(PassClass::ID);
68
647
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<polly::IslAstInfoWrapperPass>()
Line
Count
Source
66
315
  AnalysisUsage &addRequired() {
67
315
    return addRequiredID(PassClass::ID);
68
315
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::StackProtector>()
Line
Count
Source
66
42.2k
  AnalysisUsage &addRequired() {
67
42.2k
    return addRequiredID(PassClass::ID);
68
42.2k
  }
69
70
  AnalysisUsage &addRequiredTransitiveID(char &ID);
71
  template<class PassClass>
72
1.08M
  AnalysisUsage &addRequiredTransitive() {
73
1.08M
    return addRequiredTransitiveID(PassClass::ID);
74
1.08M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::CallGraphWrapperPass>()
Line
Count
Source
72
5
  AnalysisUsage &addRequiredTransitive() {
73
5
    return addRequiredTransitiveID(PassClass::ID);
74
5
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::AAResultsWrapperPass>()
Line
Count
Source
72
56.7k
  AnalysisUsage &addRequiredTransitive() {
73
56.7k
    return addRequiredTransitiveID(PassClass::ID);
74
56.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::ScalarEvolutionWrapperPass>()
Line
Count
Source
72
2.49k
  AnalysisUsage &addRequiredTransitive() {
73
2.49k
    return addRequiredTransitiveID(PassClass::ID);
74
2.49k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::LoopInfoWrapperPass>()
Line
Count
Source
72
185k
  AnalysisUsage &addRequiredTransitive() {
73
185k
    return addRequiredTransitiveID(PassClass::ID);
74
185k
  }
Unexecuted instantiation: llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::MemoryDependenceWrapperPass>()
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::TargetLibraryInfoWrapperPass>()
Line
Count
Source
72
227k
  AnalysisUsage &addRequiredTransitive() {
73
227k
    return addRequiredTransitiveID(PassClass::ID);
74
227k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::DominatorTreeWrapperPass>()
Line
Count
Source
72
202k
  AnalysisUsage &addRequiredTransitive() {
73
202k
    return addRequiredTransitiveID(PassClass::ID);
74
202k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::AssumptionCacheTracker>()
Line
Count
Source
72
185k
  AnalysisUsage &addRequiredTransitive() {
73
185k
    return addRequiredTransitiveID(PassClass::ID);
74
185k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::LiveIntervals>()
Line
Count
Source
72
62.9k
  AnalysisUsage &addRequiredTransitive() {
73
62.9k
    return addRequiredTransitiveID(PassClass::ID);
74
62.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::SlotIndexes>()
Line
Count
Source
72
68.0k
  AnalysisUsage &addRequiredTransitive() {
73
68.0k
    return addRequiredTransitiveID(PassClass::ID);
74
68.0k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::VirtRegMap>()
Line
Count
Source
72
31.4k
  AnalysisUsage &addRequiredTransitive() {
73
31.4k
    return addRequiredTransitiveID(PassClass::ID);
74
31.4k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::EdgeBundles>()
Line
Count
Source
72
31.4k
  AnalysisUsage &addRequiredTransitive() {
73
31.4k
    return addRequiredTransitiveID(PassClass::ID);
74
31.4k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::MachineLoopInfo>()
Line
Count
Source
72
31.4k
  AnalysisUsage &addRequiredTransitive() {
73
31.4k
    return addRequiredTransitiveID(PassClass::ID);
74
31.4k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<polly::ScopInfoRegionPass>()
Line
Count
Source
72
1.21k
  AnalysisUsage &addRequiredTransitive() {
73
1.21k
    return addRequiredTransitiveID(PassClass::ID);
74
1.21k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<polly::ScopInfoWrapperPass>()
Line
Count
Source
72
45
  AnalysisUsage &addRequiredTransitive() {
73
45
    return addRequiredTransitiveID(PassClass::ID);
74
45
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<polly::DependenceInfoWrapperPass>()
Line
Count
Source
72
19
  AnalysisUsage &addRequiredTransitive() {
73
19
    return addRequiredTransitiveID(PassClass::ID);
74
19
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::RegionInfoPass>()
Line
Count
Source
72
1.28k
  AnalysisUsage &addRequiredTransitive() {
73
1.28k
    return addRequiredTransitiveID(PassClass::ID);
74
1.28k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<polly::ScopDetectionWrapperPass>()
Line
Count
Source
72
1.16k
  AnalysisUsage &addRequiredTransitive() {
73
1.16k
    return addRequiredTransitiveID(PassClass::ID);
74
1.16k
  }
75
  ///@}
76
77
  ///@{
78
  /// Add the specified ID to the set of analyses preserved by this pass.
79
0
  AnalysisUsage &addPreservedID(const void *ID) {
80
0
    Preserved.push_back(ID);
81
0
    return *this;
82
0
  }
83
1.10M
  AnalysisUsage &addPreservedID(char &ID) {
84
1.10M
    Preserved.push_back(&ID);
85
1.10M
    return *this;
86
1.10M
  }
87
  /// Add the specified Pass class to the set of analyses preserved by this pass.
88
  template<class PassClass>
89
43.6M
  AnalysisUsage &addPreserved() {
90
43.6M
    Preserved.push_back(&PassClass::ID);
91
43.6M
    return *this;
92
43.6M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineDominatorTree>()
Line
Count
Source
89
389k
  AnalysisUsage &addPreserved() {
90
389k
    Preserved.push_back(&PassClass::ID);
91
389k
    return *this;
92
389k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineLoopInfo>()
Line
Count
Source
89
401k
  AnalysisUsage &addPreserved() {
90
401k
    Preserved.push_back(&PassClass::ID);
91
401k
    return *this;
92
401k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineTraceMetrics>()
Line
Count
Source
89
59.0k
  AnalysisUsage &addPreserved() {
90
59.0k
    Preserved.push_back(&PassClass::ID);
91
59.0k
    return *this;
92
59.0k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::DominatorTreeWrapperPass>()
Line
Count
Source
89
4.22M
  AnalysisUsage &addPreserved() {
90
4.22M
    Preserved.push_back(&PassClass::ID);
91
4.22M
    return *this;
92
4.22M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LoopInfoWrapperPass>()
Line
Count
Source
89
3.81M
  AnalysisUsage &addPreserved() {
90
3.81M
    Preserved.push_back(&PassClass::ID);
91
3.81M
    return *this;
92
3.81M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::ScalarEvolutionWrapperPass>()
Line
Count
Source
89
3.80M
  AnalysisUsage &addPreserved() {
90
3.80M
    Preserved.push_back(&PassClass::ID);
91
3.80M
    return *this;
92
3.80M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LegacyDivergenceAnalysis>()
Line
Count
Source
89
1.99k
  AnalysisUsage &addPreserved() {
90
1.99k
    Preserved.push_back(&PassClass::ID);
91
1.99k
    return *this;
92
1.99k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::SlotIndexes>()
Line
Count
Source
89
334k
  AnalysisUsage &addPreserved() {
90
334k
    Preserved.push_back(&PassClass::ID);
91
334k
    return *this;
92
334k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveIntervals>()
Line
Count
Source
89
202k
  AnalysisUsage &addPreserved() {
90
202k
    Preserved.push_back(&PassClass::ID);
91
202k
    return *this;
92
202k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::PostDominatorTreeWrapperPass>()
Line
Count
Source
89
26.9k
  AnalysisUsage &addPreserved() {
90
26.9k
    Preserved.push_back(&PassClass::ID);
91
26.9k
    return *this;
92
26.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::AAResultsWrapperPass>()
Line
Count
Source
89
3.98M
  AnalysisUsage &addPreserved() {
90
3.98M
    Preserved.push_back(&PassClass::ID);
91
3.98M
    return *this;
92
3.98M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::TargetLibraryInfoWrapperPass>()
Line
Count
Source
89
15.9k
  AnalysisUsage &addPreserved() {
90
15.9k
    Preserved.push_back(&PassClass::ID);
91
15.9k
    return *this;
92
15.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::StackProtector>()
Line
Count
Source
89
46.3k
  AnalysisUsage &addPreserved() {
90
46.3k
    Preserved.push_back(&PassClass::ID);
91
46.3k
    return *this;
92
46.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineBlockFrequencyInfo>()
Line
Count
Source
89
65.3k
  AnalysisUsage &addPreserved() {
90
65.3k
    Preserved.push_back(&PassClass::ID);
91
65.3k
    return *this;
92
65.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::WebAssemblyExceptionInfo>()
Line
Count
Source
89
320
  AnalysisUsage &addPreserved() {
90
320
    Preserved.push_back(&PassClass::ID);
91
320
    return *this;
92
320
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineModuleInfo>()
Line
Count
Source
89
3.39M
  AnalysisUsage &addPreserved() {
90
3.39M
    Preserved.push_back(&PassClass::ID);
91
3.39M
    return *this;
92
3.39M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::CallGraphWrapperPass>()
Line
Count
Source
89
78.3k
  AnalysisUsage &addPreserved() {
90
78.3k
    Preserved.push_back(&PassClass::ID);
91
78.3k
    return *this;
92
78.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveVariables>()
Line
Count
Source
89
103k
  AnalysisUsage &addPreserved() {
90
103k
    Preserved.push_back(&PassClass::ID);
91
103k
    return *this;
92
103k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::BasicAAWrapperPass>()
Line
Count
Source
89
3.86M
  AnalysisUsage &addPreserved() {
90
3.86M
    Preserved.push_back(&PassClass::ID);
91
3.86M
    return *this;
92
3.86M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::DominanceFrontierWrapperPass>()
Line
Count
Source
89
3.33M
  AnalysisUsage &addPreserved() {
90
3.33M
    Preserved.push_back(&PassClass::ID);
91
3.33M
    return *this;
92
3.33M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::GlobalsAAWrapperPass>()
Line
Count
Source
89
4.39M
  AnalysisUsage &addPreserved() {
90
4.39M
    Preserved.push_back(&PassClass::ID);
91
4.39M
    return *this;
92
4.39M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::IVUsersWrapperPass>()
Line
Count
Source
89
3.36M
  AnalysisUsage &addPreserved() {
90
3.36M
    Preserved.push_back(&PassClass::ID);
91
3.36M
    return *this;
92
3.36M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MemoryDependenceWrapperPass>()
Line
Count
Source
89
3.36M
  AnalysisUsage &addPreserved() {
90
3.36M
    Preserved.push_back(&PassClass::ID);
91
3.36M
    return *this;
92
3.36M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::SCEVAAWrapperPass>()
Line
Count
Source
89
3.73M
  AnalysisUsage &addPreserved() {
90
3.73M
    Preserved.push_back(&PassClass::ID);
91
3.73M
    return *this;
92
3.73M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachinePostDominatorTree>()
Line
Count
Source
89
31.9k
  AnalysisUsage &addPreserved() {
90
31.9k
    Preserved.push_back(&PassClass::ID);
91
31.9k
    return *this;
92
31.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveDebugVariables>()
Line
Count
Source
89
31.4k
  AnalysisUsage &addPreserved() {
90
31.4k
    Preserved.push_back(&PassClass::ID);
91
31.4k
    return *this;
92
31.4k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveStacks>()
Line
Count
Source
89
62.9k
  AnalysisUsage &addPreserved() {
90
62.9k
    Preserved.push_back(&PassClass::ID);
91
62.9k
    return *this;
92
62.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::VirtRegMap>()
Line
Count
Source
89
31.4k
  AnalysisUsage &addPreserved() {
90
31.4k
    Preserved.push_back(&PassClass::ID);
91
31.4k
    return *this;
92
31.4k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveRegMatrix>()
Line
Count
Source
89
31.4k
  AnalysisUsage &addPreserved() {
90
31.4k
    Preserved.push_back(&PassClass::ID);
91
31.4k
    return *this;
92
31.4k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MemorySSAWrapperPass>()
Line
Count
Source
89
13.1k
  AnalysisUsage &addPreserved() {
90
13.1k
    Preserved.push_back(&PassClass::ID);
91
13.1k
    return *this;
92
13.1k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LazyValueInfoWrapperPass>()
Line
Count
Source
89
26.8k
  AnalysisUsage &addPreserved() {
90
26.8k
    Preserved.push_back(&PassClass::ID);
91
26.8k
    return *this;
92
26.8k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::DependenceAnalysisWrapperPass>()
Line
Count
Source
89
140k
  AnalysisUsage &addPreserved() {
90
140k
    Preserved.push_back(&PassClass::ID);
91
140k
    return *this;
92
140k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LCSSAVerificationPass>()
Line
Count
Source
89
258k
  AnalysisUsage &addPreserved() {
90
258k
    Preserved.push_back(&PassClass::ID);
91
258k
    return *this;
92
258k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<polly::ScopDetectionWrapperPass>()
Line
Count
Source
89
962
  AnalysisUsage &addPreserved() {
90
962
    Preserved.push_back(&PassClass::ID);
91
962
    return *this;
92
962
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::OptimizationRemarkEmitterWrapperPass>()
Line
Count
Source
89
962
  AnalysisUsage &addPreserved() {
90
962
    Preserved.push_back(&PassClass::ID);
91
962
    return *this;
92
962
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::RegionInfoPass>()
Line
Count
Source
89
974
  AnalysisUsage &addPreserved() {
90
974
    Preserved.push_back(&PassClass::ID);
91
974
    return *this;
92
974
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<polly::ScopInfoRegionPass>()
Line
Count
Source
89
962
  AnalysisUsage &addPreserved() {
90
962
    Preserved.push_back(&PassClass::ID);
91
962
    return *this;
92
962
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::TargetTransformInfoWrapperPass>()
Line
Count
Source
89
962
  AnalysisUsage &addPreserved() {
90
962
    Preserved.push_back(&PassClass::ID);
91
962
    return *this;
92
962
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<polly::DependenceInfo>()
Line
Count
Source
89
937
  AnalysisUsage &addPreserved() {
90
937
    Preserved.push_back(&PassClass::ID);
91
937
    return *this;
92
937
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<polly::IslAstInfoWrapperPass>()
Line
Count
Source
89
315
  AnalysisUsage &addPreserved() {
90
315
    Preserved.push_back(&PassClass::ID);
91
315
    return *this;
92
315
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::GCModuleInfo>()
Line
Count
Source
89
35.4k
  AnalysisUsage &addPreserved() {
90
35.4k
    Preserved.push_back(&PassClass::ID);
91
35.4k
    return *this;
92
35.4k
  }
93
  ///@}
94
95
  ///@{
96
  /// Add the specified ID to the set of analyses used by this pass if they are
97
  /// available..
98
0
  AnalysisUsage &addUsedIfAvailableID(const void *ID) {
99
0
    Used.push_back(ID);
100
0
    return *this;
101
0
  }
102
0
  AnalysisUsage &addUsedIfAvailableID(char &ID) {
103
0
    Used.push_back(&ID);
104
0
    return *this;
105
0
  }
106
  /// Add the specified Pass class to the set of analyses used by this pass.
107
  template<class PassClass>
108
3.20M
  AnalysisUsage &addUsedIfAvailable() {
109
3.20M
    Used.push_back(&PassClass::ID);
110
3.20M
    return *this;
111
3.20M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::ScopedNoAliasAAWrapperPass>()
Line
Count
Source
108
397k
  AnalysisUsage &addUsedIfAvailable() {
109
397k
    Used.push_back(&PassClass::ID);
110
397k
    return *this;
111
397k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::TypeBasedAAWrapperPass>()
Line
Count
Source
108
397k
  AnalysisUsage &addUsedIfAvailable() {
109
397k
    Used.push_back(&PassClass::ID);
110
397k
    return *this;
111
397k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::objcarc::ObjCARCAAWrapperPass>()
Line
Count
Source
108
397k
  AnalysisUsage &addUsedIfAvailable() {
109
397k
    Used.push_back(&PassClass::ID);
110
397k
    return *this;
111
397k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::GlobalsAAWrapperPass>()
Line
Count
Source
108
397k
  AnalysisUsage &addUsedIfAvailable() {
109
397k
    Used.push_back(&PassClass::ID);
110
397k
    return *this;
111
397k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::SCEVAAWrapperPass>()
Line
Count
Source
108
348k
  AnalysisUsage &addUsedIfAvailable() {
109
348k
    Used.push_back(&PassClass::ID);
110
348k
    return *this;
111
348k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::CFLAndersAAWrapperPass>()
Line
Count
Source
108
397k
  AnalysisUsage &addUsedIfAvailable() {
109
397k
    Used.push_back(&PassClass::ID);
110
397k
    return *this;
111
397k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::CFLSteensAAWrapperPass>()
Line
Count
Source
108
397k
  AnalysisUsage &addUsedIfAvailable() {
109
397k
    Used.push_back(&PassClass::ID);
110
397k
    return *this;
111
397k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::PhiValuesWrapperPass>()
Line
Count
Source
108
367k
  AnalysisUsage &addUsedIfAvailable() {
109
367k
    Used.push_back(&PassClass::ID);
110
367k
    return *this;
111
367k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::SlotIndexes>()
Line
Count
Source
108
1.03k
  AnalysisUsage &addUsedIfAvailable() {
109
1.03k
    Used.push_back(&PassClass::ID);
110
1.03k
    return *this;
111
1.03k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::LiveVariables>()
Line
Count
Source
108
67.2k
  AnalysisUsage &addUsedIfAvailable() {
109
67.2k
    Used.push_back(&PassClass::ID);
110
67.2k
    return *this;
111
67.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::AAResultsWrapperPass>()
Line
Count
Source
108
33.6k
  AnalysisUsage &addUsedIfAvailable() {
109
33.6k
    Used.push_back(&PassClass::ID);
110
33.6k
    return *this;
111
33.6k
  }
112
  ///@}
113
114
  /// Add the Pass with the specified argument string to the set of analyses
115
  /// preserved by this pass. If no such Pass exists, do nothing. This can be
116
  /// useful when a pass is trivially preserved, but may not be linked in. Be
117
  /// careful about spelling!
118
  AnalysisUsage &addPreserved(StringRef Arg);
119
120
  /// Set by analyses that do not transform their input at all
121
5.10M
  void setPreservesAll() { PreservesAll = true; }
122
123
  /// Determine whether a pass said it does not transform its input at all
124
192M
  bool getPreservesAll() const { return PreservesAll; }
125
126
  /// This function should be called by the pass, iff they do not:
127
  ///
128
  ///  1. Add or remove basic blocks from the function
129
  ///  2. Modify terminator instructions in any way.
130
  ///
131
  /// This function annotates the AnalysisUsage info object to say that analyses
132
  /// that only depend on the CFG are preserved by this pass.
133
  void setPreservesCFG();
134
135
202M
  const VectorType &getRequiredSet() const { return Required; }
136
53.7M
  const VectorType &getRequiredTransitiveSet() const {
137
53.7M
    return RequiredTransitive;
138
53.7M
  }
139
94.3M
  const VectorType &getPreservedSet() const { return Preserved; }
140
28.1M
  const VectorType &getUsedSet() const { return Used; }
141
};
142
143
//===----------------------------------------------------------------------===//
144
/// AnalysisResolver - Simple interface used by Pass objects to pull all
145
/// analysis information out of pass manager that is responsible to manage
146
/// the pass.
147
///
148
class AnalysisResolver {
149
public:
150
  AnalysisResolver() = delete;
151
9.52M
  explicit AnalysisResolver(PMDataManager &P) : PM(P) {}
152
153
108M
  PMDataManager &getPMDataManager() { return PM; }
154
155
  /// Find pass that is implementing PI.
156
732M
  Pass *findImplPass(AnalysisID PI) {
157
732M
    Pass *ResultPass = nullptr;
158
1.71G
    for (const auto &AnalysisImpl : AnalysisImpls) {
159
1.71G
      if (AnalysisImpl.first == PI) {
160
710M
        ResultPass = AnalysisImpl.second;
161
710M
        break;
162
710M
      }
163
1.71G
    }
164
732M
    return ResultPass;
165
732M
  }
166
167
  /// Find pass that is implementing PI. Initialize pass for Function F.
168
  Pass *findImplPass(Pass *P, AnalysisID PI, Function &F);
169
170
409M
  void addAnalysisImplsPair(AnalysisID PI, Pass *P) {
171
409M
    if (findImplPass(PI) == P)
172
387M
      return;
173
22.4M
    std::pair<AnalysisID, Pass*> pir = std::make_pair(PI,P);
174
22.4M
    AnalysisImpls.push_back(pir);
175
22.4M
  }
176
177
  /// Clear cache that is used to connect a pass to the analysis (PassInfo).
178
4.46M
  void clearAnalysisImpls() {
179
4.46M
    AnalysisImpls.clear();
180
4.46M
  }
181
182
  /// Return analysis result or null if it doesn't exist.
183
  Pass *getAnalysisIfAvailable(AnalysisID ID, bool Direction) const;
184
185
private:
186
  /// This keeps track of which passes implements the interfaces that are
187
  /// required by the current pass (to implement getAnalysis()).
188
  std::vector<std::pair<AnalysisID, Pass *>> AnalysisImpls;
189
190
  /// PassManager that is used to resolve analysis info
191
  PMDataManager &PM;
192
};
193
194
/// getAnalysisIfAvailable<AnalysisType>() - Subclasses use this function to
195
/// get analysis information that might be around, for example to update it.
196
/// This is different than getAnalysis in that it can fail (if the analysis
197
/// results haven't been computed), so should only be used if you can handle
198
/// the case when the analysis is not available.  This method is often used by
199
/// transformation APIs to update analysis results for a pass automatically as
200
/// the transform is performed.
201
template<typename AnalysisType>
202
134M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
134M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
134M
205
134M
  const void *PI = &AnalysisType::ID;
206
134M
207
134M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
134M
  if (!ResultPass) 
return nullptr80.5M
;
209
54.3M
210
54.3M
  // Because the AnalysisType may not be a subclass of pass (for
211
54.3M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
54.3M
  // adjust the return pointer (because the class may multiply inherit, once
213
54.3M
  // from pass, once from AnalysisType).
214
54.3M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
54.3M
}
llvm::MachineLoopInfo* llvm::Pass::getAnalysisIfAvailable<llvm::MachineLoopInfo>() const
Line
Count
Source
202
1.94M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
1.94M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
1.94M
205
1.94M
  const void *PI = &AnalysisType::ID;
206
1.94M
207
1.94M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
1.94M
  if (!ResultPass) 
return nullptr385k
;
209
1.56M
210
1.56M
  // Because the AnalysisType may not be a subclass of pass (for
211
1.56M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
1.56M
  // adjust the return pointer (because the class may multiply inherit, once
213
1.56M
  // from pass, once from AnalysisType).
214
1.56M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
1.56M
}
llvm::AMDGPUAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::AMDGPUAAWrapperPass>() const
Line
Count
Source
202
158k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
158k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
158k
205
158k
  const void *PI = &AnalysisType::ID;
206
158k
207
158k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
158k
  if (!ResultPass) 
return nullptr0
;
209
158k
210
158k
  // Because the AnalysisType may not be a subclass of pass (for
211
158k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
158k
  // adjust the return pointer (because the class may multiply inherit, once
213
158k
  // from pass, once from AnalysisType).
214
158k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
158k
}
llvm::TargetPassConfig* llvm::Pass::getAnalysisIfAvailable<llvm::TargetPassConfig>() const
Line
Count
Source
202
2.04M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
2.04M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
2.04M
205
2.04M
  const void *PI = &AnalysisType::ID;
206
2.04M
207
2.04M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
2.04M
  if (!ResultPass) 
return nullptr18
;
209
2.04M
210
2.04M
  // Because the AnalysisType may not be a subclass of pass (for
211
2.04M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
2.04M
  // adjust the return pointer (because the class may multiply inherit, once
213
2.04M
  // from pass, once from AnalysisType).
214
2.04M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
2.04M
}
llvm::DominatorTreeWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::DominatorTreeWrapperPass>() const
Line
Count
Source
202
5.25M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
5.25M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
5.25M
205
5.25M
  const void *PI = &AnalysisType::ID;
206
5.25M
207
5.25M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
5.25M
  if (!ResultPass) 
return nullptr946k
;
209
4.30M
210
4.30M
  // Because the AnalysisType may not be a subclass of pass (for
211
4.30M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
4.30M
  // adjust the return pointer (because the class may multiply inherit, once
213
4.30M
  // from pass, once from AnalysisType).
214
4.30M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
4.30M
}
llvm::LiveIntervals* llvm::Pass::getAnalysisIfAvailable<llvm::LiveIntervals>() const
Line
Count
Source
202
2.96M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
2.96M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
2.96M
205
2.96M
  const void *PI = &AnalysisType::ID;
206
2.96M
207
2.96M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
2.96M
  if (!ResultPass) 
return nullptr2.76M
;
209
201k
210
201k
  // Because the AnalysisType may not be a subclass of pass (for
211
201k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
201k
  // adjust the return pointer (because the class may multiply inherit, once
213
201k
  // from pass, once from AnalysisType).
214
201k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
201k
}
llvm::TargetLibraryInfoWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::TargetLibraryInfoWrapperPass>() const
Line
Count
Source
202
2.95M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
2.95M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
2.95M
205
2.95M
  const void *PI = &AnalysisType::ID;
206
2.95M
207
2.95M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
2.95M
  if (!ResultPass) 
return nullptr0
;
209
2.95M
210
2.95M
  // Because the AnalysisType may not be a subclass of pass (for
211
2.95M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
2.95M
  // adjust the return pointer (because the class may multiply inherit, once
213
2.95M
  // from pass, once from AnalysisType).
214
2.95M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
2.95M
}
llvm::ScopedNoAliasAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::ScopedNoAliasAAWrapperPass>() const
Line
Count
Source
202
10.1M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
10.1M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
10.1M
205
10.1M
  const void *PI = &AnalysisType::ID;
206
10.1M
207
10.1M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
10.1M
  if (!ResultPass) 
return nullptr48.0k
;
209
10.0M
210
10.0M
  // Because the AnalysisType may not be a subclass of pass (for
211
10.0M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
10.0M
  // adjust the return pointer (because the class may multiply inherit, once
213
10.0M
  // from pass, once from AnalysisType).
214
10.0M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
10.0M
}
llvm::TypeBasedAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::TypeBasedAAWrapperPass>() const
Line
Count
Source
202
10.1M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
10.1M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
10.1M
205
10.1M
  const void *PI = &AnalysisType::ID;
206
10.1M
207
10.1M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
10.1M
  if (!ResultPass) 
return nullptr47.8k
;
209
10.0M
210
10.0M
  // Because the AnalysisType may not be a subclass of pass (for
211
10.0M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
10.0M
  // adjust the return pointer (because the class may multiply inherit, once
213
10.0M
  // from pass, once from AnalysisType).
214
10.0M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
10.0M
}
llvm::objcarc::ObjCARCAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::objcarc::ObjCARCAAWrapperPass>() const
Line
Count
Source
202
10.1M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
10.1M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
10.1M
205
10.1M
  const void *PI = &AnalysisType::ID;
206
10.1M
207
10.1M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
10.1M
  if (!ResultPass) 
return nullptr10.1M
;
209
969
210
969
  // Because the AnalysisType may not be a subclass of pass (for
211
969
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
969
  // adjust the return pointer (because the class may multiply inherit, once
213
969
  // from pass, once from AnalysisType).
214
969
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
969
}
llvm::GlobalsAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::GlobalsAAWrapperPass>() const
Line
Count
Source
202
10.1M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
10.1M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
10.1M
205
10.1M
  const void *PI = &AnalysisType::ID;
206
10.1M
207
10.1M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
10.1M
  if (!ResultPass) 
return nullptr2.15M
;
209
7.98M
210
7.98M
  // Because the AnalysisType may not be a subclass of pass (for
211
7.98M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
7.98M
  // adjust the return pointer (because the class may multiply inherit, once
213
7.98M
  // from pass, once from AnalysisType).
214
7.98M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
7.98M
}
llvm::SCEVAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::SCEVAAWrapperPass>() const
Line
Count
Source
202
8.99M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
8.99M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
8.99M
205
8.99M
  const void *PI = &AnalysisType::ID;
206
8.99M
207
8.99M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
8.99M
  if (!ResultPass) 
return nullptr8.99M
;
209
4
210
4
  // Because the AnalysisType may not be a subclass of pass (for
211
4
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
4
  // adjust the return pointer (because the class may multiply inherit, once
213
4
  // from pass, once from AnalysisType).
214
4
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
4
}
llvm::CFLAndersAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::CFLAndersAAWrapperPass>() const
Line
Count
Source
202
10.1M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
10.1M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
10.1M
205
10.1M
  const void *PI = &AnalysisType::ID;
206
10.1M
207
10.1M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
10.1M
  if (!ResultPass) 
return nullptr10.1M
;
209
41
210
41
  // Because the AnalysisType may not be a subclass of pass (for
211
41
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
41
  // adjust the return pointer (because the class may multiply inherit, once
213
41
  // from pass, once from AnalysisType).
214
41
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
41
}
llvm::CFLSteensAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::CFLSteensAAWrapperPass>() const
Line
Count
Source
202
10.1M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
10.1M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
10.1M
205
10.1M
  const void *PI = &AnalysisType::ID;
206
10.1M
207
10.1M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
10.1M
  if (!ResultPass) 
return nullptr10.1M
;
209
64
210
64
  // Because the AnalysisType may not be a subclass of pass (for
211
64
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
64
  // adjust the return pointer (because the class may multiply inherit, once
213
64
  // from pass, once from AnalysisType).
214
64
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
64
}
llvm::ExternalAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::ExternalAAWrapperPass>() const
Line
Count
Source
202
8.99M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
8.99M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
8.99M
205
8.99M
  const void *PI = &AnalysisType::ID;
206
8.99M
207
8.99M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
8.99M
  if (!ResultPass) 
return nullptr8.83M
;
209
158k
210
158k
  // Because the AnalysisType may not be a subclass of pass (for
211
158k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
158k
  // adjust the return pointer (because the class may multiply inherit, once
213
158k
  // from pass, once from AnalysisType).
214
158k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
158k
}
llvm::LoopInfoWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::LoopInfoWrapperPass>() const
Line
Count
Source
202
13.0M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
13.0M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
13.0M
205
13.0M
  const void *PI = &AnalysisType::ID;
206
13.0M
207
13.0M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
13.0M
  if (!ResultPass) 
return nullptr6.06M
;
209
6.99M
210
6.99M
  // Because the AnalysisType may not be a subclass of pass (for
211
6.99M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
6.99M
  // adjust the return pointer (because the class may multiply inherit, once
213
6.99M
  // from pass, once from AnalysisType).
214
6.99M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
6.99M
}
llvm::PhiValuesWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::PhiValuesWrapperPass>() const
Line
Count
Source
202
9.18M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
9.18M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
9.18M
205
9.18M
  const void *PI = &AnalysisType::ID;
206
9.18M
207
9.18M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
9.18M
  if (!ResultPass) 
return nullptr8.24M
;
209
931k
210
931k
  // Because the AnalysisType may not be a subclass of pass (for
211
931k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
931k
  // adjust the return pointer (because the class may multiply inherit, once
213
931k
  // from pass, once from AnalysisType).
214
931k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
931k
}
llvm::TargetTransformInfoWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::TargetTransformInfoWrapperPass>() const
Line
Count
Source
202
332k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
332k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
332k
205
332k
  const void *PI = &AnalysisType::ID;
206
332k
207
332k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
332k
  if (!ResultPass) 
return nullptr0
;
209
332k
210
332k
  // Because the AnalysisType may not be a subclass of pass (for
211
332k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
332k
  // adjust the return pointer (because the class may multiply inherit, once
213
332k
  // from pass, once from AnalysisType).
214
332k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
332k
}
llvm::AssumptionCacheTracker* llvm::Pass::getAnalysisIfAvailable<llvm::AssumptionCacheTracker>() const
Line
Count
Source
202
1.32M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
1.32M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
1.32M
205
1.32M
  const void *PI = &AnalysisType::ID;
206
1.32M
207
1.32M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
1.32M
  if (!ResultPass) 
return nullptr0
;
209
1.32M
210
1.32M
  // Because the AnalysisType may not be a subclass of pass (for
211
1.32M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
1.32M
  // adjust the return pointer (because the class may multiply inherit, once
213
1.32M
  // from pass, once from AnalysisType).
214
1.32M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
1.32M
}
llvm::MachineModuleInfo* llvm::Pass::getAnalysisIfAvailable<llvm::MachineModuleInfo>() const
Line
Count
Source
202
1.14M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
1.14M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
1.14M
205
1.14M
  const void *PI = &AnalysisType::ID;
206
1.14M
207
1.14M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
1.14M
  if (!ResultPass) 
return nullptr0
;
209
1.14M
210
1.14M
  // Because the AnalysisType may not be a subclass of pass (for
211
1.14M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
1.14M
  // adjust the return pointer (because the class may multiply inherit, once
213
1.14M
  // from pass, once from AnalysisType).
214
1.14M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
1.14M
}
llvm::GCModuleInfo* llvm::Pass::getAnalysisIfAvailable<llvm::GCModuleInfo>() const
Line
Count
Source
202
100k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
100k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
100k
205
100k
  const void *PI = &AnalysisType::ID;
206
100k
207
100k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
100k
  if (!ResultPass) 
return nullptr0
;
209
100k
210
100k
  // Because the AnalysisType may not be a subclass of pass (for
211
100k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
100k
  // adjust the return pointer (because the class may multiply inherit, once
213
100k
  // from pass, once from AnalysisType).
214
100k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
100k
}
llvm::MachineBlockFrequencyInfo* llvm::Pass::getAnalysisIfAvailable<llvm::MachineBlockFrequencyInfo>() const
Line
Count
Source
202
60
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
60
  assert(Resolver && "Pass not resident in a PassManager object!");
204
60
205
60
  const void *PI = &AnalysisType::ID;
206
60
207
60
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
60
  if (!ResultPass) 
return nullptr20
;
209
40
210
40
  // Because the AnalysisType may not be a subclass of pass (for
211
40
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
40
  // adjust the return pointer (because the class may multiply inherit, once
213
40
  // from pass, once from AnalysisType).
214
40
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
40
}
llvm::MachineDominatorTree* llvm::Pass::getAnalysisIfAvailable<llvm::MachineDominatorTree>() const
Line
Count
Source
202
951k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
951k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
951k
205
951k
  const void *PI = &AnalysisType::ID;
206
951k
207
951k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
951k
  if (!ResultPass) 
return nullptr378k
;
209
573k
210
573k
  // Because the AnalysisType may not be a subclass of pass (for
211
573k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
573k
  // adjust the return pointer (because the class may multiply inherit, once
213
573k
  // from pass, once from AnalysisType).
214
573k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
573k
}
llvm::SlotIndexes* llvm::Pass::getAnalysisIfAvailable<llvm::SlotIndexes>() const
Line
Count
Source
202
1.97M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
1.97M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
1.97M
205
1.97M
  const void *PI = &AnalysisType::ID;
206
1.97M
207
1.97M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
1.97M
  if (!ResultPass) 
return nullptr1.73M
;
209
240k
210
240k
  // Because the AnalysisType may not be a subclass of pass (for
211
240k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
240k
  // adjust the return pointer (because the class may multiply inherit, once
213
240k
  // from pass, once from AnalysisType).
214
240k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
240k
}
llvm::LiveVariables* llvm::Pass::getAnalysisIfAvailable<llvm::LiveVariables>() const
Line
Count
Source
202
2.72M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
2.72M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
2.72M
205
2.72M
  const void *PI = &AnalysisType::ID;
206
2.72M
207
2.72M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
2.72M
  if (!ResultPass) 
return nullptr1.64M
;
209
1.08M
210
1.08M
  // Because the AnalysisType may not be a subclass of pass (for
211
1.08M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
1.08M
  // adjust the return pointer (because the class may multiply inherit, once
213
1.08M
  // from pass, once from AnalysisType).
214
1.08M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
1.08M
}
llvm::LiveStacks* llvm::Pass::getAnalysisIfAvailable<llvm::LiveStacks>() const
Line
Count
Source
202
1.69M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
1.69M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
1.69M
205
1.69M
  const void *PI = &AnalysisType::ID;
206
1.69M
207
1.69M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
1.69M
  if (!ResultPass) 
return nullptr1.61M
;
209
78.1k
210
78.1k
  // Because the AnalysisType may not be a subclass of pass (for
211
78.1k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
78.1k
  // adjust the return pointer (because the class may multiply inherit, once
213
78.1k
  // from pass, once from AnalysisType).
214
78.1k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
78.1k
}
llvm::AAResultsWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::AAResultsWrapperPass>() const
Line
Count
Source
202
478k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
478k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
478k
205
478k
  const void *PI = &AnalysisType::ID;
206
478k
207
478k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
478k
  if (!ResultPass) 
return nullptr7.20k
;
209
471k
210
471k
  // Because the AnalysisType may not be a subclass of pass (for
211
471k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
471k
  // adjust the return pointer (because the class may multiply inherit, once
213
471k
  // from pass, once from AnalysisType).
214
471k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
471k
}
llvm::CallGraphWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::CallGraphWrapperPass>() const
Line
Count
Source
202
13
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
13
  assert(Resolver && "Pass not resident in a PassManager object!");
204
13
205
13
  const void *PI = &AnalysisType::ID;
206
13
207
13
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
13
  if (!ResultPass) return nullptr;
209
0
210
0
  // Because the AnalysisType may not be a subclass of pass (for
211
0
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
0
  // adjust the return pointer (because the class may multiply inherit, once
213
0
  // from pass, once from AnalysisType).
214
0
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
0
}
llvm::PostDominatorTreeWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::PostDominatorTreeWrapperPass>() const
Line
Count
Source
202
457k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
457k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
457k
205
457k
  const void *PI = &AnalysisType::ID;
206
457k
207
457k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
457k
  if (
!ResultPass457k
) return nullptr;
209
18.4E
210
18.4E
  // Because the AnalysisType may not be a subclass of pass (for
211
18.4E
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
18.4E
  // adjust the return pointer (because the class may multiply inherit, once
213
18.4E
  // from pass, once from AnalysisType).
214
18.4E
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
18.4E
}
llvm::ScalarEvolutionWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::ScalarEvolutionWrapperPass>() const
Line
Count
Source
202
6.99M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
6.99M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
6.99M
205
6.99M
  const void *PI = &AnalysisType::ID;
206
6.99M
207
6.99M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
6.99M
  if (!ResultPass) 
return nullptr5.51M
;
209
1.48M
210
1.48M
  // Because the AnalysisType may not be a subclass of pass (for
211
1.48M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
1.48M
  // adjust the return pointer (because the class may multiply inherit, once
213
1.48M
  // from pass, once from AnalysisType).
214
1.48M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
1.48M
}
llvm::RegionInfoPass* llvm::Pass::getAnalysisIfAvailable<llvm::RegionInfoPass>() const
Line
Count
Source
202
13
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
13
  assert(Resolver && "Pass not resident in a PassManager object!");
204
13
205
13
  const void *PI = &AnalysisType::ID;
206
13
207
13
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
13
  if (!ResultPass) return nullptr;
209
0
210
0
  // Because the AnalysisType may not be a subclass of pass (for
211
0
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
0
  // adjust the return pointer (because the class may multiply inherit, once
213
0
  // from pass, once from AnalysisType).
214
0
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
0
}
Unexecuted instantiation: llvm::MachineBranchProbabilityInfo* llvm::Pass::getAnalysisIfAvailable<llvm::MachineBranchProbabilityInfo>() const
llvm::LegacyDivergenceAnalysis* llvm::Pass::getAnalysisIfAvailable<llvm::LegacyDivergenceAnalysis>() const
Line
Count
Source
202
285k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
285k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
285k
205
285k
  const void *PI = &AnalysisType::ID;
206
285k
207
285k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
285k
  if (!ResultPass) 
return nullptr262k
;
209
22.4k
210
22.4k
  // Because the AnalysisType may not be a subclass of pass (for
211
22.4k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
22.4k
  // adjust the return pointer (because the class may multiply inherit, once
213
22.4k
  // from pass, once from AnalysisType).
214
22.4k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
22.4k
}
216
217
/// getAnalysis<AnalysisType>() - This function is used by subclasses to get
218
/// to the analysis information that they claim to use by overriding the
219
/// getAnalysisUsage function.
220
template<typename AnalysisType>
221
323M
AnalysisType &Pass::getAnalysis() const {
222
323M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
323M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
323M
}
llvm::MachineDominatorTree& llvm::Pass::getAnalysis<llvm::MachineDominatorTree>() const
Line
Count
Source
221
7.69M
AnalysisType &Pass::getAnalysis() const {
222
7.69M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
7.69M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
7.69M
}
llvm::MachineBranchProbabilityInfo& llvm::Pass::getAnalysis<llvm::MachineBranchProbabilityInfo>() const
Line
Count
Source
221
4.27M
AnalysisType &Pass::getAnalysis() const {
222
4.27M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
4.27M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
4.27M
}
llvm::MachineTraceMetrics& llvm::Pass::getAnalysis<llvm::MachineTraceMetrics>() const
Line
Count
Source
221
1.17M
AnalysisType &Pass::getAnalysis() const {
222
1.17M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.17M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.17M
}
llvm::TargetPassConfig& llvm::Pass::getAnalysis<llvm::TargetPassConfig>() const
Line
Count
Source
221
3.63M
AnalysisType &Pass::getAnalysis() const {
222
3.63M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
3.63M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
3.63M
}
llvm::LoopInfoWrapperPass& llvm::Pass::getAnalysis<llvm::LoopInfoWrapperPass>() const
Line
Count
Source
221
33.7M
AnalysisType &Pass::getAnalysis() const {
222
33.7M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
33.7M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
33.7M
}
llvm::ScalarEvolutionWrapperPass& llvm::Pass::getAnalysis<llvm::ScalarEvolutionWrapperPass>() const
Line
Count
Source
221
3.80M
AnalysisType &Pass::getAnalysis() const {
222
3.80M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
3.80M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
3.80M
}
llvm::MachineLoopInfo& llvm::Pass::getAnalysis<llvm::MachineLoopInfo>() const
Line
Count
Source
221
8.69M
AnalysisType &Pass::getAnalysis() const {
222
8.69M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
8.69M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
8.69M
}
llvm::AAResultsWrapperPass& llvm::Pass::getAnalysis<llvm::AAResultsWrapperPass>() const
Line
Count
Source
221
16.3M
AnalysisType &Pass::getAnalysis() const {
222
16.3M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
16.3M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
16.3M
}
llvm::LegacyDivergenceAnalysis& llvm::Pass::getAnalysis<llvm::LegacyDivergenceAnalysis>() const
Line
Count
Source
221
61.6k
AnalysisType &Pass::getAnalysis() const {
222
61.6k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
61.6k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
61.6k
}
llvm::MemoryDependenceWrapperPass& llvm::Pass::getAnalysis<llvm::MemoryDependenceWrapperPass>() const
Line
Count
Source
221
1.39M
AnalysisType &Pass::getAnalysis() const {
222
1.39M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.39M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.39M
}
llvm::AssumptionCacheTracker& llvm::Pass::getAnalysis<llvm::AssumptionCacheTracker>() const
Line
Count
Source
221
34.8M
AnalysisType &Pass::getAnalysis() const {
222
34.8M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
34.8M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
34.8M
}
llvm::TargetTransformInfoWrapperPass& llvm::Pass::getAnalysis<llvm::TargetTransformInfoWrapperPass>() const
Line
Count
Source
221
13.5M
AnalysisType &Pass::getAnalysis() const {
222
13.5M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
13.5M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
13.5M
}
Unexecuted instantiation: llvm::MachineRegionInfoPass& llvm::Pass::getAnalysis<llvm::MachineRegionInfoPass>() const
llvm::PostDominatorTreeWrapperPass& llvm::Pass::getAnalysis<llvm::PostDominatorTreeWrapperPass>() const
Line
Count
Source
221
603k
AnalysisType &Pass::getAnalysis() const {
222
603k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
603k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
603k
}
llvm::MachinePostDominatorTree& llvm::Pass::getAnalysis<llvm::MachinePostDominatorTree>() const
Line
Count
Source
221
989k
AnalysisType &Pass::getAnalysis() const {
222
989k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
989k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
989k
}
llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysis<llvm::DominatorTreeWrapperPass>() const
Line
Count
Source
221
45.5M
AnalysisType &Pass::getAnalysis() const {
222
45.5M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
45.5M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
45.5M
}
llvm::LiveIntervals& llvm::Pass::getAnalysis<llvm::LiveIntervals>() const
Line
Count
Source
221
3.36M
AnalysisType &Pass::getAnalysis() const {
222
3.36M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
3.36M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
3.36M
}
llvm::AMDGPUArgumentUsageInfo& llvm::Pass::getAnalysis<llvm::AMDGPUArgumentUsageInfo>() const
Line
Count
Source
221
20.6k
AnalysisType &Pass::getAnalysis() const {
222
20.6k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
20.6k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
20.6k
}
llvm::TargetLibraryInfoWrapperPass& llvm::Pass::getAnalysis<llvm::TargetLibraryInfoWrapperPass>() const
Line
Count
Source
221
47.3M
AnalysisType &Pass::getAnalysis() const {
222
47.3M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
47.3M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
47.3M
}
llvm::MachineDominanceFrontier& llvm::Pass::getAnalysis<llvm::MachineDominanceFrontier>() const
Line
Count
Source
221
10.1k
AnalysisType &Pass::getAnalysis() const {
222
10.1k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
10.1k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
10.1k
}
llvm::WebAssemblyExceptionInfo& llvm::Pass::getAnalysis<llvm::WebAssemblyExceptionInfo>() const
Line
Count
Source
221
3.66k
AnalysisType &Pass::getAnalysis() const {
222
3.66k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
3.66k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
3.66k
}
llvm::MachineBlockFrequencyInfo& llvm::Pass::getAnalysis<llvm::MachineBlockFrequencyInfo>() const
Line
Count
Source
221
3.81M
AnalysisType &Pass::getAnalysis() const {
222
3.81M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
3.81M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
3.81M
}
llvm::EdgeBundles& llvm::Pass::getAnalysis<llvm::EdgeBundles>() const
Line
Count
Source
221
933k
AnalysisType &Pass::getAnalysis() const {
222
933k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
933k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
933k
}
llvm::MachineModuleInfo& llvm::Pass::getAnalysis<llvm::MachineModuleInfo>() const
Line
Count
Source
221
49.0M
AnalysisType &Pass::getAnalysis() const {
222
49.0M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
49.0M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
49.0M
}
llvm::BasicAAWrapperPass& llvm::Pass::getAnalysis<llvm::BasicAAWrapperPass>() const
Line
Count
Source
221
8.99M
AnalysisType &Pass::getAnalysis() const {
222
8.99M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
8.99M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
8.99M
}
llvm::BranchProbabilityInfoWrapperPass& llvm::Pass::getAnalysis<llvm::BranchProbabilityInfoWrapperPass>() const
Line
Count
Source
221
2.08M
AnalysisType &Pass::getAnalysis() const {
222
2.08M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
2.08M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
2.08M
}
llvm::CallGraphWrapperPass& llvm::Pass::getAnalysis<llvm::CallGraphWrapperPass>() const
Line
Count
Source
221
2.14M
AnalysisType &Pass::getAnalysis() const {
222
2.14M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
2.14M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
2.14M
}
llvm::LazyBranchProbabilityInfoPass& llvm::Pass::getAnalysis<llvm::LazyBranchProbabilityInfoPass>() const
Line
Count
Source
221
5.60M
AnalysisType &Pass::getAnalysis() const {
222
5.60M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
5.60M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
5.60M
}
llvm::LazyValueInfoWrapperPass& llvm::Pass::getAnalysis<llvm::LazyValueInfoWrapperPass>() const
Line
Count
Source
221
1.82M
AnalysisType &Pass::getAnalysis() const {
222
1.82M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.82M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.82M
}
llvm::PhiValuesWrapperPass& llvm::Pass::getAnalysis<llvm::PhiValuesWrapperPass>() const
Line
Count
Source
221
1.39M
AnalysisType &Pass::getAnalysis() const {
222
1.39M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.39M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.39M
}
llvm::MemorySSAWrapperPass& llvm::Pass::getAnalysis<llvm::MemorySSAWrapperPass>() const
Line
Count
Source
221
457k
AnalysisType &Pass::getAnalysis() const {
222
457k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
457k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
457k
}
llvm::ProfileSummaryInfoWrapperPass& llvm::Pass::getAnalysis<llvm::ProfileSummaryInfoWrapperPass>() const
Line
Count
Source
221
1.29M
AnalysisType &Pass::getAnalysis() const {
222
1.29M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.29M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.29M
}
llvm::LazyBlockFrequencyInfoPass& llvm::Pass::getAnalysis<llvm::LazyBlockFrequencyInfoPass>() const
Line
Count
Source
221
209
AnalysisType &Pass::getAnalysis() const {
222
209
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
209
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
209
}
llvm::DominanceFrontierWrapperPass& llvm::Pass::getAnalysis<llvm::DominanceFrontierWrapperPass>() const
Line
Count
Source
221
23.5k
AnalysisType &Pass::getAnalysis() const {
222
23.5k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
23.5k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
23.5k
}
llvm::RegionInfoPass& llvm::Pass::getAnalysis<llvm::RegionInfoPass>() const
Line
Count
Source
221
25.0k
AnalysisType &Pass::getAnalysis() const {
222
25.0k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
25.0k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
25.0k
}
llvm::ReachingDefAnalysis& llvm::Pass::getAnalysis<llvm::ReachingDefAnalysis>() const
Line
Count
Source
221
278k
AnalysisType &Pass::getAnalysis() const {
222
278k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
278k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
278k
}
llvm::GCModuleInfo& llvm::Pass::getAnalysis<llvm::GCModuleInfo>() const
Line
Count
Source
221
198
AnalysisType &Pass::getAnalysis() const {
222
198
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
198
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
198
}
llvm::LiveStacks& llvm::Pass::getAnalysis<llvm::LiveStacks>() const
Line
Count
Source
221
1.39M
AnalysisType &Pass::getAnalysis() const {
222
1.39M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.39M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.39M
}
llvm::SlotIndexes& llvm::Pass::getAnalysis<llvm::SlotIndexes>() const
Line
Count
Source
221
1.90M
AnalysisType &Pass::getAnalysis() const {
222
1.90M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.90M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.90M
}
llvm::VirtRegMap& llvm::Pass::getAnalysis<llvm::VirtRegMap>() const
Line
Count
Source
221
1.39M
AnalysisType &Pass::getAnalysis() const {
222
1.39M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.39M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.39M
}
llvm::LazyMachineBlockFrequencyInfoPass& llvm::Pass::getAnalysis<llvm::LazyMachineBlockFrequencyInfoPass>() const
Line
Count
Source
221
60
AnalysisType &Pass::getAnalysis() const {
222
60
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
60
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
60
}
llvm::MachineOptimizationRemarkEmitterPass& llvm::Pass::getAnalysis<llvm::MachineOptimizationRemarkEmitterPass>() const
Line
Count
Source
221
1.77M
AnalysisType &Pass::getAnalysis() const {
222
1.77M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.77M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.77M
}
llvm::LiveRegMatrix& llvm::Pass::getAnalysis<llvm::LiveRegMatrix>() const
Line
Count
Source
221
466k
AnalysisType &Pass::getAnalysis() const {
222
466k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
466k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
466k
}
llvm::SpillPlacement& llvm::Pass::getAnalysis<llvm::SpillPlacement>() const
Line
Count
Source
221
465k
AnalysisType &Pass::getAnalysis() const {
222
465k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
465k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
465k
}
llvm::LiveDebugVariables& llvm::Pass::getAnalysis<llvm::LiveDebugVariables>() const
Line
Count
Source
221
931k
AnalysisType &Pass::getAnalysis() const {
222
931k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
931k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
931k
}
llvm::PhysicalRegisterUsageInfo& llvm::Pass::getAnalysis<llvm::PhysicalRegisterUsageInfo>() const
Line
Count
Source
221
39.6k
AnalysisType &Pass::getAnalysis() const {
222
39.6k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
39.6k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
39.6k
}
llvm::ModuleSummaryIndexWrapperPass& llvm::Pass::getAnalysis<llvm::ModuleSummaryIndexWrapperPass>() const
Line
Count
Source
221
307
AnalysisType &Pass::getAnalysis() const {
222
307
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
307
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
307
}
llvm::OptimizationRemarkEmitterWrapperPass& llvm::Pass::getAnalysis<llvm::OptimizationRemarkEmitterWrapperPass>() const
Line
Count
Source
221
5.88M
AnalysisType &Pass::getAnalysis() const {
222
5.88M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
5.88M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
5.88M
}
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysis<llvm::BlockFrequencyInfoWrapperPass>() const
Line
Count
Source
221
1.38M
AnalysisType &Pass::getAnalysis() const {
222
1.38M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.38M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.38M
}
llvm::DemandedBitsWrapperPass& llvm::Pass::getAnalysis<llvm::DemandedBitsWrapperPass>() const
Line
Count
Source
221
1.01M
AnalysisType &Pass::getAnalysis() const {
222
1.01M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.01M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.01M
}
llvm::LoopAccessLegacyAnalysis& llvm::Pass::getAnalysis<llvm::LoopAccessLegacyAnalysis>() const
Line
Count
Source
221
837k
AnalysisType &Pass::getAnalysis() const {
222
837k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
837k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
837k
}
llvm::DependenceAnalysisWrapperPass& llvm::Pass::getAnalysis<llvm::DependenceAnalysisWrapperPass>() const
Line
Count
Source
221
148
AnalysisType &Pass::getAnalysis() const {
222
148
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
148
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
148
}
llvm::IVUsersWrapperPass& llvm::Pass::getAnalysis<llvm::IVUsersWrapperPass>() const
Line
Count
Source
221
207k
AnalysisType &Pass::getAnalysis() const {
222
207k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
207k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
207k
}
polly::ScopInfoWrapperPass& llvm::Pass::getAnalysis<polly::ScopInfoWrapperPass>() const
Line
Count
Source
221
45
AnalysisType &Pass::getAnalysis() const {
222
45
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
45
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
45
}
polly::DependenceInfoWrapperPass& llvm::Pass::getAnalysis<polly::DependenceInfoWrapperPass>() const
Line
Count
Source
221
19
AnalysisType &Pass::getAnalysis() const {
222
19
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
19
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
19
}
polly::ScopDetectionWrapperPass& llvm::Pass::getAnalysis<polly::ScopDetectionWrapperPass>() const
Line
Count
Source
221
4.25k
AnalysisType &Pass::getAnalysis() const {
222
4.25k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
4.25k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
4.25k
}
polly::ScopInfoRegionPass& llvm::Pass::getAnalysis<polly::ScopInfoRegionPass>() const
Line
Count
Source
221
6.56k
AnalysisType &Pass::getAnalysis() const {
222
6.56k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
6.56k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
6.56k
}
polly::DependenceInfo& llvm::Pass::getAnalysis<polly::DependenceInfo>() const
Line
Count
Source
221
609
AnalysisType &Pass::getAnalysis() const {
222
609
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
609
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
609
}
polly::IslAstInfoWrapperPass& llvm::Pass::getAnalysis<polly::IslAstInfoWrapperPass>() const
Line
Count
Source
221
294
AnalysisType &Pass::getAnalysis() const {
222
294
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
294
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
294
}
llvm::StackProtector& llvm::Pass::getAnalysis<llvm::StackProtector>() const
Line
Count
Source
221
519k
AnalysisType &Pass::getAnalysis() const {
222
519k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
519k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
519k
}
225
226
template<typename AnalysisType>
227
323M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
323M
  assert(PI && "getAnalysis for unregistered pass!");
229
323M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
323M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
323M
  // should be a small number, we just do a linear search over a (dense)
232
323M
  // vector.
233
323M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
323M
  assert(ResultPass &&
235
323M
         "getAnalysis*() called on an analysis that was not "
236
323M
         "'required' by pass!");
237
323M
238
323M
  // Because the AnalysisType may not be a subclass of pass (for
239
323M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
323M
  // adjust the return pointer (because the class may multiply inherit, once
241
323M
  // from pass, once from AnalysisType).
242
323M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
323M
}
llvm::MachineDominatorTree& llvm::Pass::getAnalysisID<llvm::MachineDominatorTree>(void const*) const
Line
Count
Source
227
7.69M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
7.69M
  assert(PI && "getAnalysis for unregistered pass!");
229
7.69M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
7.69M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
7.69M
  // should be a small number, we just do a linear search over a (dense)
232
7.69M
  // vector.
233
7.69M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
7.69M
  assert(ResultPass &&
235
7.69M
         "getAnalysis*() called on an analysis that was not "
236
7.69M
         "'required' by pass!");
237
7.69M
238
7.69M
  // Because the AnalysisType may not be a subclass of pass (for
239
7.69M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
7.69M
  // adjust the return pointer (because the class may multiply inherit, once
241
7.69M
  // from pass, once from AnalysisType).
242
7.69M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
7.69M
}
llvm::MachineBranchProbabilityInfo& llvm::Pass::getAnalysisID<llvm::MachineBranchProbabilityInfo>(void const*) const
Line
Count
Source
227
4.27M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
4.27M
  assert(PI && "getAnalysis for unregistered pass!");
229
4.27M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
4.27M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
4.27M
  // should be a small number, we just do a linear search over a (dense)
232
4.27M
  // vector.
233
4.27M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
4.27M
  assert(ResultPass &&
235
4.27M
         "getAnalysis*() called on an analysis that was not "
236
4.27M
         "'required' by pass!");
237
4.27M
238
4.27M
  // Because the AnalysisType may not be a subclass of pass (for
239
4.27M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
4.27M
  // adjust the return pointer (because the class may multiply inherit, once
241
4.27M
  // from pass, once from AnalysisType).
242
4.27M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
4.27M
}
llvm::MachineTraceMetrics& llvm::Pass::getAnalysisID<llvm::MachineTraceMetrics>(void const*) const
Line
Count
Source
227
1.17M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.17M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.17M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.17M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.17M
  // should be a small number, we just do a linear search over a (dense)
232
1.17M
  // vector.
233
1.17M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.17M
  assert(ResultPass &&
235
1.17M
         "getAnalysis*() called on an analysis that was not "
236
1.17M
         "'required' by pass!");
237
1.17M
238
1.17M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.17M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.17M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.17M
  // from pass, once from AnalysisType).
242
1.17M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.17M
}
llvm::TargetPassConfig& llvm::Pass::getAnalysisID<llvm::TargetPassConfig>(void const*) const
Line
Count
Source
227
3.63M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
3.63M
  assert(PI && "getAnalysis for unregistered pass!");
229
3.63M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
3.63M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
3.63M
  // should be a small number, we just do a linear search over a (dense)
232
3.63M
  // vector.
233
3.63M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
3.63M
  assert(ResultPass &&
235
3.63M
         "getAnalysis*() called on an analysis that was not "
236
3.63M
         "'required' by pass!");
237
3.63M
238
3.63M
  // Because the AnalysisType may not be a subclass of pass (for
239
3.63M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
3.63M
  // adjust the return pointer (because the class may multiply inherit, once
241
3.63M
  // from pass, once from AnalysisType).
242
3.63M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
3.63M
}
llvm::LoopInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::LoopInfoWrapperPass>(void const*) const
Line
Count
Source
227
33.7M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
33.7M
  assert(PI && "getAnalysis for unregistered pass!");
229
33.7M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
33.7M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
33.7M
  // should be a small number, we just do a linear search over a (dense)
232
33.7M
  // vector.
233
33.7M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
33.7M
  assert(ResultPass &&
235
33.7M
         "getAnalysis*() called on an analysis that was not "
236
33.7M
         "'required' by pass!");
237
33.7M
238
33.7M
  // Because the AnalysisType may not be a subclass of pass (for
239
33.7M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
33.7M
  // adjust the return pointer (because the class may multiply inherit, once
241
33.7M
  // from pass, once from AnalysisType).
242
33.7M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
33.7M
}
llvm::ScalarEvolutionWrapperPass& llvm::Pass::getAnalysisID<llvm::ScalarEvolutionWrapperPass>(void const*) const
Line
Count
Source
227
3.80M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
3.80M
  assert(PI && "getAnalysis for unregistered pass!");
229
3.80M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
3.80M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
3.80M
  // should be a small number, we just do a linear search over a (dense)
232
3.80M
  // vector.
233
3.80M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
3.80M
  assert(ResultPass &&
235
3.80M
         "getAnalysis*() called on an analysis that was not "
236
3.80M
         "'required' by pass!");
237
3.80M
238
3.80M
  // Because the AnalysisType may not be a subclass of pass (for
239
3.80M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
3.80M
  // adjust the return pointer (because the class may multiply inherit, once
241
3.80M
  // from pass, once from AnalysisType).
242
3.80M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
3.80M
}
llvm::MachineLoopInfo& llvm::Pass::getAnalysisID<llvm::MachineLoopInfo>(void const*) const
Line
Count
Source
227
8.69M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
8.69M
  assert(PI && "getAnalysis for unregistered pass!");
229
8.69M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
8.69M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
8.69M
  // should be a small number, we just do a linear search over a (dense)
232
8.69M
  // vector.
233
8.69M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
8.69M
  assert(ResultPass &&
235
8.69M
         "getAnalysis*() called on an analysis that was not "
236
8.69M
         "'required' by pass!");
237
8.69M
238
8.69M
  // Because the AnalysisType may not be a subclass of pass (for
239
8.69M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
8.69M
  // adjust the return pointer (because the class may multiply inherit, once
241
8.69M
  // from pass, once from AnalysisType).
242
8.69M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
8.69M
}
llvm::AAResultsWrapperPass& llvm::Pass::getAnalysisID<llvm::AAResultsWrapperPass>(void const*) const
Line
Count
Source
227
16.3M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
16.3M
  assert(PI && "getAnalysis for unregistered pass!");
229
16.3M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
16.3M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
16.3M
  // should be a small number, we just do a linear search over a (dense)
232
16.3M
  // vector.
233
16.3M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
16.3M
  assert(ResultPass &&
235
16.3M
         "getAnalysis*() called on an analysis that was not "
236
16.3M
         "'required' by pass!");
237
16.3M
238
16.3M
  // Because the AnalysisType may not be a subclass of pass (for
239
16.3M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
16.3M
  // adjust the return pointer (because the class may multiply inherit, once
241
16.3M
  // from pass, once from AnalysisType).
242
16.3M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
16.3M
}
llvm::LegacyDivergenceAnalysis& llvm::Pass::getAnalysisID<llvm::LegacyDivergenceAnalysis>(void const*) const
Line
Count
Source
227
61.6k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
61.6k
  assert(PI && "getAnalysis for unregistered pass!");
229
61.6k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
61.6k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
61.6k
  // should be a small number, we just do a linear search over a (dense)
232
61.6k
  // vector.
233
61.6k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
61.6k
  assert(ResultPass &&
235
61.6k
         "getAnalysis*() called on an analysis that was not "
236
61.6k
         "'required' by pass!");
237
61.6k
238
61.6k
  // Because the AnalysisType may not be a subclass of pass (for
239
61.6k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
61.6k
  // adjust the return pointer (because the class may multiply inherit, once
241
61.6k
  // from pass, once from AnalysisType).
242
61.6k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
61.6k
}
llvm::MemoryDependenceWrapperPass& llvm::Pass::getAnalysisID<llvm::MemoryDependenceWrapperPass>(void const*) const
Line
Count
Source
227
1.39M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.39M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.39M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.39M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.39M
  // should be a small number, we just do a linear search over a (dense)
232
1.39M
  // vector.
233
1.39M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.39M
  assert(ResultPass &&
235
1.39M
         "getAnalysis*() called on an analysis that was not "
236
1.39M
         "'required' by pass!");
237
1.39M
238
1.39M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.39M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.39M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.39M
  // from pass, once from AnalysisType).
242
1.39M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.39M
}
llvm::AssumptionCacheTracker& llvm::Pass::getAnalysisID<llvm::AssumptionCacheTracker>(void const*) const
Line
Count
Source
227
34.8M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
34.8M
  assert(PI && "getAnalysis for unregistered pass!");
229
34.8M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
34.8M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
34.8M
  // should be a small number, we just do a linear search over a (dense)
232
34.8M
  // vector.
233
34.8M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
34.8M
  assert(ResultPass &&
235
34.8M
         "getAnalysis*() called on an analysis that was not "
236
34.8M
         "'required' by pass!");
237
34.8M
238
34.8M
  // Because the AnalysisType may not be a subclass of pass (for
239
34.8M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
34.8M
  // adjust the return pointer (because the class may multiply inherit, once
241
34.8M
  // from pass, once from AnalysisType).
242
34.8M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
34.8M
}
llvm::TargetTransformInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::TargetTransformInfoWrapperPass>(void const*) const
Line
Count
Source
227
13.5M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
13.5M
  assert(PI && "getAnalysis for unregistered pass!");
229
13.5M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
13.5M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
13.5M
  // should be a small number, we just do a linear search over a (dense)
232
13.5M
  // vector.
233
13.5M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
13.5M
  assert(ResultPass &&
235
13.5M
         "getAnalysis*() called on an analysis that was not "
236
13.5M
         "'required' by pass!");
237
13.5M
238
13.5M
  // Because the AnalysisType may not be a subclass of pass (for
239
13.5M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
13.5M
  // adjust the return pointer (because the class may multiply inherit, once
241
13.5M
  // from pass, once from AnalysisType).
242
13.5M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
13.5M
}
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
227
603k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
603k
  assert(PI && "getAnalysis for unregistered pass!");
229
603k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
603k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
603k
  // should be a small number, we just do a linear search over a (dense)
232
603k
  // vector.
233
603k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
603k
  assert(ResultPass &&
235
603k
         "getAnalysis*() called on an analysis that was not "
236
603k
         "'required' by pass!");
237
603k
238
603k
  // Because the AnalysisType may not be a subclass of pass (for
239
603k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
603k
  // adjust the return pointer (because the class may multiply inherit, once
241
603k
  // from pass, once from AnalysisType).
242
603k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
603k
}
llvm::MachinePostDominatorTree& llvm::Pass::getAnalysisID<llvm::MachinePostDominatorTree>(void const*) const
Line
Count
Source
227
989k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
989k
  assert(PI && "getAnalysis for unregistered pass!");
229
989k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
989k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
989k
  // should be a small number, we just do a linear search over a (dense)
232
989k
  // vector.
233
989k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
989k
  assert(ResultPass &&
235
989k
         "getAnalysis*() called on an analysis that was not "
236
989k
         "'required' by pass!");
237
989k
238
989k
  // Because the AnalysisType may not be a subclass of pass (for
239
989k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
989k
  // adjust the return pointer (because the class may multiply inherit, once
241
989k
  // from pass, once from AnalysisType).
242
989k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
989k
}
llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysisID<llvm::DominatorTreeWrapperPass>(void const*) const
Line
Count
Source
227
45.5M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
45.5M
  assert(PI && "getAnalysis for unregistered pass!");
229
45.5M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
45.5M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
45.5M
  // should be a small number, we just do a linear search over a (dense)
232
45.5M
  // vector.
233
45.5M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
45.5M
  assert(ResultPass &&
235
45.5M
         "getAnalysis*() called on an analysis that was not "
236
45.5M
         "'required' by pass!");
237
45.5M
238
45.5M
  // Because the AnalysisType may not be a subclass of pass (for
239
45.5M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
45.5M
  // adjust the return pointer (because the class may multiply inherit, once
241
45.5M
  // from pass, once from AnalysisType).
242
45.5M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
45.5M
}
llvm::LiveIntervals& llvm::Pass::getAnalysisID<llvm::LiveIntervals>(void const*) const
Line
Count
Source
227
3.36M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
3.36M
  assert(PI && "getAnalysis for unregistered pass!");
229
3.36M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
3.36M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
3.36M
  // should be a small number, we just do a linear search over a (dense)
232
3.36M
  // vector.
233
3.36M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
3.36M
  assert(ResultPass &&
235
3.36M
         "getAnalysis*() called on an analysis that was not "
236
3.36M
         "'required' by pass!");
237
3.36M
238
3.36M
  // Because the AnalysisType may not be a subclass of pass (for
239
3.36M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
3.36M
  // adjust the return pointer (because the class may multiply inherit, once
241
3.36M
  // from pass, once from AnalysisType).
242
3.36M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
3.36M
}
llvm::AMDGPUArgumentUsageInfo& llvm::Pass::getAnalysisID<llvm::AMDGPUArgumentUsageInfo>(void const*) const
Line
Count
Source
227
20.6k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
20.6k
  assert(PI && "getAnalysis for unregistered pass!");
229
20.6k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
20.6k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
20.6k
  // should be a small number, we just do a linear search over a (dense)
232
20.6k
  // vector.
233
20.6k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
20.6k
  assert(ResultPass &&
235
20.6k
         "getAnalysis*() called on an analysis that was not "
236
20.6k
         "'required' by pass!");
237
20.6k
238
20.6k
  // Because the AnalysisType may not be a subclass of pass (for
239
20.6k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
20.6k
  // adjust the return pointer (because the class may multiply inherit, once
241
20.6k
  // from pass, once from AnalysisType).
242
20.6k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
20.6k
}
llvm::TargetLibraryInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::TargetLibraryInfoWrapperPass>(void const*) const
Line
Count
Source
227
47.3M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
47.3M
  assert(PI && "getAnalysis for unregistered pass!");
229
47.3M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
47.3M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
47.3M
  // should be a small number, we just do a linear search over a (dense)
232
47.3M
  // vector.
233
47.3M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
47.3M
  assert(ResultPass &&
235
47.3M
         "getAnalysis*() called on an analysis that was not "
236
47.3M
         "'required' by pass!");
237
47.3M
238
47.3M
  // Because the AnalysisType may not be a subclass of pass (for
239
47.3M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
47.3M
  // adjust the return pointer (because the class may multiply inherit, once
241
47.3M
  // from pass, once from AnalysisType).
242
47.3M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
47.3M
}
llvm::MachineDominanceFrontier& llvm::Pass::getAnalysisID<llvm::MachineDominanceFrontier>(void const*) const
Line
Count
Source
227
10.1k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
10.1k
  assert(PI && "getAnalysis for unregistered pass!");
229
10.1k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
10.1k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
10.1k
  // should be a small number, we just do a linear search over a (dense)
232
10.1k
  // vector.
233
10.1k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
10.1k
  assert(ResultPass &&
235
10.1k
         "getAnalysis*() called on an analysis that was not "
236
10.1k
         "'required' by pass!");
237
10.1k
238
10.1k
  // Because the AnalysisType may not be a subclass of pass (for
239
10.1k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
10.1k
  // adjust the return pointer (because the class may multiply inherit, once
241
10.1k
  // from pass, once from AnalysisType).
242
10.1k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
10.1k
}
llvm::WebAssemblyExceptionInfo& llvm::Pass::getAnalysisID<llvm::WebAssemblyExceptionInfo>(void const*) const
Line
Count
Source
227
3.66k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
3.66k
  assert(PI && "getAnalysis for unregistered pass!");
229
3.66k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
3.66k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
3.66k
  // should be a small number, we just do a linear search over a (dense)
232
3.66k
  // vector.
233
3.66k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
3.66k
  assert(ResultPass &&
235
3.66k
         "getAnalysis*() called on an analysis that was not "
236
3.66k
         "'required' by pass!");
237
3.66k
238
3.66k
  // Because the AnalysisType may not be a subclass of pass (for
239
3.66k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
3.66k
  // adjust the return pointer (because the class may multiply inherit, once
241
3.66k
  // from pass, once from AnalysisType).
242
3.66k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
3.66k
}
llvm::MachineBlockFrequencyInfo& llvm::Pass::getAnalysisID<llvm::MachineBlockFrequencyInfo>(void const*) const
Line
Count
Source
227
3.81M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
3.81M
  assert(PI && "getAnalysis for unregistered pass!");
229
3.81M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
3.81M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
3.81M
  // should be a small number, we just do a linear search over a (dense)
232
3.81M
  // vector.
233
3.81M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
3.81M
  assert(ResultPass &&
235
3.81M
         "getAnalysis*() called on an analysis that was not "
236
3.81M
         "'required' by pass!");
237
3.81M
238
3.81M
  // Because the AnalysisType may not be a subclass of pass (for
239
3.81M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
3.81M
  // adjust the return pointer (because the class may multiply inherit, once
241
3.81M
  // from pass, once from AnalysisType).
242
3.81M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
3.81M
}
llvm::EdgeBundles& llvm::Pass::getAnalysisID<llvm::EdgeBundles>(void const*) const
Line
Count
Source
227
933k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
933k
  assert(PI && "getAnalysis for unregistered pass!");
229
933k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
933k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
933k
  // should be a small number, we just do a linear search over a (dense)
232
933k
  // vector.
233
933k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
933k
  assert(ResultPass &&
235
933k
         "getAnalysis*() called on an analysis that was not "
236
933k
         "'required' by pass!");
237
933k
238
933k
  // Because the AnalysisType may not be a subclass of pass (for
239
933k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
933k
  // adjust the return pointer (because the class may multiply inherit, once
241
933k
  // from pass, once from AnalysisType).
242
933k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
933k
}
llvm::MachineModuleInfo& llvm::Pass::getAnalysisID<llvm::MachineModuleInfo>(void const*) const
Line
Count
Source
227
49.0M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
49.0M
  assert(PI && "getAnalysis for unregistered pass!");
229
49.0M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
49.0M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
49.0M
  // should be a small number, we just do a linear search over a (dense)
232
49.0M
  // vector.
233
49.0M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
49.0M
  assert(ResultPass &&
235
49.0M
         "getAnalysis*() called on an analysis that was not "
236
49.0M
         "'required' by pass!");
237
49.0M
238
49.0M
  // Because the AnalysisType may not be a subclass of pass (for
239
49.0M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
49.0M
  // adjust the return pointer (because the class may multiply inherit, once
241
49.0M
  // from pass, once from AnalysisType).
242
49.0M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
49.0M
}
llvm::BasicAAWrapperPass& llvm::Pass::getAnalysisID<llvm::BasicAAWrapperPass>(void const*) const
Line
Count
Source
227
8.99M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
8.99M
  assert(PI && "getAnalysis for unregistered pass!");
229
8.99M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
8.99M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
8.99M
  // should be a small number, we just do a linear search over a (dense)
232
8.99M
  // vector.
233
8.99M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
8.99M
  assert(ResultPass &&
235
8.99M
         "getAnalysis*() called on an analysis that was not "
236
8.99M
         "'required' by pass!");
237
8.99M
238
8.99M
  // Because the AnalysisType may not be a subclass of pass (for
239
8.99M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
8.99M
  // adjust the return pointer (because the class may multiply inherit, once
241
8.99M
  // from pass, once from AnalysisType).
242
8.99M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
8.99M
}
llvm::BranchProbabilityInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::BranchProbabilityInfoWrapperPass>(void const*) const
Line
Count
Source
227
2.08M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
2.08M
  assert(PI && "getAnalysis for unregistered pass!");
229
2.08M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
2.08M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
2.08M
  // should be a small number, we just do a linear search over a (dense)
232
2.08M
  // vector.
233
2.08M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
2.08M
  assert(ResultPass &&
235
2.08M
         "getAnalysis*() called on an analysis that was not "
236
2.08M
         "'required' by pass!");
237
2.08M
238
2.08M
  // Because the AnalysisType may not be a subclass of pass (for
239
2.08M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
2.08M
  // adjust the return pointer (because the class may multiply inherit, once
241
2.08M
  // from pass, once from AnalysisType).
242
2.08M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
2.08M
}
llvm::CallGraphWrapperPass& llvm::Pass::getAnalysisID<llvm::CallGraphWrapperPass>(void const*) const
Line
Count
Source
227
2.14M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
2.14M
  assert(PI && "getAnalysis for unregistered pass!");
229
2.14M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
2.14M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
2.14M
  // should be a small number, we just do a linear search over a (dense)
232
2.14M
  // vector.
233
2.14M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
2.14M
  assert(ResultPass &&
235
2.14M
         "getAnalysis*() called on an analysis that was not "
236
2.14M
         "'required' by pass!");
237
2.14M
238
2.14M
  // Because the AnalysisType may not be a subclass of pass (for
239
2.14M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
2.14M
  // adjust the return pointer (because the class may multiply inherit, once
241
2.14M
  // from pass, once from AnalysisType).
242
2.14M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
2.14M
}
llvm::LazyBranchProbabilityInfoPass& llvm::Pass::getAnalysisID<llvm::LazyBranchProbabilityInfoPass>(void const*) const
Line
Count
Source
227
5.60M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
5.60M
  assert(PI && "getAnalysis for unregistered pass!");
229
5.60M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
5.60M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
5.60M
  // should be a small number, we just do a linear search over a (dense)
232
5.60M
  // vector.
233
5.60M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
5.60M
  assert(ResultPass &&
235
5.60M
         "getAnalysis*() called on an analysis that was not "
236
5.60M
         "'required' by pass!");
237
5.60M
238
5.60M
  // Because the AnalysisType may not be a subclass of pass (for
239
5.60M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
5.60M
  // adjust the return pointer (because the class may multiply inherit, once
241
5.60M
  // from pass, once from AnalysisType).
242
5.60M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
5.60M
}
llvm::LazyValueInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::LazyValueInfoWrapperPass>(void const*) const
Line
Count
Source
227
1.82M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.82M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.82M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.82M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.82M
  // should be a small number, we just do a linear search over a (dense)
232
1.82M
  // vector.
233
1.82M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.82M
  assert(ResultPass &&
235
1.82M
         "getAnalysis*() called on an analysis that was not "
236
1.82M
         "'required' by pass!");
237
1.82M
238
1.82M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.82M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.82M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.82M
  // from pass, once from AnalysisType).
242
1.82M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.82M
}
llvm::PhiValuesWrapperPass& llvm::Pass::getAnalysisID<llvm::PhiValuesWrapperPass>(void const*) const
Line
Count
Source
227
1.39M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.39M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.39M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.39M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.39M
  // should be a small number, we just do a linear search over a (dense)
232
1.39M
  // vector.
233
1.39M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.39M
  assert(ResultPass &&
235
1.39M
         "getAnalysis*() called on an analysis that was not "
236
1.39M
         "'required' by pass!");
237
1.39M
238
1.39M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.39M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.39M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.39M
  // from pass, once from AnalysisType).
242
1.39M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.39M
}
llvm::MemorySSAWrapperPass& llvm::Pass::getAnalysisID<llvm::MemorySSAWrapperPass>(void const*) const
Line
Count
Source
227
457k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
457k
  assert(PI && "getAnalysis for unregistered pass!");
229
457k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
457k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
457k
  // should be a small number, we just do a linear search over a (dense)
232
457k
  // vector.
233
457k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
457k
  assert(ResultPass &&
235
457k
         "getAnalysis*() called on an analysis that was not "
236
457k
         "'required' by pass!");
237
457k
238
457k
  // Because the AnalysisType may not be a subclass of pass (for
239
457k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
457k
  // adjust the return pointer (because the class may multiply inherit, once
241
457k
  // from pass, once from AnalysisType).
242
457k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
457k
}
llvm::ProfileSummaryInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::ProfileSummaryInfoWrapperPass>(void const*) const
Line
Count
Source
227
1.29M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.29M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.29M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.29M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.29M
  // should be a small number, we just do a linear search over a (dense)
232
1.29M
  // vector.
233
1.29M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.29M
  assert(ResultPass &&
235
1.29M
         "getAnalysis*() called on an analysis that was not "
236
1.29M
         "'required' by pass!");
237
1.29M
238
1.29M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.29M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.29M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.29M
  // from pass, once from AnalysisType).
242
1.29M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.29M
}
llvm::LazyBlockFrequencyInfoPass& llvm::Pass::getAnalysisID<llvm::LazyBlockFrequencyInfoPass>(void const*) const
Line
Count
Source
227
209
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
209
  assert(PI && "getAnalysis for unregistered pass!");
229
209
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
209
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
209
  // should be a small number, we just do a linear search over a (dense)
232
209
  // vector.
233
209
  Pass *ResultPass = Resolver->findImplPass(PI);
234
209
  assert(ResultPass &&
235
209
         "getAnalysis*() called on an analysis that was not "
236
209
         "'required' by pass!");
237
209
238
209
  // Because the AnalysisType may not be a subclass of pass (for
239
209
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
209
  // adjust the return pointer (because the class may multiply inherit, once
241
209
  // from pass, once from AnalysisType).
242
209
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
209
}
llvm::DominanceFrontierWrapperPass& llvm::Pass::getAnalysisID<llvm::DominanceFrontierWrapperPass>(void const*) const
Line
Count
Source
227
23.5k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
23.5k
  assert(PI && "getAnalysis for unregistered pass!");
229
23.5k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
23.5k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
23.5k
  // should be a small number, we just do a linear search over a (dense)
232
23.5k
  // vector.
233
23.5k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
23.5k
  assert(ResultPass &&
235
23.5k
         "getAnalysis*() called on an analysis that was not "
236
23.5k
         "'required' by pass!");
237
23.5k
238
23.5k
  // Because the AnalysisType may not be a subclass of pass (for
239
23.5k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
23.5k
  // adjust the return pointer (because the class may multiply inherit, once
241
23.5k
  // from pass, once from AnalysisType).
242
23.5k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
23.5k
}
llvm::RegionInfoPass& llvm::Pass::getAnalysisID<llvm::RegionInfoPass>(void const*) const
Line
Count
Source
227
25.0k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
25.0k
  assert(PI && "getAnalysis for unregistered pass!");
229
25.0k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
25.0k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
25.0k
  // should be a small number, we just do a linear search over a (dense)
232
25.0k
  // vector.
233
25.0k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
25.0k
  assert(ResultPass &&
235
25.0k
         "getAnalysis*() called on an analysis that was not "
236
25.0k
         "'required' by pass!");
237
25.0k
238
25.0k
  // Because the AnalysisType may not be a subclass of pass (for
239
25.0k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
25.0k
  // adjust the return pointer (because the class may multiply inherit, once
241
25.0k
  // from pass, once from AnalysisType).
242
25.0k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
25.0k
}
llvm::ReachingDefAnalysis& llvm::Pass::getAnalysisID<llvm::ReachingDefAnalysis>(void const*) const
Line
Count
Source
227
278k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
278k
  assert(PI && "getAnalysis for unregistered pass!");
229
278k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
278k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
278k
  // should be a small number, we just do a linear search over a (dense)
232
278k
  // vector.
233
278k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
278k
  assert(ResultPass &&
235
278k
         "getAnalysis*() called on an analysis that was not "
236
278k
         "'required' by pass!");
237
278k
238
278k
  // Because the AnalysisType may not be a subclass of pass (for
239
278k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
278k
  // adjust the return pointer (because the class may multiply inherit, once
241
278k
  // from pass, once from AnalysisType).
242
278k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
278k
}
llvm::GCModuleInfo& llvm::Pass::getAnalysisID<llvm::GCModuleInfo>(void const*) const
Line
Count
Source
227
198
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
198
  assert(PI && "getAnalysis for unregistered pass!");
229
198
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
198
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
198
  // should be a small number, we just do a linear search over a (dense)
232
198
  // vector.
233
198
  Pass *ResultPass = Resolver->findImplPass(PI);
234
198
  assert(ResultPass &&
235
198
         "getAnalysis*() called on an analysis that was not "
236
198
         "'required' by pass!");
237
198
238
198
  // Because the AnalysisType may not be a subclass of pass (for
239
198
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
198
  // adjust the return pointer (because the class may multiply inherit, once
241
198
  // from pass, once from AnalysisType).
242
198
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
198
}
llvm::LiveStacks& llvm::Pass::getAnalysisID<llvm::LiveStacks>(void const*) const
Line
Count
Source
227
1.39M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.39M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.39M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.39M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.39M
  // should be a small number, we just do a linear search over a (dense)
232
1.39M
  // vector.
233
1.39M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.39M
  assert(ResultPass &&
235
1.39M
         "getAnalysis*() called on an analysis that was not "
236
1.39M
         "'required' by pass!");
237
1.39M
238
1.39M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.39M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.39M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.39M
  // from pass, once from AnalysisType).
242
1.39M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.39M
}
llvm::SlotIndexes& llvm::Pass::getAnalysisID<llvm::SlotIndexes>(void const*) const
Line
Count
Source
227
1.90M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.90M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.90M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.90M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.90M
  // should be a small number, we just do a linear search over a (dense)
232
1.90M
  // vector.
233
1.90M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.90M
  assert(ResultPass &&
235
1.90M
         "getAnalysis*() called on an analysis that was not "
236
1.90M
         "'required' by pass!");
237
1.90M
238
1.90M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.90M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.90M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.90M
  // from pass, once from AnalysisType).
242
1.90M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.90M
}
llvm::VirtRegMap& llvm::Pass::getAnalysisID<llvm::VirtRegMap>(void const*) const
Line
Count
Source
227
1.39M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.39M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.39M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.39M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.39M
  // should be a small number, we just do a linear search over a (dense)
232
1.39M
  // vector.
233
1.39M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.39M
  assert(ResultPass &&
235
1.39M
         "getAnalysis*() called on an analysis that was not "
236
1.39M
         "'required' by pass!");
237
1.39M
238
1.39M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.39M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.39M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.39M
  // from pass, once from AnalysisType).
242
1.39M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.39M
}
llvm::LazyMachineBlockFrequencyInfoPass& llvm::Pass::getAnalysisID<llvm::LazyMachineBlockFrequencyInfoPass>(void const*) const
Line
Count
Source
227
60
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
60
  assert(PI && "getAnalysis for unregistered pass!");
229
60
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
60
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
60
  // should be a small number, we just do a linear search over a (dense)
232
60
  // vector.
233
60
  Pass *ResultPass = Resolver->findImplPass(PI);
234
60
  assert(ResultPass &&
235
60
         "getAnalysis*() called on an analysis that was not "
236
60
         "'required' by pass!");
237
60
238
60
  // Because the AnalysisType may not be a subclass of pass (for
239
60
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
60
  // adjust the return pointer (because the class may multiply inherit, once
241
60
  // from pass, once from AnalysisType).
242
60
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
60
}
llvm::MachineOptimizationRemarkEmitterPass& llvm::Pass::getAnalysisID<llvm::MachineOptimizationRemarkEmitterPass>(void const*) const
Line
Count
Source
227
1.77M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.77M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.77M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.77M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.77M
  // should be a small number, we just do a linear search over a (dense)
232
1.77M
  // vector.
233
1.77M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.77M
  assert(ResultPass &&
235
1.77M
         "getAnalysis*() called on an analysis that was not "
236
1.77M
         "'required' by pass!");
237
1.77M
238
1.77M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.77M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.77M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.77M
  // from pass, once from AnalysisType).
242
1.77M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.77M
}
llvm::LiveRegMatrix& llvm::Pass::getAnalysisID<llvm::LiveRegMatrix>(void const*) const
Line
Count
Source
227
466k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
466k
  assert(PI && "getAnalysis for unregistered pass!");
229
466k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
466k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
466k
  // should be a small number, we just do a linear search over a (dense)
232
466k
  // vector.
233
466k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
466k
  assert(ResultPass &&
235
466k
         "getAnalysis*() called on an analysis that was not "
236
466k
         "'required' by pass!");
237
466k
238
466k
  // Because the AnalysisType may not be a subclass of pass (for
239
466k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
466k
  // adjust the return pointer (because the class may multiply inherit, once
241
466k
  // from pass, once from AnalysisType).
242
466k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
466k
}
llvm::SpillPlacement& llvm::Pass::getAnalysisID<llvm::SpillPlacement>(void const*) const
Line
Count
Source
227
465k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
465k
  assert(PI && "getAnalysis for unregistered pass!");
229
465k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
465k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
465k
  // should be a small number, we just do a linear search over a (dense)
232
465k
  // vector.
233
465k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
465k
  assert(ResultPass &&
235
465k
         "getAnalysis*() called on an analysis that was not "
236
465k
         "'required' by pass!");
237
465k
238
465k
  // Because the AnalysisType may not be a subclass of pass (for
239
465k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
465k
  // adjust the return pointer (because the class may multiply inherit, once
241
465k
  // from pass, once from AnalysisType).
242
465k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
465k
}
llvm::LiveDebugVariables& llvm::Pass::getAnalysisID<llvm::LiveDebugVariables>(void const*) const
Line
Count
Source
227
931k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
931k
  assert(PI && "getAnalysis for unregistered pass!");
229
931k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
931k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
931k
  // should be a small number, we just do a linear search over a (dense)
232
931k
  // vector.
233
931k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
931k
  assert(ResultPass &&
235
931k
         "getAnalysis*() called on an analysis that was not "
236
931k
         "'required' by pass!");
237
931k
238
931k
  // Because the AnalysisType may not be a subclass of pass (for
239
931k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
931k
  // adjust the return pointer (because the class may multiply inherit, once
241
931k
  // from pass, once from AnalysisType).
242
931k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
931k
}
llvm::PhysicalRegisterUsageInfo& llvm::Pass::getAnalysisID<llvm::PhysicalRegisterUsageInfo>(void const*) const
Line
Count
Source
227
39.6k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
39.6k
  assert(PI && "getAnalysis for unregistered pass!");
229
39.6k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
39.6k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
39.6k
  // should be a small number, we just do a linear search over a (dense)
232
39.6k
  // vector.
233
39.6k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
39.6k
  assert(ResultPass &&
235
39.6k
         "getAnalysis*() called on an analysis that was not "
236
39.6k
         "'required' by pass!");
237
39.6k
238
39.6k
  // Because the AnalysisType may not be a subclass of pass (for
239
39.6k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
39.6k
  // adjust the return pointer (because the class may multiply inherit, once
241
39.6k
  // from pass, once from AnalysisType).
242
39.6k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
39.6k
}
llvm::ModuleSummaryIndexWrapperPass& llvm::Pass::getAnalysisID<llvm::ModuleSummaryIndexWrapperPass>(void const*) const
Line
Count
Source
227
307
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
307
  assert(PI && "getAnalysis for unregistered pass!");
229
307
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
307
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
307
  // should be a small number, we just do a linear search over a (dense)
232
307
  // vector.
233
307
  Pass *ResultPass = Resolver->findImplPass(PI);
234
307
  assert(ResultPass &&
235
307
         "getAnalysis*() called on an analysis that was not "
236
307
         "'required' by pass!");
237
307
238
307
  // Because the AnalysisType may not be a subclass of pass (for
239
307
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
307
  // adjust the return pointer (because the class may multiply inherit, once
241
307
  // from pass, once from AnalysisType).
242
307
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
307
}
llvm::OptimizationRemarkEmitterWrapperPass& llvm::Pass::getAnalysisID<llvm::OptimizationRemarkEmitterWrapperPass>(void const*) const
Line
Count
Source
227
5.88M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
5.88M
  assert(PI && "getAnalysis for unregistered pass!");
229
5.88M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
5.88M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
5.88M
  // should be a small number, we just do a linear search over a (dense)
232
5.88M
  // vector.
233
5.88M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
5.88M
  assert(ResultPass &&
235
5.88M
         "getAnalysis*() called on an analysis that was not "
236
5.88M
         "'required' by pass!");
237
5.88M
238
5.88M
  // Because the AnalysisType may not be a subclass of pass (for
239
5.88M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
5.88M
  // adjust the return pointer (because the class may multiply inherit, once
241
5.88M
  // from pass, once from AnalysisType).
242
5.88M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
5.88M
}
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::BlockFrequencyInfoWrapperPass>(void const*) const
Line
Count
Source
227
1.38M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.38M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.38M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.38M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.38M
  // should be a small number, we just do a linear search over a (dense)
232
1.38M
  // vector.
233
1.38M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.38M
  assert(ResultPass &&
235
1.38M
         "getAnalysis*() called on an analysis that was not "
236
1.38M
         "'required' by pass!");
237
1.38M
238
1.38M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.38M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.38M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.38M
  // from pass, once from AnalysisType).
242
1.38M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.38M
}
llvm::DemandedBitsWrapperPass& llvm::Pass::getAnalysisID<llvm::DemandedBitsWrapperPass>(void const*) const
Line
Count
Source
227
1.01M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.01M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.01M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.01M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.01M
  // should be a small number, we just do a linear search over a (dense)
232
1.01M
  // vector.
233
1.01M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.01M
  assert(ResultPass &&
235
1.01M
         "getAnalysis*() called on an analysis that was not "
236
1.01M
         "'required' by pass!");
237
1.01M
238
1.01M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.01M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.01M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.01M
  // from pass, once from AnalysisType).
242
1.01M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.01M
}
llvm::LoopAccessLegacyAnalysis& llvm::Pass::getAnalysisID<llvm::LoopAccessLegacyAnalysis>(void const*) const
Line
Count
Source
227
837k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
837k
  assert(PI && "getAnalysis for unregistered pass!");
229
837k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
837k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
837k
  // should be a small number, we just do a linear search over a (dense)
232
837k
  // vector.
233
837k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
837k
  assert(ResultPass &&
235
837k
         "getAnalysis*() called on an analysis that was not "
236
837k
         "'required' by pass!");
237
837k
238
837k
  // Because the AnalysisType may not be a subclass of pass (for
239
837k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
837k
  // adjust the return pointer (because the class may multiply inherit, once
241
837k
  // from pass, once from AnalysisType).
242
837k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
837k
}
llvm::DependenceAnalysisWrapperPass& llvm::Pass::getAnalysisID<llvm::DependenceAnalysisWrapperPass>(void const*) const
Line
Count
Source
227
148
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
148
  assert(PI && "getAnalysis for unregistered pass!");
229
148
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
148
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
148
  // should be a small number, we just do a linear search over a (dense)
232
148
  // vector.
233
148
  Pass *ResultPass = Resolver->findImplPass(PI);
234
148
  assert(ResultPass &&
235
148
         "getAnalysis*() called on an analysis that was not "
236
148
         "'required' by pass!");
237
148
238
148
  // Because the AnalysisType may not be a subclass of pass (for
239
148
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
148
  // adjust the return pointer (because the class may multiply inherit, once
241
148
  // from pass, once from AnalysisType).
242
148
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
148
}
llvm::IVUsersWrapperPass& llvm::Pass::getAnalysisID<llvm::IVUsersWrapperPass>(void const*) const
Line
Count
Source
227
207k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
207k
  assert(PI && "getAnalysis for unregistered pass!");
229
207k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
207k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
207k
  // should be a small number, we just do a linear search over a (dense)
232
207k
  // vector.
233
207k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
207k
  assert(ResultPass &&
235
207k
         "getAnalysis*() called on an analysis that was not "
236
207k
         "'required' by pass!");
237
207k
238
207k
  // Because the AnalysisType may not be a subclass of pass (for
239
207k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
207k
  // adjust the return pointer (because the class may multiply inherit, once
241
207k
  // from pass, once from AnalysisType).
242
207k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
207k
}
polly::ScopInfoWrapperPass& llvm::Pass::getAnalysisID<polly::ScopInfoWrapperPass>(void const*) const
Line
Count
Source
227
45
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
45
  assert(PI && "getAnalysis for unregistered pass!");
229
45
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
45
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
45
  // should be a small number, we just do a linear search over a (dense)
232
45
  // vector.
233
45
  Pass *ResultPass = Resolver->findImplPass(PI);
234
45
  assert(ResultPass &&
235
45
         "getAnalysis*() called on an analysis that was not "
236
45
         "'required' by pass!");
237
45
238
45
  // Because the AnalysisType may not be a subclass of pass (for
239
45
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
45
  // adjust the return pointer (because the class may multiply inherit, once
241
45
  // from pass, once from AnalysisType).
242
45
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
45
}
polly::DependenceInfoWrapperPass& llvm::Pass::getAnalysisID<polly::DependenceInfoWrapperPass>(void const*) const
Line
Count
Source
227
19
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
19
  assert(PI && "getAnalysis for unregistered pass!");
229
19
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
19
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
19
  // should be a small number, we just do a linear search over a (dense)
232
19
  // vector.
233
19
  Pass *ResultPass = Resolver->findImplPass(PI);
234
19
  assert(ResultPass &&
235
19
         "getAnalysis*() called on an analysis that was not "
236
19
         "'required' by pass!");
237
19
238
19
  // Because the AnalysisType may not be a subclass of pass (for
239
19
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
19
  // adjust the return pointer (because the class may multiply inherit, once
241
19
  // from pass, once from AnalysisType).
242
19
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
19
}
polly::ScopDetectionWrapperPass& llvm::Pass::getAnalysisID<polly::ScopDetectionWrapperPass>(void const*) const
Line
Count
Source
227
4.25k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
4.25k
  assert(PI && "getAnalysis for unregistered pass!");
229
4.25k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
4.25k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
4.25k
  // should be a small number, we just do a linear search over a (dense)
232
4.25k
  // vector.
233
4.25k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
4.25k
  assert(ResultPass &&
235
4.25k
         "getAnalysis*() called on an analysis that was not "
236
4.25k
         "'required' by pass!");
237
4.25k
238
4.25k
  // Because the AnalysisType may not be a subclass of pass (for
239
4.25k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
4.25k
  // adjust the return pointer (because the class may multiply inherit, once
241
4.25k
  // from pass, once from AnalysisType).
242
4.25k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
4.25k
}
polly::ScopInfoRegionPass& llvm::Pass::getAnalysisID<polly::ScopInfoRegionPass>(void const*) const
Line
Count
Source
227
6.56k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
6.56k
  assert(PI && "getAnalysis for unregistered pass!");
229
6.56k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
6.56k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
6.56k
  // should be a small number, we just do a linear search over a (dense)
232
6.56k
  // vector.
233
6.56k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
6.56k
  assert(ResultPass &&
235
6.56k
         "getAnalysis*() called on an analysis that was not "
236
6.56k
         "'required' by pass!");
237
6.56k
238
6.56k
  // Because the AnalysisType may not be a subclass of pass (for
239
6.56k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
6.56k
  // adjust the return pointer (because the class may multiply inherit, once
241
6.56k
  // from pass, once from AnalysisType).
242
6.56k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
6.56k
}
polly::DependenceInfo& llvm::Pass::getAnalysisID<polly::DependenceInfo>(void const*) const
Line
Count
Source
227
609
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
609
  assert(PI && "getAnalysis for unregistered pass!");
229
609
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
609
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
609
  // should be a small number, we just do a linear search over a (dense)
232
609
  // vector.
233
609
  Pass *ResultPass = Resolver->findImplPass(PI);
234
609
  assert(ResultPass &&
235
609
         "getAnalysis*() called on an analysis that was not "
236
609
         "'required' by pass!");
237
609
238
609
  // Because the AnalysisType may not be a subclass of pass (for
239
609
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
609
  // adjust the return pointer (because the class may multiply inherit, once
241
609
  // from pass, once from AnalysisType).
242
609
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
609
}
polly::IslAstInfoWrapperPass& llvm::Pass::getAnalysisID<polly::IslAstInfoWrapperPass>(void const*) const
Line
Count
Source
227
294
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
294
  assert(PI && "getAnalysis for unregistered pass!");
229
294
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
294
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
294
  // should be a small number, we just do a linear search over a (dense)
232
294
  // vector.
233
294
  Pass *ResultPass = Resolver->findImplPass(PI);
234
294
  assert(ResultPass &&
235
294
         "getAnalysis*() called on an analysis that was not "
236
294
         "'required' by pass!");
237
294
238
294
  // Because the AnalysisType may not be a subclass of pass (for
239
294
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
294
  // adjust the return pointer (because the class may multiply inherit, once
241
294
  // from pass, once from AnalysisType).
242
294
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
294
}
llvm::StackProtector& llvm::Pass::getAnalysisID<llvm::StackProtector>(void const*) const
Line
Count
Source
227
519k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
519k
  assert(PI && "getAnalysis for unregistered pass!");
229
519k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
519k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
519k
  // should be a small number, we just do a linear search over a (dense)
232
519k
  // vector.
233
519k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
519k
  assert(ResultPass &&
235
519k
         "getAnalysis*() called on an analysis that was not "
236
519k
         "'required' by pass!");
237
519k
238
519k
  // Because the AnalysisType may not be a subclass of pass (for
239
519k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
519k
  // adjust the return pointer (because the class may multiply inherit, once
241
519k
  // from pass, once from AnalysisType).
242
519k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
519k
}
llvm::Pass& llvm::Pass::getAnalysisID<llvm::Pass>(void const*) const
Line
Count
Source
227
13.2k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
13.2k
  assert(PI && "getAnalysis for unregistered pass!");
229
13.2k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
13.2k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
13.2k
  // should be a small number, we just do a linear search over a (dense)
232
13.2k
  // vector.
233
13.2k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
13.2k
  assert(ResultPass &&
235
13.2k
         "getAnalysis*() called on an analysis that was not "
236
13.2k
         "'required' by pass!");
237
13.2k
238
13.2k
  // Because the AnalysisType may not be a subclass of pass (for
239
13.2k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
13.2k
  // adjust the return pointer (because the class may multiply inherit, once
241
13.2k
  // from pass, once from AnalysisType).
242
13.2k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
13.2k
}
244
245
/// getAnalysis<AnalysisType>() - This function is used by subclasses to get
246
/// to the analysis information that they claim to use by overriding the
247
/// getAnalysisUsage function.
248
template<typename AnalysisType>
249
623k
AnalysisType &Pass::getAnalysis(Function &F) {
250
623k
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
251
623k
252
623k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
253
623k
}
llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysis<llvm::DominatorTreeWrapperPass>(llvm::Function&)
Line
Count
Source
249
587k
AnalysisType &Pass::getAnalysis(Function &F) {
250
587k
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
251
587k
252
587k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
253
587k
}
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysis<llvm::BlockFrequencyInfoWrapperPass>(llvm::Function&)
Line
Count
Source
249
36.2k
AnalysisType &Pass::getAnalysis(Function &F) {
250
36.2k
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
251
36.2k
252
36.2k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
253
36.2k
}
llvm::BranchProbabilityInfoWrapperPass& llvm::Pass::getAnalysis<llvm::BranchProbabilityInfoWrapperPass>(llvm::Function&)
Line
Count
Source
249
78
AnalysisType &Pass::getAnalysis(Function &F) {
250
78
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
251
78
252
78
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
253
78
}
llvm::PostDominatorTreeWrapperPass& llvm::Pass::getAnalysis<llvm::PostDominatorTreeWrapperPass>(llvm::Function&)
Line
Count
Source
249
51
AnalysisType &Pass::getAnalysis(Function &F) {
250
51
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
251
51
252
51
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
253
51
}
254
255
template<typename AnalysisType>
256
623k
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
257
623k
  assert(PI && "getAnalysis for unregistered pass!");
258
623k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
259
623k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
260
623k
  // should be a small number, we just do a linear search over a (dense)
261
623k
  // vector.
262
623k
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
263
623k
  assert(ResultPass && "Unable to find requested analysis info");
264
623k
265
623k
  // Because the AnalysisType may not be a subclass of pass (for
266
623k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
267
623k
  // adjust the return pointer (because the class may multiply inherit, once
268
623k
  // from pass, once from AnalysisType).
269
623k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
270
623k
}
llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysisID<llvm::DominatorTreeWrapperPass>(void const*, llvm::Function&)
Line
Count
Source
256
587k
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
257
587k
  assert(PI && "getAnalysis for unregistered pass!");
258
587k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
259
587k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
260
587k
  // should be a small number, we just do a linear search over a (dense)
261
587k
  // vector.
262
587k
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
263
587k
  assert(ResultPass && "Unable to find requested analysis info");
264
587k
265
587k
  // Because the AnalysisType may not be a subclass of pass (for
266
587k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
267
587k
  // adjust the return pointer (because the class may multiply inherit, once
268
587k
  // from pass, once from AnalysisType).
269
587k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
270
587k
}
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::BlockFrequencyInfoWrapperPass>(void const*, llvm::Function&)
Line
Count
Source
256
36.2k
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
257
36.2k
  assert(PI && "getAnalysis for unregistered pass!");
258
36.2k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
259
36.2k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
260
36.2k
  // should be a small number, we just do a linear search over a (dense)
261
36.2k
  // vector.
262
36.2k
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
263
36.2k
  assert(ResultPass && "Unable to find requested analysis info");
264
36.2k
265
36.2k
  // Because the AnalysisType may not be a subclass of pass (for
266
36.2k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
267
36.2k
  // adjust the return pointer (because the class may multiply inherit, once
268
36.2k
  // from pass, once from AnalysisType).
269
36.2k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
270
36.2k
}
llvm::BranchProbabilityInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::BranchProbabilityInfoWrapperPass>(void const*, llvm::Function&)
Line
Count
Source
256
78
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
257
78
  assert(PI && "getAnalysis for unregistered pass!");
258
78
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
259
78
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
260
78
  // should be a small number, we just do a linear search over a (dense)
261
78
  // vector.
262
78
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
263
78
  assert(ResultPass && "Unable to find requested analysis info");
264
78
265
78
  // Because the AnalysisType may not be a subclass of pass (for
266
78
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
267
78
  // adjust the return pointer (because the class may multiply inherit, once
268
78
  // from pass, once from AnalysisType).
269
78
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
270
78
}
llvm::PostDominatorTreeWrapperPass& llvm::Pass::getAnalysisID<llvm::PostDominatorTreeWrapperPass>(void const*, llvm::Function&)
Line
Count
Source
256
51
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
257
51
  assert(PI && "getAnalysis for unregistered pass!");
258
51
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
259
51
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
260
51
  // should be a small number, we just do a linear search over a (dense)
261
51
  // vector.
262
51
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
263
51
  assert(ResultPass && "Unable to find requested analysis info");
264
51
265
51
  // Because the AnalysisType may not be a subclass of pass (for
266
51
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
267
51
  // adjust the return pointer (because the class may multiply inherit, once
268
51
  // from pass, once from AnalysisType).
269
51
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
270
51
}
271
272
} // end namespace llvm
273
274
#endif // LLVM_PASSANALYSISSUPPORT_H