Coverage Report

Created: 2018-07-12 09:57

/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
8.91M
  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
17.9M
  AnalysisUsage &addRequired() {
67
17.9M
    return addRequiredID(PassClass::ID);
68
17.9M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineDominatorTree>()
Line
Count
Source
66
447k
  AnalysisUsage &addRequired() {
67
447k
    return addRequiredID(PassClass::ID);
68
447k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ReachingDefAnalysis>()
Line
Count
Source
66
29.9k
  AnalysisUsage &addRequired() {
67
29.9k
    return addRequiredID(PassClass::ID);
68
29.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineBranchProbabilityInfo>()
Line
Count
Source
66
447k
  AnalysisUsage &addRequired() {
67
447k
    return addRequiredID(PassClass::ID);
68
447k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineLoopInfo>()
Line
Count
Source
66
550k
  AnalysisUsage &addRequired() {
67
550k
    return addRequiredID(PassClass::ID);
68
550k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineTraceMetrics>()
Line
Count
Source
66
57.2k
  AnalysisUsage &addRequired() {
67
57.2k
    return addRequiredID(PassClass::ID);
68
57.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::TargetPassConfig>()
Line
Count
Source
66
260k
  AnalysisUsage &addRequired() {
67
260k
    return addRequiredID(PassClass::ID);
68
260k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LoopInfoWrapperPass>()
Line
Count
Source
66
1.98M
  AnalysisUsage &addRequired() {
67
1.98M
    return addRequiredID(PassClass::ID);
68
1.98M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ScalarEvolutionWrapperPass>()
Line
Count
Source
66
361k
  AnalysisUsage &addRequired() {
67
361k
    return addRequiredID(PassClass::ID);
68
361k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AAResultsWrapperPass>()
Line
Count
Source
66
778k
  AnalysisUsage &addRequired() {
67
778k
    return addRequiredID(PassClass::ID);
68
778k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DominatorTreeWrapperPass>()
Line
Count
Source
66
2.38M
  AnalysisUsage &addRequired() {
67
2.38M
    return addRequiredID(PassClass::ID);
68
2.38M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DivergenceAnalysis>()
Line
Count
Source
66
11.0k
  AnalysisUsage &addRequired() {
67
11.0k
    return addRequiredID(PassClass::ID);
68
11.0k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MemoryDependenceWrapperPass>()
Line
Count
Source
66
41.6k
  AnalysisUsage &addRequired() {
67
41.6k
    return addRequiredID(PassClass::ID);
68
41.6k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AMDGPUArgumentUsageInfo>()
Line
Count
Source
66
2.05k
  AnalysisUsage &addRequired() {
67
2.05k
    return addRequiredID(PassClass::ID);
68
2.05k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AMDGPUPerfHintAnalysis>()
Line
Count
Source
66
2.05k
  AnalysisUsage &addRequired() {
67
2.05k
    return addRequiredID(PassClass::ID);
68
2.05k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::TargetTransformInfoWrapperPass>()
Line
Count
Source
66
728k
  AnalysisUsage &addRequired() {
67
728k
    return addRequiredID(PassClass::ID);
68
728k
  }
Unexecuted instantiation: llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineRegionInfoPass>()
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::PostDominatorTreeWrapperPass>()
Line
Count
Source
66
28.2k
  AnalysisUsage &addRequired() {
67
28.2k
    return addRequiredID(PassClass::ID);
68
28.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachinePostDominatorTree>()
Line
Count
Source
66
91.7k
  AnalysisUsage &addRequired() {
67
91.7k
    return addRequiredID(PassClass::ID);
68
91.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveIntervals>()
Line
Count
Source
66
161k
  AnalysisUsage &addRequired() {
67
161k
    return addRequiredID(PassClass::ID);
68
161k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AssumptionCacheTracker>()
Line
Count
Source
66
1.08M
  AnalysisUsage &addRequired() {
67
1.08M
    return addRequiredID(PassClass::ID);
68
1.08M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::TargetLibraryInfoWrapperPass>()
Line
Count
Source
66
2.02M
  AnalysisUsage &addRequired() {
67
2.02M
    return addRequiredID(PassClass::ID);
68
2.02M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineDominanceFrontier>()
Line
Count
Source
66
1.65k
  AnalysisUsage &addRequired() {
67
1.65k
    return addRequiredID(PassClass::ID);
68
1.65k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::SlotIndexes>()
Line
Count
Source
66
185k
  AnalysisUsage &addRequired() {
67
185k
    return addRequiredID(PassClass::ID);
68
185k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::EdgeBundles>()
Line
Count
Source
66
41.4k
  AnalysisUsage &addRequired() {
67
41.4k
    return addRequiredID(PassClass::ID);
68
41.4k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineModuleInfo>()
Line
Count
Source
66
3.24M
  AnalysisUsage &addRequired() {
67
3.24M
    return addRequiredID(PassClass::ID);
68
3.24M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::BasicAAWrapperPass>()
Line
Count
Source
66
309k
  AnalysisUsage &addRequired() {
67
309k
    return addRequiredID(PassClass::ID);
68
309k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::BranchProbabilityInfoWrapperPass>()
Line
Count
Source
66
140k
  AnalysisUsage &addRequired() {
67
140k
    return addRequiredID(PassClass::ID);
68
140k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::CallGraphWrapperPass>()
Line
Count
Source
66
129k
  AnalysisUsage &addRequired() {
67
129k
    return addRequiredID(PassClass::ID);
68
129k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyBranchProbabilityInfoPass>()
Line
Count
Source
66
398k
  AnalysisUsage &addRequired() {
67
398k
    return addRequiredID(PassClass::ID);
68
398k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyBlockFrequencyInfoPass>()
Line
Count
Source
66
206k
  AnalysisUsage &addRequired() {
67
206k
    return addRequiredID(PassClass::ID);
68
206k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyValueInfoWrapperPass>()
Line
Count
Source
66
52.2k
  AnalysisUsage &addRequired() {
67
52.2k
    return addRequiredID(PassClass::ID);
68
52.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MemorySSAWrapperPass>()
Line
Count
Source
66
13.0k
  AnalysisUsage &addRequired() {
67
13.0k
    return addRequiredID(PassClass::ID);
68
13.0k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::BlockFrequencyInfoWrapperPass>()
Line
Count
Source
66
95.6k
  AnalysisUsage &addRequired() {
67
95.6k
    return addRequiredID(PassClass::ID);
68
95.6k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ProfileSummaryInfoWrapperPass>()
Line
Count
Source
66
55.0k
  AnalysisUsage &addRequired() {
67
55.0k
    return addRequiredID(PassClass::ID);
68
55.0k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DominanceFrontierWrapperPass>()
Line
Count
Source
66
3.36k
  AnalysisUsage &addRequired() {
67
3.36k
    return addRequiredID(PassClass::ID);
68
3.36k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::RegionInfoPass>()
Line
Count
Source
66
4.68k
  AnalysisUsage &addRequired() {
67
4.68k
    return addRequiredID(PassClass::ID);
68
4.68k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineBlockFrequencyInfo>()
Line
Count
Source
66
221k
  AnalysisUsage &addRequired() {
67
221k
    return addRequiredID(PassClass::ID);
68
221k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::GCModuleInfo>()
Line
Count
Source
66
128k
  AnalysisUsage &addRequired() {
67
128k
    return addRequiredID(PassClass::ID);
68
128k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::StackProtector>()
Line
Count
Source
66
128k
  AnalysisUsage &addRequired() {
67
128k
    return addRequiredID(PassClass::ID);
68
128k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyMachineBlockFrequencyInfoPass>()
Line
Count
Source
66
94.3k
  AnalysisUsage &addRequired() {
67
94.3k
    return addRequiredID(PassClass::ID);
68
94.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineOptimizationRemarkEmitterPass>()
Line
Count
Source
66
124k
  AnalysisUsage &addRequired() {
67
124k
    return addRequiredID(PassClass::ID);
68
124k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveDebugVariables>()
Line
Count
Source
66
60.7k
  AnalysisUsage &addRequired() {
67
60.7k
    return addRequiredID(PassClass::ID);
68
60.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveStacks>()
Line
Count
Source
66
91.2k
  AnalysisUsage &addRequired() {
67
91.2k
    return addRequiredID(PassClass::ID);
68
91.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::VirtRegMap>()
Line
Count
Source
66
60.7k
  AnalysisUsage &addRequired() {
67
60.7k
    return addRequiredID(PassClass::ID);
68
60.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveRegMatrix>()
Line
Count
Source
66
30.3k
  AnalysisUsage &addRequired() {
67
30.3k
    return addRequiredID(PassClass::ID);
68
30.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::SpillPlacement>()
Line
Count
Source
66
30.3k
  AnalysisUsage &addRequired() {
67
30.3k
    return addRequiredID(PassClass::ID);
68
30.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::PhysicalRegisterUsageInfo>()
Line
Count
Source
66
3.54k
  AnalysisUsage &addRequired() {
67
3.54k
    return addRequiredID(PassClass::ID);
68
3.54k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ModuleSummaryIndexWrapperPass>()
Line
Count
Source
66
289
  AnalysisUsage &addRequired() {
67
289
    return addRequiredID(PassClass::ID);
68
289
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::OptimizationRemarkEmitterWrapperPass>()
Line
Count
Source
66
207k
  AnalysisUsage &addRequired() {
67
207k
    return addRequiredID(PassClass::ID);
68
207k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::objcarc::ObjCARCAAWrapperPass>()
Line
Count
Source
66
30
  AnalysisUsage &addRequired() {
67
30
    return addRequiredID(PassClass::ID);
68
30
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DemandedBitsWrapperPass>()
Line
Count
Source
66
39.7k
  AnalysisUsage &addRequired() {
67
39.7k
    return addRequiredID(PassClass::ID);
68
39.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LoopAccessLegacyAnalysis>()
Line
Count
Source
66
39.2k
  AnalysisUsage &addRequired() {
67
39.2k
    return addRequiredID(PassClass::ID);
68
39.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DependenceAnalysisWrapperPass>()
Line
Count
Source
66
14
  AnalysisUsage &addRequired() {
67
14
    return addRequiredID(PassClass::ID);
68
14
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::IVUsersWrapperPass>()
Line
Count
Source
66
30.7k
  AnalysisUsage &addRequired() {
67
30.7k
    return addRequiredID(PassClass::ID);
68
30.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LCSSAVerificationPass>()
Line
Count
Source
66
254k
  AnalysisUsage &addRequired() {
67
254k
    return addRequiredID(PassClass::ID);
68
254k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<polly::ScopDetectionWrapperPass>()
Line
Count
Source
66
315
  AnalysisUsage &addRequired() {
67
315
    return addRequiredID(PassClass::ID);
68
315
  }
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
645
  AnalysisUsage &addRequired() {
67
645
    return addRequiredID(PassClass::ID);
68
645
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<polly::IslAstInfoWrapperPass>()
Line
Count
Source
66
314
  AnalysisUsage &addRequired() {
67
314
    return addRequiredID(PassClass::ID);
68
314
  }
69
70
  AnalysisUsage &addRequiredTransitiveID(char &ID);
71
  template<class PassClass>
72
1.06M
  AnalysisUsage &addRequiredTransitive() {
73
1.06M
    return addRequiredTransitiveID(PassClass::ID);
74
1.06M
  }
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
55.7k
  AnalysisUsage &addRequiredTransitive() {
73
55.7k
    return addRequiredTransitiveID(PassClass::ID);
74
55.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::ScalarEvolutionWrapperPass>()
Line
Count
Source
72
2.48k
  AnalysisUsage &addRequiredTransitive() {
73
2.48k
    return addRequiredTransitiveID(PassClass::ID);
74
2.48k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::LoopInfoWrapperPass>()
Line
Count
Source
72
181k
  AnalysisUsage &addRequiredTransitive() {
73
181k
    return addRequiredTransitiveID(PassClass::ID);
74
181k
  }
Unexecuted instantiation: llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::MemoryDependenceWrapperPass>()
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::TargetLibraryInfoWrapperPass>()
Line
Count
Source
72
222k
  AnalysisUsage &addRequiredTransitive() {
73
222k
    return addRequiredTransitiveID(PassClass::ID);
74
222k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::DominatorTreeWrapperPass>()
Line
Count
Source
72
197k
  AnalysisUsage &addRequiredTransitive() {
73
197k
    return addRequiredTransitiveID(PassClass::ID);
74
197k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::AssumptionCacheTracker>()
Line
Count
Source
72
181k
  AnalysisUsage &addRequiredTransitive() {
73
181k
    return addRequiredTransitiveID(PassClass::ID);
74
181k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::LiveIntervals>()
Line
Count
Source
72
60.7k
  AnalysisUsage &addRequiredTransitive() {
73
60.7k
    return addRequiredTransitiveID(PassClass::ID);
74
60.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::SlotIndexes>()
Line
Count
Source
72
64.9k
  AnalysisUsage &addRequiredTransitive() {
73
64.9k
    return addRequiredTransitiveID(PassClass::ID);
74
64.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::VirtRegMap>()
Line
Count
Source
72
30.3k
  AnalysisUsage &addRequiredTransitive() {
73
30.3k
    return addRequiredTransitiveID(PassClass::ID);
74
30.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::EdgeBundles>()
Line
Count
Source
72
30.3k
  AnalysisUsage &addRequiredTransitive() {
73
30.3k
    return addRequiredTransitiveID(PassClass::ID);
74
30.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::MachineLoopInfo>()
Line
Count
Source
72
30.3k
  AnalysisUsage &addRequiredTransitive() {
73
30.3k
    return addRequiredTransitiveID(PassClass::ID);
74
30.3k
  }
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.06M
  AnalysisUsage &addPreservedID(char &ID) {
84
1.06M
    Preserved.push_back(&ID);
85
1.06M
    return *this;
86
1.06M
  }
87
  /// Add the specified Pass class to the set of analyses preserved by this pass.
88
  template<class PassClass>
89
44.3M
  AnalysisUsage &addPreserved() {
90
44.3M
    Preserved.push_back(&PassClass::ID);
91
44.3M
    return *this;
92
44.3M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineDominatorTree>()
Line
Count
Source
89
372k
  AnalysisUsage &addPreserved() {
90
372k
    Preserved.push_back(&PassClass::ID);
91
372k
    return *this;
92
372k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineLoopInfo>()
Line
Count
Source
89
384k
  AnalysisUsage &addPreserved() {
90
384k
    Preserved.push_back(&PassClass::ID);
91
384k
    return *this;
92
384k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineTraceMetrics>()
Line
Count
Source
89
57.2k
  AnalysisUsage &addPreserved() {
90
57.2k
    Preserved.push_back(&PassClass::ID);
91
57.2k
    return *this;
92
57.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::DominatorTreeWrapperPass>()
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::LoopInfoWrapperPass>()
Line
Count
Source
89
3.59M
  AnalysisUsage &addPreserved() {
90
3.59M
    Preserved.push_back(&PassClass::ID);
91
3.59M
    return *this;
92
3.59M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::ScalarEvolutionWrapperPass>()
Line
Count
Source
89
3.59M
  AnalysisUsage &addPreserved() {
90
3.59M
    Preserved.push_back(&PassClass::ID);
91
3.59M
    return *this;
92
3.59M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::DivergenceAnalysis>()
Line
Count
Source
89
1.78k
  AnalysisUsage &addPreserved() {
90
1.78k
    Preserved.push_back(&PassClass::ID);
91
1.78k
    return *this;
92
1.78k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::SlotIndexes>()
Line
Count
Source
89
318k
  AnalysisUsage &addPreserved() {
90
318k
    Preserved.push_back(&PassClass::ID);
91
318k
    return *this;
92
318k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveIntervals>()
Line
Count
Source
89
193k
  AnalysisUsage &addPreserved() {
90
193k
    Preserved.push_back(&PassClass::ID);
91
193k
    return *this;
92
193k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::PostDominatorTreeWrapperPass>()
Line
Count
Source
89
13.7k
  AnalysisUsage &addPreserved() {
90
13.7k
    Preserved.push_back(&PassClass::ID);
91
13.7k
    return *this;
92
13.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::AAResultsWrapperPass>()
Line
Count
Source
89
3.76M
  AnalysisUsage &addPreserved() {
90
3.76M
    Preserved.push_back(&PassClass::ID);
91
3.76M
    return *this;
92
3.76M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::TargetLibraryInfoWrapperPass>()
Line
Count
Source
89
15.5k
  AnalysisUsage &addPreserved() {
90
15.5k
    Preserved.push_back(&PassClass::ID);
91
15.5k
    return *this;
92
15.5k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::StackProtector>()
Line
Count
Source
89
3.17M
  AnalysisUsage &addPreserved() {
90
3.17M
    Preserved.push_back(&PassClass::ID);
91
3.17M
    return *this;
92
3.17M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineModuleInfo>()
Line
Count
Source
89
3.17M
  AnalysisUsage &addPreserved() {
90
3.17M
    Preserved.push_back(&PassClass::ID);
91
3.17M
    return *this;
92
3.17M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::CallGraphWrapperPass>()
Line
Count
Source
89
76.6k
  AnalysisUsage &addPreserved() {
90
76.6k
    Preserved.push_back(&PassClass::ID);
91
76.6k
    return *this;
92
76.6k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveVariables>()
Line
Count
Source
89
98.5k
  AnalysisUsage &addPreserved() {
90
98.5k
    Preserved.push_back(&PassClass::ID);
91
98.5k
    return *this;
92
98.5k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::BasicAAWrapperPass>()
Line
Count
Source
89
3.65M
  AnalysisUsage &addPreserved() {
90
3.65M
    Preserved.push_back(&PassClass::ID);
91
3.65M
    return *this;
92
3.65M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::DominanceFrontierWrapperPass>()
Line
Count
Source
89
3.13M
  AnalysisUsage &addPreserved() {
90
3.13M
    Preserved.push_back(&PassClass::ID);
91
3.13M
    return *this;
92
3.13M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::GlobalsAAWrapperPass>()
Line
Count
Source
89
4.17M
  AnalysisUsage &addPreserved() {
90
4.17M
    Preserved.push_back(&PassClass::ID);
91
4.17M
    return *this;
92
4.17M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::IVUsersWrapperPass>()
Line
Count
Source
89
3.16M
  AnalysisUsage &addPreserved() {
90
3.16M
    Preserved.push_back(&PassClass::ID);
91
3.16M
    return *this;
92
3.16M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MemoryDependenceWrapperPass>()
Line
Count
Source
89
3.16M
  AnalysisUsage &addPreserved() {
90
3.16M
    Preserved.push_back(&PassClass::ID);
91
3.16M
    return *this;
92
3.16M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::SCEVAAWrapperPass>()
Line
Count
Source
89
3.52M
  AnalysisUsage &addPreserved() {
90
3.52M
    Preserved.push_back(&PassClass::ID);
91
3.52M
    return *this;
92
3.52M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachinePostDominatorTree>()
Line
Count
Source
89
30.5k
  AnalysisUsage &addPreserved() {
90
30.5k
    Preserved.push_back(&PassClass::ID);
91
30.5k
    return *this;
92
30.5k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveDebugVariables>()
Line
Count
Source
89
30.3k
  AnalysisUsage &addPreserved() {
90
30.3k
    Preserved.push_back(&PassClass::ID);
91
30.3k
    return *this;
92
30.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveStacks>()
Line
Count
Source
89
60.7k
  AnalysisUsage &addPreserved() {
90
60.7k
    Preserved.push_back(&PassClass::ID);
91
60.7k
    return *this;
92
60.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineBlockFrequencyInfo>()
Line
Count
Source
89
60.9k
  AnalysisUsage &addPreserved() {
90
60.9k
    Preserved.push_back(&PassClass::ID);
91
60.9k
    return *this;
92
60.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::VirtRegMap>()
Line
Count
Source
89
30.3k
  AnalysisUsage &addPreserved() {
90
30.3k
    Preserved.push_back(&PassClass::ID);
91
30.3k
    return *this;
92
30.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveRegMatrix>()
Line
Count
Source
89
30.3k
  AnalysisUsage &addPreserved() {
90
30.3k
    Preserved.push_back(&PassClass::ID);
91
30.3k
    return *this;
92
30.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MemorySSAWrapperPass>()
Line
Count
Source
89
12.9k
  AnalysisUsage &addPreserved() {
90
12.9k
    Preserved.push_back(&PassClass::ID);
91
12.9k
    return *this;
92
12.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LazyValueInfoWrapperPass>()
Line
Count
Source
89
26.4k
  AnalysisUsage &addPreserved() {
90
26.4k
    Preserved.push_back(&PassClass::ID);
91
26.4k
    return *this;
92
26.4k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::DependenceAnalysisWrapperPass>()
Line
Count
Source
89
137k
  AnalysisUsage &addPreserved() {
90
137k
    Preserved.push_back(&PassClass::ID);
91
137k
    return *this;
92
137k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LCSSAVerificationPass>()
Line
Count
Source
89
254k
  AnalysisUsage &addPreserved() {
90
254k
    Preserved.push_back(&PassClass::ID);
91
254k
    return *this;
92
254k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<polly::ScopDetectionWrapperPass>()
Line
Count
Source
89
959
  AnalysisUsage &addPreserved() {
90
959
    Preserved.push_back(&PassClass::ID);
91
959
    return *this;
92
959
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::OptimizationRemarkEmitterWrapperPass>()
Line
Count
Source
89
959
  AnalysisUsage &addPreserved() {
90
959
    Preserved.push_back(&PassClass::ID);
91
959
    return *this;
92
959
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::RegionInfoPass>()
Line
Count
Source
89
971
  AnalysisUsage &addPreserved() {
90
971
    Preserved.push_back(&PassClass::ID);
91
971
    return *this;
92
971
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<polly::ScopInfoRegionPass>()
Line
Count
Source
89
959
  AnalysisUsage &addPreserved() {
90
959
    Preserved.push_back(&PassClass::ID);
91
959
    return *this;
92
959
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::TargetTransformInfoWrapperPass>()
Line
Count
Source
89
959
  AnalysisUsage &addPreserved() {
90
959
    Preserved.push_back(&PassClass::ID);
91
959
    return *this;
92
959
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<polly::DependenceInfo>()
Line
Count
Source
89
934
  AnalysisUsage &addPreserved() {
90
934
    Preserved.push_back(&PassClass::ID);
91
934
    return *this;
92
934
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<polly::IslAstInfoWrapperPass>()
Line
Count
Source
89
314
  AnalysisUsage &addPreserved() {
90
314
    Preserved.push_back(&PassClass::ID);
91
314
    return *this;
92
314
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::GCModuleInfo>()
Line
Count
Source
89
33.8k
  AnalysisUsage &addPreserved() {
90
33.8k
    Preserved.push_back(&PassClass::ID);
91
33.8k
    return *this;
92
33.8k
  }
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
2.55M
  AnalysisUsage &addUsedIfAvailable() {
109
2.55M
    Used.push_back(&PassClass::ID);
110
2.55M
    return *this;
111
2.55M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::ScopedNoAliasAAWrapperPass>()
Line
Count
Source
108
358k
  AnalysisUsage &addUsedIfAvailable() {
109
358k
    Used.push_back(&PassClass::ID);
110
358k
    return *this;
111
358k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::TypeBasedAAWrapperPass>()
Line
Count
Source
108
358k
  AnalysisUsage &addUsedIfAvailable() {
109
358k
    Used.push_back(&PassClass::ID);
110
358k
    return *this;
111
358k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::objcarc::ObjCARCAAWrapperPass>()
Line
Count
Source
108
358k
  AnalysisUsage &addUsedIfAvailable() {
109
358k
    Used.push_back(&PassClass::ID);
110
358k
    return *this;
111
358k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::GlobalsAAWrapperPass>()
Line
Count
Source
108
358k
  AnalysisUsage &addUsedIfAvailable() {
109
358k
    Used.push_back(&PassClass::ID);
110
358k
    return *this;
111
358k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::SCEVAAWrapperPass>()
Line
Count
Source
108
309k
  AnalysisUsage &addUsedIfAvailable() {
109
309k
    Used.push_back(&PassClass::ID);
110
309k
    return *this;
111
309k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::CFLAndersAAWrapperPass>()
Line
Count
Source
108
358k
  AnalysisUsage &addUsedIfAvailable() {
109
358k
    Used.push_back(&PassClass::ID);
110
358k
    return *this;
111
358k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::CFLSteensAAWrapperPass>()
Line
Count
Source
108
358k
  AnalysisUsage &addUsedIfAvailable() {
109
358k
    Used.push_back(&PassClass::ID);
110
358k
    return *this;
111
358k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::LiveVariables>()
Line
Count
Source
108
64.2k
  AnalysisUsage &addUsedIfAvailable() {
109
64.2k
    Used.push_back(&PassClass::ID);
110
64.2k
    return *this;
111
64.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::AAResultsWrapperPass>()
Line
Count
Source
108
32.1k
  AnalysisUsage &addUsedIfAvailable() {
109
32.1k
    Used.push_back(&PassClass::ID);
110
32.1k
    return *this;
111
32.1k
  }
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
4.73M
  void setPreservesAll() { PreservesAll = true; }
122
123
  /// Determine whether a pass said it does not transform its input at all
124
177M
  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
186M
  const VectorType &getRequiredSet() const { return Required; }
136
50.6M
  const VectorType &getRequiredTransitiveSet() const {
137
50.6M
    return RequiredTransitive;
138
50.6M
  }
139
88.6M
  const VectorType &getPreservedSet() const { return Preserved; }
140
26.3M
  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
8.93M
  explicit AnalysisResolver(PMDataManager &P) : PM(P) {}
152
153
102M
  PMDataManager &getPMDataManager() { return PM; }
154
155
  /// Find pass that is implementing PI.
156
685M
  Pass *findImplPass(AnalysisID PI) {
157
685M
    Pass *ResultPass = nullptr;
158
1.60G
    for (const auto &AnalysisImpl : AnalysisImpls) {
159
1.60G
      if (AnalysisImpl.first == PI) {
160
663M
        ResultPass = AnalysisImpl.second;
161
663M
        break;
162
663M
      }
163
1.60G
    }
164
685M
    return ResultPass;
165
685M
  }
166
167
  /// Find pass that is implementing PI. Initialize pass for Function F.
168
  Pass *findImplPass(Pass *P, AnalysisID PI, Function &F);
169
170
383M
  void addAnalysisImplsPair(AnalysisID PI, Pass *P) {
171
383M
    if (findImplPass(PI) == P)
172
361M
      return;
173
21.3M
    std::pair<AnalysisID, Pass*> pir = std::make_pair(PI,P);
174
21.3M
    AnalysisImpls.push_back(pir);
175
21.3M
  }
176
177
  /// Clear cache that is used to connect a pass to the analysis (PassInfo).
178
3.72M
  void clearAnalysisImpls() {
179
3.72M
    AnalysisImpls.clear();
180
3.72M
  }
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
112M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
112M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
112M
205
112M
  const void *PI = &AnalysisType::ID;
206
112M
207
112M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
112M
  if (!ResultPass) 
return nullptr64.2M
;
209
48.7M
210
48.7M
  // Because the AnalysisType may not be a subclass of pass (for
211
48.7M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
48.7M
  // adjust the return pointer (because the class may multiply inherit, once
213
48.7M
  // from pass, once from AnalysisType).
214
48.7M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
48.7M
}
llvm::MachineLoopInfo* llvm::Pass::getAnalysisIfAvailable<llvm::MachineLoopInfo>() const
Line
Count
Source
202
1.87M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
1.87M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
1.87M
205
1.87M
  const void *PI = &AnalysisType::ID;
206
1.87M
207
1.87M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
1.87M
  if (!ResultPass) 
return nullptr353k
;
209
1.51M
210
1.51M
  // Because the AnalysisType may not be a subclass of pass (for
211
1.51M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
1.51M
  // adjust the return pointer (because the class may multiply inherit, once
213
1.51M
  // from pass, once from AnalysisType).
214
1.51M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
1.51M
}
llvm::TargetPassConfig* llvm::Pass::getAnalysisIfAvailable<llvm::TargetPassConfig>() const
Line
Count
Source
202
1.92M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
1.92M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
1.92M
205
1.92M
  const void *PI = &AnalysisType::ID;
206
1.92M
207
1.92M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
1.92M
  if (!ResultPass) 
return nullptr18
;
209
1.92M
210
1.92M
  // Because the AnalysisType may not be a subclass of pass (for
211
1.92M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
1.92M
  // adjust the return pointer (because the class may multiply inherit, once
213
1.92M
  // from pass, once from AnalysisType).
214
1.92M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
1.92M
}
llvm::AMDGPUAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::AMDGPUAAWrapperPass>() const
Line
Count
Source
202
125k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
125k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
125k
205
125k
  const void *PI = &AnalysisType::ID;
206
125k
207
125k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
125k
  if (!ResultPass) 
return nullptr0
;
209
125k
210
125k
  // Because the AnalysisType may not be a subclass of pass (for
211
125k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
125k
  // adjust the return pointer (because the class may multiply inherit, once
213
125k
  // from pass, once from AnalysisType).
214
125k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
125k
}
llvm::LiveIntervals* llvm::Pass::getAnalysisIfAvailable<llvm::LiveIntervals>() 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 nullptr2.54M
;
209
182k
210
182k
  // Because the AnalysisType may not be a subclass of pass (for
211
182k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
182k
  // adjust the return pointer (because the class may multiply inherit, once
213
182k
  // from pass, once from AnalysisType).
214
182k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
182k
}
llvm::TargetLibraryInfoWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::TargetLibraryInfoWrapperPass>() const
Line
Count
Source
202
2.88M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
2.88M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
2.88M
205
2.88M
  const void *PI = &AnalysisType::ID;
206
2.88M
207
2.88M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
2.88M
  if (!ResultPass) 
return nullptr0
;
209
2.88M
210
2.88M
  // Because the AnalysisType may not be a subclass of pass (for
211
2.88M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
2.88M
  // adjust the return pointer (because the class may multiply inherit, once
213
2.88M
  // from pass, once from AnalysisType).
214
2.88M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
2.88M
}
llvm::DominatorTreeWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::DominatorTreeWrapperPass>() const
Line
Count
Source
202
4.67M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
4.67M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
4.67M
205
4.67M
  const void *PI = &AnalysisType::ID;
206
4.67M
207
4.67M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
4.67M
  if (!ResultPass) 
return nullptr1.01M
;
209
3.66M
210
3.66M
  // Because the AnalysisType may not be a subclass of pass (for
211
3.66M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
3.66M
  // adjust the return pointer (because the class may multiply inherit, once
213
3.66M
  // from pass, once from AnalysisType).
214
3.66M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
3.66M
}
llvm::ScopedNoAliasAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::ScopedNoAliasAAWrapperPass>() const
Line
Count
Source
202
9.20M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
9.20M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
9.20M
205
9.20M
  const void *PI = &AnalysisType::ID;
206
9.20M
207
9.20M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
9.20M
  if (!ResultPass) 
return nullptr44.8k
;
209
9.15M
210
9.15M
  // Because the AnalysisType may not be a subclass of pass (for
211
9.15M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
9.15M
  // adjust the return pointer (because the class may multiply inherit, once
213
9.15M
  // from pass, once from AnalysisType).
214
9.15M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
9.15M
}
llvm::TypeBasedAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::TypeBasedAAWrapperPass>() const
Line
Count
Source
202
9.20M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
9.20M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
9.20M
205
9.20M
  const void *PI = &AnalysisType::ID;
206
9.20M
207
9.20M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
9.20M
  if (!ResultPass) 
return nullptr44.7k
;
209
9.15M
210
9.15M
  // Because the AnalysisType may not be a subclass of pass (for
211
9.15M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
9.15M
  // adjust the return pointer (because the class may multiply inherit, once
213
9.15M
  // from pass, once from AnalysisType).
214
9.15M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
9.15M
}
llvm::objcarc::ObjCARCAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::objcarc::ObjCARCAAWrapperPass>() const
Line
Count
Source
202
9.20M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
9.20M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
9.20M
205
9.20M
  const void *PI = &AnalysisType::ID;
206
9.20M
207
9.20M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
9.20M
  if (!ResultPass) 
return nullptr9.20M
;
209
699
210
699
  // Because the AnalysisType may not be a subclass of pass (for
211
699
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
699
  // adjust the return pointer (because the class may multiply inherit, once
213
699
  // from pass, once from AnalysisType).
214
699
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
699
}
llvm::GlobalsAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::GlobalsAAWrapperPass>() const
Line
Count
Source
202
9.20M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
9.20M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
9.20M
205
9.20M
  const void *PI = &AnalysisType::ID;
206
9.20M
207
9.20M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
9.20M
  if (!ResultPass) 
return nullptr1.61M
;
209
7.58M
210
7.58M
  // Because the AnalysisType may not be a subclass of pass (for
211
7.58M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
7.58M
  // adjust the return pointer (because the class may multiply inherit, once
213
7.58M
  // from pass, once from AnalysisType).
214
7.58M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
7.58M
}
llvm::SCEVAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::SCEVAAWrapperPass>() const
Line
Count
Source
202
8.14M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
8.14M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
8.14M
205
8.14M
  const void *PI = &AnalysisType::ID;
206
8.14M
207
8.14M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
8.14M
  if (!ResultPass) 
return nullptr8.14M
;
209
10
210
10
  // Because the AnalysisType may not be a subclass of pass (for
211
10
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
10
  // adjust the return pointer (because the class may multiply inherit, once
213
10
  // from pass, once from AnalysisType).
214
10
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
10
}
llvm::CFLAndersAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::CFLAndersAAWrapperPass>() const
Line
Count
Source
202
9.20M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
9.20M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
9.20M
205
9.20M
  const void *PI = &AnalysisType::ID;
206
9.20M
207
9.20M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
9.20M
  if (!ResultPass) 
return nullptr9.20M
;
209
34
210
34
  // Because the AnalysisType may not be a subclass of pass (for
211
34
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
34
  // adjust the return pointer (because the class may multiply inherit, once
213
34
  // from pass, once from AnalysisType).
214
34
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
34
}
llvm::CFLSteensAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::CFLSteensAAWrapperPass>() const
Line
Count
Source
202
9.20M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
9.20M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
9.20M
205
9.20M
  const void *PI = &AnalysisType::ID;
206
9.20M
207
9.20M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
9.20M
  if (!ResultPass) 
return nullptr9.20M
;
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
}
AliasAnalysis.cpp:(anonymous namespace)::ExternalAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<(anonymous namespace)::ExternalAAWrapperPass>() const
Line
Count
Source
202
8.14M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
8.14M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
8.14M
205
8.14M
  const void *PI = &AnalysisType::ID;
206
8.14M
207
8.14M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
8.14M
  if (!ResultPass) 
return nullptr8.01M
;
209
125k
210
125k
  // Because the AnalysisType may not be a subclass of pass (for
211
125k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
125k
  // adjust the return pointer (because the class may multiply inherit, once
213
125k
  // from pass, once from AnalysisType).
214
125k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
125k
}
llvm::LoopInfoWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::LoopInfoWrapperPass>() const
Line
Count
Source
202
10.2M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
10.2M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
10.2M
205
10.2M
  const void *PI = &AnalysisType::ID;
206
10.2M
207
10.2M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
10.2M
  if (!ResultPass) 
return nullptr4.43M
;
209
5.81M
210
5.81M
  // Because the AnalysisType may not be a subclass of pass (for
211
5.81M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
5.81M
  // adjust the return pointer (because the class may multiply inherit, once
213
5.81M
  // from pass, once from AnalysisType).
214
5.81M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
5.81M
}
llvm::TargetTransformInfoWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::TargetTransformInfoWrapperPass>() const
Line
Count
Source
202
314k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
314k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
314k
205
314k
  const void *PI = &AnalysisType::ID;
206
314k
207
314k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
314k
  if (!ResultPass) 
return nullptr0
;
209
314k
210
314k
  // Because the AnalysisType may not be a subclass of pass (for
211
314k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
314k
  // adjust the return pointer (because the class may multiply inherit, once
213
314k
  // from pass, once from AnalysisType).
214
314k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
314k
}
llvm::AssumptionCacheTracker* llvm::Pass::getAnalysisIfAvailable<llvm::AssumptionCacheTracker>() const
Line
Count
Source
202
1.27M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
1.27M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
1.27M
205
1.27M
  const void *PI = &AnalysisType::ID;
206
1.27M
207
1.27M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
1.27M
  if (!ResultPass) 
return nullptr0
;
209
1.27M
210
1.27M
  // Because the AnalysisType may not be a subclass of pass (for
211
1.27M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
1.27M
  // adjust the return pointer (because the class may multiply inherit, once
213
1.27M
  // from pass, once from AnalysisType).
214
1.27M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
1.27M
}
llvm::MachineModuleInfo* llvm::Pass::getAnalysisIfAvailable<llvm::MachineModuleInfo>() const
Line
Count
Source
202
1.09M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
1.09M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
1.09M
205
1.09M
  const void *PI = &AnalysisType::ID;
206
1.09M
207
1.09M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
1.09M
  if (!ResultPass) 
return nullptr0
;
209
1.09M
210
1.09M
  // Because the AnalysisType may not be a subclass of pass (for
211
1.09M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
1.09M
  // adjust the return pointer (because the class may multiply inherit, once
213
1.09M
  // from pass, once from AnalysisType).
214
1.09M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
1.09M
}
llvm::GCModuleInfo* llvm::Pass::getAnalysisIfAvailable<llvm::GCModuleInfo>() const
Line
Count
Source
202
96.2k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
96.2k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
96.2k
205
96.2k
  const void *PI = &AnalysisType::ID;
206
96.2k
207
96.2k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
96.2k
  if (!ResultPass) 
return nullptr0
;
209
96.2k
210
96.2k
  // Because the AnalysisType may not be a subclass of pass (for
211
96.2k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
96.2k
  // adjust the return pointer (because the class may multiply inherit, once
213
96.2k
  // from pass, once from AnalysisType).
214
96.2k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
96.2k
}
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
904k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
904k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
904k
205
904k
  const void *PI = &AnalysisType::ID;
206
904k
207
904k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
904k
  if (!ResultPass) 
return nullptr346k
;
209
557k
210
557k
  // Because the AnalysisType may not be a subclass of pass (for
211
557k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
557k
  // adjust the return pointer (because the class may multiply inherit, once
213
557k
  // from pass, once from AnalysisType).
214
557k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
557k
}
llvm::SlotIndexes* llvm::Pass::getAnalysisIfAvailable<llvm::SlotIndexes>() const
Line
Count
Source
202
1.78M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
1.78M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
1.78M
205
1.78M
  const void *PI = &AnalysisType::ID;
206
1.78M
207
1.78M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
1.78M
  if (!ResultPass) 
return nullptr1.56M
;
209
218k
210
218k
  // Because the AnalysisType may not be a subclass of pass (for
211
218k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
218k
  // adjust the return pointer (because the class may multiply inherit, once
213
218k
  // from pass, once from AnalysisType).
214
218k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
218k
}
llvm::LiveVariables* llvm::Pass::getAnalysisIfAvailable<llvm::LiveVariables>() const
Line
Count
Source
202
2.51M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
2.51M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
2.51M
205
2.51M
  const void *PI = &AnalysisType::ID;
206
2.51M
207
2.51M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
2.51M
  if (!ResultPass) 
return nullptr1.47M
;
209
1.03M
210
1.03M
  // Because the AnalysisType may not be a subclass of pass (for
211
1.03M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
1.03M
  // adjust the return pointer (because the class may multiply inherit, once
213
1.03M
  // from pass, once from AnalysisType).
214
1.03M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
1.03M
}
llvm::LiveStacks* llvm::Pass::getAnalysisIfAvailable<llvm::LiveStacks>() const
Line
Count
Source
202
1.51M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
1.51M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
1.51M
205
1.51M
  const void *PI = &AnalysisType::ID;
206
1.51M
207
1.51M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
1.51M
  if (!ResultPass) 
return nullptr1.44M
;
209
71.6k
210
71.6k
  // Because the AnalysisType may not be a subclass of pass (for
211
71.6k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
71.6k
  // adjust the return pointer (because the class may multiply inherit, once
213
71.6k
  // from pass, once from AnalysisType).
214
71.6k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
71.6k
}
llvm::AAResultsWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::AAResultsWrapperPass>() const
Line
Count
Source
202
455k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
455k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
455k
205
455k
  const void *PI = &AnalysisType::ID;
206
455k
207
455k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
455k
  if (!ResultPass) 
return nullptr6.88k
;
209
449k
210
449k
  // Because the AnalysisType may not be a subclass of pass (for
211
449k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
449k
  // adjust the return pointer (because the class may multiply inherit, once
213
449k
  // from pass, once from AnalysisType).
214
449k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
449k
}
llvm::CallGraphWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::CallGraphWrapperPass>() const
Line
Count
Source
202
14
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
14
  assert(Resolver && "Pass not resident in a PassManager object!");
204
14
205
14
  const void *PI = &AnalysisType::ID;
206
14
207
14
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
14
  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
2
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
2
  assert(Resolver && "Pass not resident in a PassManager object!");
204
2
205
2
  const void *PI = &AnalysisType::ID;
206
2
207
2
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
2
  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::ScalarEvolutionWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::ScalarEvolutionWrapperPass>() const
Line
Count
Source
202
6.77M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
6.77M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
6.77M
205
6.77M
  const void *PI = &AnalysisType::ID;
206
6.77M
207
6.77M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
6.77M
  if (!ResultPass) 
return nullptr5.31M
;
209
1.45M
210
1.45M
  // Because the AnalysisType may not be a subclass of pass (for
211
1.45M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
1.45M
  // adjust the return pointer (because the class may multiply inherit, once
213
1.45M
  // from pass, once from AnalysisType).
214
1.45M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
1.45M
}
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::DivergenceAnalysis* llvm::Pass::getAnalysisIfAvailable<llvm::DivergenceAnalysis>() const
Line
Count
Source
202
264k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
264k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
264k
205
264k
  const void *PI = &AnalysisType::ID;
206
264k
207
264k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
264k
  if (!ResultPass) 
return nullptr244k
;
209
20.0k
210
20.0k
  // Because the AnalysisType may not be a subclass of pass (for
211
20.0k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
20.0k
  // adjust the return pointer (because the class may multiply inherit, once
213
20.0k
  // from pass, once from AnalysisType).
214
20.0k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
20.0k
}
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
302M
AnalysisType &Pass::getAnalysis() const {
222
302M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
302M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
302M
}
llvm::MachineDominatorTree& llvm::Pass::getAnalysis<llvm::MachineDominatorTree>() const
Line
Count
Source
221
7.30M
AnalysisType &Pass::getAnalysis() const {
222
7.30M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
7.30M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
7.30M
}
llvm::MachineBranchProbabilityInfo& llvm::Pass::getAnalysis<llvm::MachineBranchProbabilityInfo>() const
Line
Count
Source
221
4.07M
AnalysisType &Pass::getAnalysis() const {
222
4.07M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
4.07M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
4.07M
}
llvm::MachineTraceMetrics& llvm::Pass::getAnalysis<llvm::MachineTraceMetrics>() const
Line
Count
Source
221
1.15M
AnalysisType &Pass::getAnalysis() const {
222
1.15M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.15M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.15M
}
llvm::TargetPassConfig& llvm::Pass::getAnalysis<llvm::TargetPassConfig>() const
Line
Count
Source
221
3.28M
AnalysisType &Pass::getAnalysis() const {
222
3.28M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
3.28M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
3.28M
}
llvm::LoopInfoWrapperPass& llvm::Pass::getAnalysis<llvm::LoopInfoWrapperPass>() const
Line
Count
Source
221
32.6M
AnalysisType &Pass::getAnalysis() const {
222
32.6M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
32.6M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
32.6M
}
llvm::ScalarEvolutionWrapperPass& llvm::Pass::getAnalysis<llvm::ScalarEvolutionWrapperPass>() const
Line
Count
Source
221
3.74M
AnalysisType &Pass::getAnalysis() const {
222
3.74M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
3.74M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
3.74M
}
llvm::MachineLoopInfo& llvm::Pass::getAnalysis<llvm::MachineLoopInfo>() const
Line
Count
Source
221
8.28M
AnalysisType &Pass::getAnalysis() const {
222
8.28M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
8.28M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
8.28M
}
llvm::AAResultsWrapperPass& llvm::Pass::getAnalysis<llvm::AAResultsWrapperPass>() const
Line
Count
Source
221
15.1M
AnalysisType &Pass::getAnalysis() const {
222
15.1M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
15.1M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
15.1M
}
llvm::DivergenceAnalysis& llvm::Pass::getAnalysis<llvm::DivergenceAnalysis>() const
Line
Count
Source
221
54.8k
AnalysisType &Pass::getAnalysis() const {
222
54.8k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
54.8k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
54.8k
}
llvm::MemoryDependenceWrapperPass& llvm::Pass::getAnalysis<llvm::MemoryDependenceWrapperPass>() const
Line
Count
Source
221
1.31M
AnalysisType &Pass::getAnalysis() const {
222
1.31M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.31M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.31M
}
llvm::TargetTransformInfoWrapperPass& llvm::Pass::getAnalysis<llvm::TargetTransformInfoWrapperPass>() const
Line
Count
Source
221
14.7M
AnalysisType &Pass::getAnalysis() const {
222
14.7M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
14.7M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
14.7M
}
Unexecuted instantiation: llvm::MachineRegionInfoPass& llvm::Pass::getAnalysis<llvm::MachineRegionInfoPass>() const
llvm::PostDominatorTreeWrapperPass& llvm::Pass::getAnalysis<llvm::PostDominatorTreeWrapperPass>() const
Line
Count
Source
221
564k
AnalysisType &Pass::getAnalysis() const {
222
564k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
564k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
564k
}
llvm::MachinePostDominatorTree& llvm::Pass::getAnalysis<llvm::MachinePostDominatorTree>() const
Line
Count
Source
221
936k
AnalysisType &Pass::getAnalysis() const {
222
936k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
936k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
936k
}
llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysis<llvm::DominatorTreeWrapperPass>() const
Line
Count
Source
221
41.3M
AnalysisType &Pass::getAnalysis() const {
222
41.3M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
41.3M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
41.3M
}
llvm::LiveIntervals& llvm::Pass::getAnalysis<llvm::LiveIntervals>() const
Line
Count
Source
221
3.21M
AnalysisType &Pass::getAnalysis() const {
222
3.21M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
3.21M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
3.21M
}
llvm::AMDGPUArgumentUsageInfo& llvm::Pass::getAnalysis<llvm::AMDGPUArgumentUsageInfo>() const
Line
Count
Source
221
18.3k
AnalysisType &Pass::getAnalysis() const {
222
18.3k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
18.3k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
18.3k
}
llvm::TargetLibraryInfoWrapperPass& llvm::Pass::getAnalysis<llvm::TargetLibraryInfoWrapperPass>() const
Line
Count
Source
221
42.5M
AnalysisType &Pass::getAnalysis() const {
222
42.5M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
42.5M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
42.5M
}
llvm::MachineDominanceFrontier& llvm::Pass::getAnalysis<llvm::MachineDominanceFrontier>() const
Line
Count
Source
221
6.55k
AnalysisType &Pass::getAnalysis() const {
222
6.55k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
6.55k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
6.55k
}
llvm::AssumptionCacheTracker& llvm::Pass::getAnalysis<llvm::AssumptionCacheTracker>() const
Line
Count
Source
221
30.6M
AnalysisType &Pass::getAnalysis() const {
222
30.6M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
30.6M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
30.6M
}
llvm::EdgeBundles& llvm::Pass::getAnalysis<llvm::EdgeBundles>() const
Line
Count
Source
221
895k
AnalysisType &Pass::getAnalysis() const {
222
895k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
895k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
895k
}
llvm::MachineModuleInfo& llvm::Pass::getAnalysis<llvm::MachineModuleInfo>() const
Line
Count
Source
221
45.6M
AnalysisType &Pass::getAnalysis() const {
222
45.6M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
45.6M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
45.6M
}
llvm::BasicAAWrapperPass& llvm::Pass::getAnalysis<llvm::BasicAAWrapperPass>() const
Line
Count
Source
221
8.14M
AnalysisType &Pass::getAnalysis() const {
222
8.14M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
8.14M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
8.14M
}
llvm::BranchProbabilityInfoWrapperPass& llvm::Pass::getAnalysis<llvm::BranchProbabilityInfoWrapperPass>() const
Line
Count
Source
221
2.00M
AnalysisType &Pass::getAnalysis() const {
222
2.00M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
2.00M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
2.00M
}
llvm::CallGraphWrapperPass& llvm::Pass::getAnalysis<llvm::CallGraphWrapperPass>() const
Line
Count
Source
221
2.05M
AnalysisType &Pass::getAnalysis() const {
222
2.05M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
2.05M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
2.05M
}
llvm::LazyBranchProbabilityInfoPass& llvm::Pass::getAnalysis<llvm::LazyBranchProbabilityInfoPass>() const
Line
Count
Source
221
5.38M
AnalysisType &Pass::getAnalysis() const {
222
5.38M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
5.38M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
5.38M
}
llvm::LazyValueInfoWrapperPass& llvm::Pass::getAnalysis<llvm::LazyValueInfoWrapperPass>() const
Line
Count
Source
221
1.73M
AnalysisType &Pass::getAnalysis() const {
222
1.73M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.73M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.73M
}
llvm::MemorySSAWrapperPass& llvm::Pass::getAnalysis<llvm::MemorySSAWrapperPass>() const
Line
Count
Source
221
433k
AnalysisType &Pass::getAnalysis() const {
222
433k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
433k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
433k
}
llvm::ProfileSummaryInfoWrapperPass& llvm::Pass::getAnalysis<llvm::ProfileSummaryInfoWrapperPass>() const
Line
Count
Source
221
1.23M
AnalysisType &Pass::getAnalysis() const {
222
1.23M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.23M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.23M
}
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
21.4k
AnalysisType &Pass::getAnalysis() const {
222
21.4k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
21.4k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
21.4k
}
llvm::RegionInfoPass& llvm::Pass::getAnalysis<llvm::RegionInfoPass>() const
Line
Count
Source
221
22.9k
AnalysisType &Pass::getAnalysis() const {
222
22.9k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
22.9k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
22.9k
}
llvm::MachineBlockFrequencyInfo& llvm::Pass::getAnalysis<llvm::MachineBlockFrequencyInfo>() const
Line
Count
Source
221
3.66M
AnalysisType &Pass::getAnalysis() const {
222
3.66M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
3.66M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
3.66M
}
llvm::ReachingDefAnalysis& llvm::Pass::getAnalysis<llvm::ReachingDefAnalysis>() const
Line
Count
Source
221
255k
AnalysisType &Pass::getAnalysis() const {
222
255k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
255k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
255k
}
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.34M
AnalysisType &Pass::getAnalysis() const {
222
1.34M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.34M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.34M
}
llvm::SlotIndexes& llvm::Pass::getAnalysis<llvm::SlotIndexes>() const
Line
Count
Source
221
1.81M
AnalysisType &Pass::getAnalysis() const {
222
1.81M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.81M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.81M
}
llvm::VirtRegMap& llvm::Pass::getAnalysis<llvm::VirtRegMap>() const
Line
Count
Source
221
1.34M
AnalysisType &Pass::getAnalysis() const {
222
1.34M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.34M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.34M
}
llvm::StackProtector& llvm::Pass::getAnalysis<llvm::StackProtector>() const
Line
Count
Source
221
2.60M
AnalysisType &Pass::getAnalysis() const {
222
2.60M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
2.60M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
2.60M
}
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.69M
AnalysisType &Pass::getAnalysis() const {
222
1.69M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.69M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.69M
}
llvm::LiveRegMatrix& llvm::Pass::getAnalysis<llvm::LiveRegMatrix>() const
Line
Count
Source
221
447k
AnalysisType &Pass::getAnalysis() const {
222
447k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
447k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
447k
}
llvm::SpillPlacement& llvm::Pass::getAnalysis<llvm::SpillPlacement>() const
Line
Count
Source
221
447k
AnalysisType &Pass::getAnalysis() const {
222
447k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
447k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
447k
}
llvm::LiveDebugVariables& llvm::Pass::getAnalysis<llvm::LiveDebugVariables>() const
Line
Count
Source
221
894k
AnalysisType &Pass::getAnalysis() const {
222
894k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
894k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
894k
}
llvm::PhysicalRegisterUsageInfo& llvm::Pass::getAnalysis<llvm::PhysicalRegisterUsageInfo>() const
Line
Count
Source
221
35.1k
AnalysisType &Pass::getAnalysis() const {
222
35.1k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
35.1k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
35.1k
}
llvm::ModuleSummaryIndexWrapperPass& llvm::Pass::getAnalysis<llvm::ModuleSummaryIndexWrapperPass>() const
Line
Count
Source
221
289
AnalysisType &Pass::getAnalysis() const {
222
289
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
289
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
289
}
llvm::OptimizationRemarkEmitterWrapperPass& llvm::Pass::getAnalysis<llvm::OptimizationRemarkEmitterWrapperPass>() const
Line
Count
Source
221
5.66M
AnalysisType &Pass::getAnalysis() const {
222
5.66M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
5.66M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
5.66M
}
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysis<llvm::BlockFrequencyInfoWrapperPass>() const
Line
Count
Source
221
1.33M
AnalysisType &Pass::getAnalysis() const {
222
1.33M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.33M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.33M
}
llvm::DemandedBitsWrapperPass& llvm::Pass::getAnalysis<llvm::DemandedBitsWrapperPass>() const
Line
Count
Source
221
984k
AnalysisType &Pass::getAnalysis() const {
222
984k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
984k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
984k
}
llvm::LoopAccessLegacyAnalysis& llvm::Pass::getAnalysis<llvm::LoopAccessLegacyAnalysis>() const
Line
Count
Source
221
829k
AnalysisType &Pass::getAnalysis() const {
222
829k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
829k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
829k
}
llvm::DependenceAnalysisWrapperPass& llvm::Pass::getAnalysis<llvm::DependenceAnalysisWrapperPass>() const
Line
Count
Source
221
135
AnalysisType &Pass::getAnalysis() const {
222
135
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
135
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
135
}
llvm::IVUsersWrapperPass& llvm::Pass::getAnalysis<llvm::IVUsersWrapperPass>() const
Line
Count
Source
221
202k
AnalysisType &Pass::getAnalysis() const {
222
202k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
202k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
202k
}
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.17k
AnalysisType &Pass::getAnalysis() const {
222
4.17k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
4.17k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
4.17k
}
polly::ScopInfoRegionPass& llvm::Pass::getAnalysis<polly::ScopInfoRegionPass>() const
Line
Count
Source
221
6.25k
AnalysisType &Pass::getAnalysis() const {
222
6.25k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
6.25k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
6.25k
}
polly::DependenceInfo& llvm::Pass::getAnalysis<polly::DependenceInfo>() const
Line
Count
Source
221
607
AnalysisType &Pass::getAnalysis() const {
222
607
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
607
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
607
}
polly::IslAstInfoWrapperPass& llvm::Pass::getAnalysis<polly::IslAstInfoWrapperPass>() const
Line
Count
Source
221
293
AnalysisType &Pass::getAnalysis() const {
222
293
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
293
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
293
}
225
226
template<typename AnalysisType>
227
302M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
302M
  assert(PI && "getAnalysis for unregistered pass!");
229
302M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
302M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
302M
  // should be a small number, we just do a linear search over a (dense)
232
302M
  // vector.
233
302M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
302M
  assert(ResultPass && 
235
302M
         "getAnalysis*() called on an analysis that was not "
236
302M
         "'required' by pass!");
237
302M
238
302M
  // Because the AnalysisType may not be a subclass of pass (for
239
302M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
302M
  // adjust the return pointer (because the class may multiply inherit, once
241
302M
  // from pass, once from AnalysisType).
242
302M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
302M
}
llvm::MachineDominatorTree& llvm::Pass::getAnalysisID<llvm::MachineDominatorTree>(void const*) const
Line
Count
Source
227
7.30M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
7.30M
  assert(PI && "getAnalysis for unregistered pass!");
229
7.30M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
7.30M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
7.30M
  // should be a small number, we just do a linear search over a (dense)
232
7.30M
  // vector.
233
7.30M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
7.30M
  assert(ResultPass && 
235
7.30M
         "getAnalysis*() called on an analysis that was not "
236
7.30M
         "'required' by pass!");
237
7.30M
238
7.30M
  // Because the AnalysisType may not be a subclass of pass (for
239
7.30M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
7.30M
  // adjust the return pointer (because the class may multiply inherit, once
241
7.30M
  // from pass, once from AnalysisType).
242
7.30M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
7.30M
}
llvm::MachineBranchProbabilityInfo& llvm::Pass::getAnalysisID<llvm::MachineBranchProbabilityInfo>(void const*) const
Line
Count
Source
227
4.07M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
4.07M
  assert(PI && "getAnalysis for unregistered pass!");
229
4.07M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
4.07M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
4.07M
  // should be a small number, we just do a linear search over a (dense)
232
4.07M
  // vector.
233
4.07M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
4.07M
  assert(ResultPass && 
235
4.07M
         "getAnalysis*() called on an analysis that was not "
236
4.07M
         "'required' by pass!");
237
4.07M
238
4.07M
  // Because the AnalysisType may not be a subclass of pass (for
239
4.07M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
4.07M
  // adjust the return pointer (because the class may multiply inherit, once
241
4.07M
  // from pass, once from AnalysisType).
242
4.07M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
4.07M
}
llvm::MachineTraceMetrics& llvm::Pass::getAnalysisID<llvm::MachineTraceMetrics>(void const*) const
Line
Count
Source
227
1.15M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.15M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.15M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.15M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.15M
  // should be a small number, we just do a linear search over a (dense)
232
1.15M
  // vector.
233
1.15M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.15M
  assert(ResultPass && 
235
1.15M
         "getAnalysis*() called on an analysis that was not "
236
1.15M
         "'required' by pass!");
237
1.15M
238
1.15M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.15M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.15M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.15M
  // from pass, once from AnalysisType).
242
1.15M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.15M
}
llvm::TargetPassConfig& llvm::Pass::getAnalysisID<llvm::TargetPassConfig>(void const*) const
Line
Count
Source
227
3.28M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
3.28M
  assert(PI && "getAnalysis for unregistered pass!");
229
3.28M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
3.28M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
3.28M
  // should be a small number, we just do a linear search over a (dense)
232
3.28M
  // vector.
233
3.28M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
3.28M
  assert(ResultPass && 
235
3.28M
         "getAnalysis*() called on an analysis that was not "
236
3.28M
         "'required' by pass!");
237
3.28M
238
3.28M
  // Because the AnalysisType may not be a subclass of pass (for
239
3.28M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
3.28M
  // adjust the return pointer (because the class may multiply inherit, once
241
3.28M
  // from pass, once from AnalysisType).
242
3.28M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
3.28M
}
llvm::LoopInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::LoopInfoWrapperPass>(void const*) const
Line
Count
Source
227
32.6M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
32.6M
  assert(PI && "getAnalysis for unregistered pass!");
229
32.6M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
32.6M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
32.6M
  // should be a small number, we just do a linear search over a (dense)
232
32.6M
  // vector.
233
32.6M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
32.6M
  assert(ResultPass && 
235
32.6M
         "getAnalysis*() called on an analysis that was not "
236
32.6M
         "'required' by pass!");
237
32.6M
238
32.6M
  // Because the AnalysisType may not be a subclass of pass (for
239
32.6M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
32.6M
  // adjust the return pointer (because the class may multiply inherit, once
241
32.6M
  // from pass, once from AnalysisType).
242
32.6M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
32.6M
}
llvm::ScalarEvolutionWrapperPass& llvm::Pass::getAnalysisID<llvm::ScalarEvolutionWrapperPass>(void const*) const
Line
Count
Source
227
3.74M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
3.74M
  assert(PI && "getAnalysis for unregistered pass!");
229
3.74M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
3.74M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
3.74M
  // should be a small number, we just do a linear search over a (dense)
232
3.74M
  // vector.
233
3.74M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
3.74M
  assert(ResultPass && 
235
3.74M
         "getAnalysis*() called on an analysis that was not "
236
3.74M
         "'required' by pass!");
237
3.74M
238
3.74M
  // Because the AnalysisType may not be a subclass of pass (for
239
3.74M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
3.74M
  // adjust the return pointer (because the class may multiply inherit, once
241
3.74M
  // from pass, once from AnalysisType).
242
3.74M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
3.74M
}
llvm::MachineLoopInfo& llvm::Pass::getAnalysisID<llvm::MachineLoopInfo>(void const*) const
Line
Count
Source
227
8.28M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
8.28M
  assert(PI && "getAnalysis for unregistered pass!");
229
8.28M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
8.28M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
8.28M
  // should be a small number, we just do a linear search over a (dense)
232
8.28M
  // vector.
233
8.28M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
8.28M
  assert(ResultPass && 
235
8.28M
         "getAnalysis*() called on an analysis that was not "
236
8.28M
         "'required' by pass!");
237
8.28M
238
8.28M
  // Because the AnalysisType may not be a subclass of pass (for
239
8.28M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
8.28M
  // adjust the return pointer (because the class may multiply inherit, once
241
8.28M
  // from pass, once from AnalysisType).
242
8.28M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
8.28M
}
llvm::AAResultsWrapperPass& llvm::Pass::getAnalysisID<llvm::AAResultsWrapperPass>(void const*) const
Line
Count
Source
227
15.1M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
15.1M
  assert(PI && "getAnalysis for unregistered pass!");
229
15.1M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
15.1M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
15.1M
  // should be a small number, we just do a linear search over a (dense)
232
15.1M
  // vector.
233
15.1M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
15.1M
  assert(ResultPass && 
235
15.1M
         "getAnalysis*() called on an analysis that was not "
236
15.1M
         "'required' by pass!");
237
15.1M
238
15.1M
  // Because the AnalysisType may not be a subclass of pass (for
239
15.1M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
15.1M
  // adjust the return pointer (because the class may multiply inherit, once
241
15.1M
  // from pass, once from AnalysisType).
242
15.1M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
15.1M
}
llvm::DivergenceAnalysis& llvm::Pass::getAnalysisID<llvm::DivergenceAnalysis>(void const*) const
Line
Count
Source
227
54.8k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
54.8k
  assert(PI && "getAnalysis for unregistered pass!");
229
54.8k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
54.8k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
54.8k
  // should be a small number, we just do a linear search over a (dense)
232
54.8k
  // vector.
233
54.8k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
54.8k
  assert(ResultPass && 
235
54.8k
         "getAnalysis*() called on an analysis that was not "
236
54.8k
         "'required' by pass!");
237
54.8k
238
54.8k
  // Because the AnalysisType may not be a subclass of pass (for
239
54.8k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
54.8k
  // adjust the return pointer (because the class may multiply inherit, once
241
54.8k
  // from pass, once from AnalysisType).
242
54.8k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
54.8k
}
llvm::MemoryDependenceWrapperPass& llvm::Pass::getAnalysisID<llvm::MemoryDependenceWrapperPass>(void const*) const
Line
Count
Source
227
1.31M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.31M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.31M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.31M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.31M
  // should be a small number, we just do a linear search over a (dense)
232
1.31M
  // vector.
233
1.31M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.31M
  assert(ResultPass && 
235
1.31M
         "getAnalysis*() called on an analysis that was not "
236
1.31M
         "'required' by pass!");
237
1.31M
238
1.31M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.31M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.31M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.31M
  // from pass, once from AnalysisType).
242
1.31M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.31M
}
llvm::TargetTransformInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::TargetTransformInfoWrapperPass>(void const*) const
Line
Count
Source
227
14.7M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
14.7M
  assert(PI && "getAnalysis for unregistered pass!");
229
14.7M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
14.7M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
14.7M
  // should be a small number, we just do a linear search over a (dense)
232
14.7M
  // vector.
233
14.7M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
14.7M
  assert(ResultPass && 
235
14.7M
         "getAnalysis*() called on an analysis that was not "
236
14.7M
         "'required' by pass!");
237
14.7M
238
14.7M
  // Because the AnalysisType may not be a subclass of pass (for
239
14.7M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
14.7M
  // adjust the return pointer (because the class may multiply inherit, once
241
14.7M
  // from pass, once from AnalysisType).
242
14.7M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
14.7M
}
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
564k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
564k
  assert(PI && "getAnalysis for unregistered pass!");
229
564k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
564k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
564k
  // should be a small number, we just do a linear search over a (dense)
232
564k
  // vector.
233
564k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
564k
  assert(ResultPass && 
235
564k
         "getAnalysis*() called on an analysis that was not "
236
564k
         "'required' by pass!");
237
564k
238
564k
  // Because the AnalysisType may not be a subclass of pass (for
239
564k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
564k
  // adjust the return pointer (because the class may multiply inherit, once
241
564k
  // from pass, once from AnalysisType).
242
564k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
564k
}
llvm::MachinePostDominatorTree& llvm::Pass::getAnalysisID<llvm::MachinePostDominatorTree>(void const*) const
Line
Count
Source
227
936k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
936k
  assert(PI && "getAnalysis for unregistered pass!");
229
936k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
936k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
936k
  // should be a small number, we just do a linear search over a (dense)
232
936k
  // vector.
233
936k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
936k
  assert(ResultPass && 
235
936k
         "getAnalysis*() called on an analysis that was not "
236
936k
         "'required' by pass!");
237
936k
238
936k
  // Because the AnalysisType may not be a subclass of pass (for
239
936k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
936k
  // adjust the return pointer (because the class may multiply inherit, once
241
936k
  // from pass, once from AnalysisType).
242
936k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
936k
}
llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysisID<llvm::DominatorTreeWrapperPass>(void const*) const
Line
Count
Source
227
41.3M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
41.3M
  assert(PI && "getAnalysis for unregistered pass!");
229
41.3M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
41.3M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
41.3M
  // should be a small number, we just do a linear search over a (dense)
232
41.3M
  // vector.
233
41.3M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
41.3M
  assert(ResultPass && 
235
41.3M
         "getAnalysis*() called on an analysis that was not "
236
41.3M
         "'required' by pass!");
237
41.3M
238
41.3M
  // Because the AnalysisType may not be a subclass of pass (for
239
41.3M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
41.3M
  // adjust the return pointer (because the class may multiply inherit, once
241
41.3M
  // from pass, once from AnalysisType).
242
41.3M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
41.3M
}
llvm::LiveIntervals& llvm::Pass::getAnalysisID<llvm::LiveIntervals>(void const*) const
Line
Count
Source
227
3.21M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
3.21M
  assert(PI && "getAnalysis for unregistered pass!");
229
3.21M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
3.21M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
3.21M
  // should be a small number, we just do a linear search over a (dense)
232
3.21M
  // vector.
233
3.21M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
3.21M
  assert(ResultPass && 
235
3.21M
         "getAnalysis*() called on an analysis that was not "
236
3.21M
         "'required' by pass!");
237
3.21M
238
3.21M
  // Because the AnalysisType may not be a subclass of pass (for
239
3.21M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
3.21M
  // adjust the return pointer (because the class may multiply inherit, once
241
3.21M
  // from pass, once from AnalysisType).
242
3.21M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
3.21M
}
llvm::AMDGPUArgumentUsageInfo& llvm::Pass::getAnalysisID<llvm::AMDGPUArgumentUsageInfo>(void const*) const
Line
Count
Source
227
18.3k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
18.3k
  assert(PI && "getAnalysis for unregistered pass!");
229
18.3k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
18.3k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
18.3k
  // should be a small number, we just do a linear search over a (dense)
232
18.3k
  // vector.
233
18.3k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
18.3k
  assert(ResultPass && 
235
18.3k
         "getAnalysis*() called on an analysis that was not "
236
18.3k
         "'required' by pass!");
237
18.3k
238
18.3k
  // Because the AnalysisType may not be a subclass of pass (for
239
18.3k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
18.3k
  // adjust the return pointer (because the class may multiply inherit, once
241
18.3k
  // from pass, once from AnalysisType).
242
18.3k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
18.3k
}
llvm::TargetLibraryInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::TargetLibraryInfoWrapperPass>(void const*) const
Line
Count
Source
227
42.5M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
42.5M
  assert(PI && "getAnalysis for unregistered pass!");
229
42.5M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
42.5M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
42.5M
  // should be a small number, we just do a linear search over a (dense)
232
42.5M
  // vector.
233
42.5M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
42.5M
  assert(ResultPass && 
235
42.5M
         "getAnalysis*() called on an analysis that was not "
236
42.5M
         "'required' by pass!");
237
42.5M
238
42.5M
  // Because the AnalysisType may not be a subclass of pass (for
239
42.5M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
42.5M
  // adjust the return pointer (because the class may multiply inherit, once
241
42.5M
  // from pass, once from AnalysisType).
242
42.5M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
42.5M
}
llvm::MachineDominanceFrontier& llvm::Pass::getAnalysisID<llvm::MachineDominanceFrontier>(void const*) const
Line
Count
Source
227
6.55k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
6.55k
  assert(PI && "getAnalysis for unregistered pass!");
229
6.55k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
6.55k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
6.55k
  // should be a small number, we just do a linear search over a (dense)
232
6.55k
  // vector.
233
6.55k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
6.55k
  assert(ResultPass && 
235
6.55k
         "getAnalysis*() called on an analysis that was not "
236
6.55k
         "'required' by pass!");
237
6.55k
238
6.55k
  // Because the AnalysisType may not be a subclass of pass (for
239
6.55k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
6.55k
  // adjust the return pointer (because the class may multiply inherit, once
241
6.55k
  // from pass, once from AnalysisType).
242
6.55k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
6.55k
}
llvm::AssumptionCacheTracker& llvm::Pass::getAnalysisID<llvm::AssumptionCacheTracker>(void const*) const
Line
Count
Source
227
30.6M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
30.6M
  assert(PI && "getAnalysis for unregistered pass!");
229
30.6M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
30.6M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
30.6M
  // should be a small number, we just do a linear search over a (dense)
232
30.6M
  // vector.
233
30.6M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
30.6M
  assert(ResultPass && 
235
30.6M
         "getAnalysis*() called on an analysis that was not "
236
30.6M
         "'required' by pass!");
237
30.6M
238
30.6M
  // Because the AnalysisType may not be a subclass of pass (for
239
30.6M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
30.6M
  // adjust the return pointer (because the class may multiply inherit, once
241
30.6M
  // from pass, once from AnalysisType).
242
30.6M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
30.6M
}
llvm::EdgeBundles& llvm::Pass::getAnalysisID<llvm::EdgeBundles>(void const*) const
Line
Count
Source
227
895k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
895k
  assert(PI && "getAnalysis for unregistered pass!");
229
895k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
895k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
895k
  // should be a small number, we just do a linear search over a (dense)
232
895k
  // vector.
233
895k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
895k
  assert(ResultPass && 
235
895k
         "getAnalysis*() called on an analysis that was not "
236
895k
         "'required' by pass!");
237
895k
238
895k
  // Because the AnalysisType may not be a subclass of pass (for
239
895k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
895k
  // adjust the return pointer (because the class may multiply inherit, once
241
895k
  // from pass, once from AnalysisType).
242
895k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
895k
}
llvm::MachineModuleInfo& llvm::Pass::getAnalysisID<llvm::MachineModuleInfo>(void const*) const
Line
Count
Source
227
45.6M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
45.6M
  assert(PI && "getAnalysis for unregistered pass!");
229
45.6M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
45.6M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
45.6M
  // should be a small number, we just do a linear search over a (dense)
232
45.6M
  // vector.
233
45.6M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
45.6M
  assert(ResultPass && 
235
45.6M
         "getAnalysis*() called on an analysis that was not "
236
45.6M
         "'required' by pass!");
237
45.6M
238
45.6M
  // Because the AnalysisType may not be a subclass of pass (for
239
45.6M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
45.6M
  // adjust the return pointer (because the class may multiply inherit, once
241
45.6M
  // from pass, once from AnalysisType).
242
45.6M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
45.6M
}
llvm::BasicAAWrapperPass& llvm::Pass::getAnalysisID<llvm::BasicAAWrapperPass>(void const*) const
Line
Count
Source
227
8.14M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
8.14M
  assert(PI && "getAnalysis for unregistered pass!");
229
8.14M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
8.14M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
8.14M
  // should be a small number, we just do a linear search over a (dense)
232
8.14M
  // vector.
233
8.14M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
8.14M
  assert(ResultPass && 
235
8.14M
         "getAnalysis*() called on an analysis that was not "
236
8.14M
         "'required' by pass!");
237
8.14M
238
8.14M
  // Because the AnalysisType may not be a subclass of pass (for
239
8.14M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
8.14M
  // adjust the return pointer (because the class may multiply inherit, once
241
8.14M
  // from pass, once from AnalysisType).
242
8.14M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
8.14M
}
llvm::BranchProbabilityInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::BranchProbabilityInfoWrapperPass>(void const*) const
Line
Count
Source
227
2.00M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
2.00M
  assert(PI && "getAnalysis for unregistered pass!");
229
2.00M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
2.00M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
2.00M
  // should be a small number, we just do a linear search over a (dense)
232
2.00M
  // vector.
233
2.00M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
2.00M
  assert(ResultPass && 
235
2.00M
         "getAnalysis*() called on an analysis that was not "
236
2.00M
         "'required' by pass!");
237
2.00M
238
2.00M
  // Because the AnalysisType may not be a subclass of pass (for
239
2.00M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
2.00M
  // adjust the return pointer (because the class may multiply inherit, once
241
2.00M
  // from pass, once from AnalysisType).
242
2.00M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
2.00M
}
llvm::CallGraphWrapperPass& llvm::Pass::getAnalysisID<llvm::CallGraphWrapperPass>(void const*) const
Line
Count
Source
227
2.05M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
2.05M
  assert(PI && "getAnalysis for unregistered pass!");
229
2.05M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
2.05M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
2.05M
  // should be a small number, we just do a linear search over a (dense)
232
2.05M
  // vector.
233
2.05M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
2.05M
  assert(ResultPass && 
235
2.05M
         "getAnalysis*() called on an analysis that was not "
236
2.05M
         "'required' by pass!");
237
2.05M
238
2.05M
  // Because the AnalysisType may not be a subclass of pass (for
239
2.05M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
2.05M
  // adjust the return pointer (because the class may multiply inherit, once
241
2.05M
  // from pass, once from AnalysisType).
242
2.05M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
2.05M
}
llvm::LazyBranchProbabilityInfoPass& llvm::Pass::getAnalysisID<llvm::LazyBranchProbabilityInfoPass>(void const*) const
Line
Count
Source
227
5.38M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
5.38M
  assert(PI && "getAnalysis for unregistered pass!");
229
5.38M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
5.38M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
5.38M
  // should be a small number, we just do a linear search over a (dense)
232
5.38M
  // vector.
233
5.38M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
5.38M
  assert(ResultPass && 
235
5.38M
         "getAnalysis*() called on an analysis that was not "
236
5.38M
         "'required' by pass!");
237
5.38M
238
5.38M
  // Because the AnalysisType may not be a subclass of pass (for
239
5.38M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
5.38M
  // adjust the return pointer (because the class may multiply inherit, once
241
5.38M
  // from pass, once from AnalysisType).
242
5.38M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
5.38M
}
llvm::LazyValueInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::LazyValueInfoWrapperPass>(void const*) const
Line
Count
Source
227
1.73M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.73M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.73M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.73M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.73M
  // should be a small number, we just do a linear search over a (dense)
232
1.73M
  // vector.
233
1.73M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.73M
  assert(ResultPass && 
235
1.73M
         "getAnalysis*() called on an analysis that was not "
236
1.73M
         "'required' by pass!");
237
1.73M
238
1.73M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.73M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.73M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.73M
  // from pass, once from AnalysisType).
242
1.73M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.73M
}
llvm::MemorySSAWrapperPass& llvm::Pass::getAnalysisID<llvm::MemorySSAWrapperPass>(void const*) const
Line
Count
Source
227
433k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
433k
  assert(PI && "getAnalysis for unregistered pass!");
229
433k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
433k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
433k
  // should be a small number, we just do a linear search over a (dense)
232
433k
  // vector.
233
433k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
433k
  assert(ResultPass && 
235
433k
         "getAnalysis*() called on an analysis that was not "
236
433k
         "'required' by pass!");
237
433k
238
433k
  // Because the AnalysisType may not be a subclass of pass (for
239
433k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
433k
  // adjust the return pointer (because the class may multiply inherit, once
241
433k
  // from pass, once from AnalysisType).
242
433k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
433k
}
llvm::ProfileSummaryInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::ProfileSummaryInfoWrapperPass>(void const*) const
Line
Count
Source
227
1.23M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.23M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.23M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.23M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.23M
  // should be a small number, we just do a linear search over a (dense)
232
1.23M
  // vector.
233
1.23M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.23M
  assert(ResultPass && 
235
1.23M
         "getAnalysis*() called on an analysis that was not "
236
1.23M
         "'required' by pass!");
237
1.23M
238
1.23M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.23M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.23M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.23M
  // from pass, once from AnalysisType).
242
1.23M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.23M
}
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
21.4k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
21.4k
  assert(PI && "getAnalysis for unregistered pass!");
229
21.4k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
21.4k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
21.4k
  // should be a small number, we just do a linear search over a (dense)
232
21.4k
  // vector.
233
21.4k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
21.4k
  assert(ResultPass && 
235
21.4k
         "getAnalysis*() called on an analysis that was not "
236
21.4k
         "'required' by pass!");
237
21.4k
238
21.4k
  // Because the AnalysisType may not be a subclass of pass (for
239
21.4k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
21.4k
  // adjust the return pointer (because the class may multiply inherit, once
241
21.4k
  // from pass, once from AnalysisType).
242
21.4k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
21.4k
}
llvm::RegionInfoPass& llvm::Pass::getAnalysisID<llvm::RegionInfoPass>(void const*) const
Line
Count
Source
227
22.9k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
22.9k
  assert(PI && "getAnalysis for unregistered pass!");
229
22.9k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
22.9k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
22.9k
  // should be a small number, we just do a linear search over a (dense)
232
22.9k
  // vector.
233
22.9k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
22.9k
  assert(ResultPass && 
235
22.9k
         "getAnalysis*() called on an analysis that was not "
236
22.9k
         "'required' by pass!");
237
22.9k
238
22.9k
  // Because the AnalysisType may not be a subclass of pass (for
239
22.9k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
22.9k
  // adjust the return pointer (because the class may multiply inherit, once
241
22.9k
  // from pass, once from AnalysisType).
242
22.9k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
22.9k
}
llvm::MachineBlockFrequencyInfo& llvm::Pass::getAnalysisID<llvm::MachineBlockFrequencyInfo>(void const*) const
Line
Count
Source
227
3.66M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
3.66M
  assert(PI && "getAnalysis for unregistered pass!");
229
3.66M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
3.66M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
3.66M
  // should be a small number, we just do a linear search over a (dense)
232
3.66M
  // vector.
233
3.66M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
3.66M
  assert(ResultPass && 
235
3.66M
         "getAnalysis*() called on an analysis that was not "
236
3.66M
         "'required' by pass!");
237
3.66M
238
3.66M
  // Because the AnalysisType may not be a subclass of pass (for
239
3.66M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
3.66M
  // adjust the return pointer (because the class may multiply inherit, once
241
3.66M
  // from pass, once from AnalysisType).
242
3.66M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
3.66M
}
llvm::ReachingDefAnalysis& llvm::Pass::getAnalysisID<llvm::ReachingDefAnalysis>(void const*) const
Line
Count
Source
227
255k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
255k
  assert(PI && "getAnalysis for unregistered pass!");
229
255k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
255k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
255k
  // should be a small number, we just do a linear search over a (dense)
232
255k
  // vector.
233
255k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
255k
  assert(ResultPass && 
235
255k
         "getAnalysis*() called on an analysis that was not "
236
255k
         "'required' by pass!");
237
255k
238
255k
  // Because the AnalysisType may not be a subclass of pass (for
239
255k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
255k
  // adjust the return pointer (because the class may multiply inherit, once
241
255k
  // from pass, once from AnalysisType).
242
255k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
255k
}
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.34M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.34M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.34M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.34M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.34M
  // should be a small number, we just do a linear search over a (dense)
232
1.34M
  // vector.
233
1.34M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.34M
  assert(ResultPass && 
235
1.34M
         "getAnalysis*() called on an analysis that was not "
236
1.34M
         "'required' by pass!");
237
1.34M
238
1.34M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.34M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.34M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.34M
  // from pass, once from AnalysisType).
242
1.34M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.34M
}
llvm::SlotIndexes& llvm::Pass::getAnalysisID<llvm::SlotIndexes>(void const*) const
Line
Count
Source
227
1.81M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.81M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.81M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.81M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.81M
  // should be a small number, we just do a linear search over a (dense)
232
1.81M
  // vector.
233
1.81M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.81M
  assert(ResultPass && 
235
1.81M
         "getAnalysis*() called on an analysis that was not "
236
1.81M
         "'required' by pass!");
237
1.81M
238
1.81M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.81M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.81M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.81M
  // from pass, once from AnalysisType).
242
1.81M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.81M
}
llvm::VirtRegMap& llvm::Pass::getAnalysisID<llvm::VirtRegMap>(void const*) const
Line
Count
Source
227
1.34M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.34M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.34M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.34M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.34M
  // should be a small number, we just do a linear search over a (dense)
232
1.34M
  // vector.
233
1.34M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.34M
  assert(ResultPass && 
235
1.34M
         "getAnalysis*() called on an analysis that was not "
236
1.34M
         "'required' by pass!");
237
1.34M
238
1.34M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.34M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.34M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.34M
  // from pass, once from AnalysisType).
242
1.34M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.34M
}
llvm::StackProtector& llvm::Pass::getAnalysisID<llvm::StackProtector>(void const*) const
Line
Count
Source
227
2.60M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
2.60M
  assert(PI && "getAnalysis for unregistered pass!");
229
2.60M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
2.60M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
2.60M
  // should be a small number, we just do a linear search over a (dense)
232
2.60M
  // vector.
233
2.60M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
2.60M
  assert(ResultPass && 
235
2.60M
         "getAnalysis*() called on an analysis that was not "
236
2.60M
         "'required' by pass!");
237
2.60M
238
2.60M
  // Because the AnalysisType may not be a subclass of pass (for
239
2.60M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
2.60M
  // adjust the return pointer (because the class may multiply inherit, once
241
2.60M
  // from pass, once from AnalysisType).
242
2.60M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
2.60M
}
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.69M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.69M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.69M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.69M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.69M
  // should be a small number, we just do a linear search over a (dense)
232
1.69M
  // vector.
233
1.69M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.69M
  assert(ResultPass && 
235
1.69M
         "getAnalysis*() called on an analysis that was not "
236
1.69M
         "'required' by pass!");
237
1.69M
238
1.69M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.69M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.69M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.69M
  // from pass, once from AnalysisType).
242
1.69M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.69M
}
llvm::LiveRegMatrix& llvm::Pass::getAnalysisID<llvm::LiveRegMatrix>(void const*) const
Line
Count
Source
227
447k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
447k
  assert(PI && "getAnalysis for unregistered pass!");
229
447k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
447k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
447k
  // should be a small number, we just do a linear search over a (dense)
232
447k
  // vector.
233
447k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
447k
  assert(ResultPass && 
235
447k
         "getAnalysis*() called on an analysis that was not "
236
447k
         "'required' by pass!");
237
447k
238
447k
  // Because the AnalysisType may not be a subclass of pass (for
239
447k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
447k
  // adjust the return pointer (because the class may multiply inherit, once
241
447k
  // from pass, once from AnalysisType).
242
447k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
447k
}
llvm::SpillPlacement& llvm::Pass::getAnalysisID<llvm::SpillPlacement>(void const*) const
Line
Count
Source
227
447k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
447k
  assert(PI && "getAnalysis for unregistered pass!");
229
447k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
447k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
447k
  // should be a small number, we just do a linear search over a (dense)
232
447k
  // vector.
233
447k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
447k
  assert(ResultPass && 
235
447k
         "getAnalysis*() called on an analysis that was not "
236
447k
         "'required' by pass!");
237
447k
238
447k
  // Because the AnalysisType may not be a subclass of pass (for
239
447k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
447k
  // adjust the return pointer (because the class may multiply inherit, once
241
447k
  // from pass, once from AnalysisType).
242
447k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
447k
}
llvm::LiveDebugVariables& llvm::Pass::getAnalysisID<llvm::LiveDebugVariables>(void const*) const
Line
Count
Source
227
894k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
894k
  assert(PI && "getAnalysis for unregistered pass!");
229
894k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
894k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
894k
  // should be a small number, we just do a linear search over a (dense)
232
894k
  // vector.
233
894k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
894k
  assert(ResultPass && 
235
894k
         "getAnalysis*() called on an analysis that was not "
236
894k
         "'required' by pass!");
237
894k
238
894k
  // Because the AnalysisType may not be a subclass of pass (for
239
894k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
894k
  // adjust the return pointer (because the class may multiply inherit, once
241
894k
  // from pass, once from AnalysisType).
242
894k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
894k
}
llvm::PhysicalRegisterUsageInfo& llvm::Pass::getAnalysisID<llvm::PhysicalRegisterUsageInfo>(void const*) const
Line
Count
Source
227
35.1k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
35.1k
  assert(PI && "getAnalysis for unregistered pass!");
229
35.1k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
35.1k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
35.1k
  // should be a small number, we just do a linear search over a (dense)
232
35.1k
  // vector.
233
35.1k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
35.1k
  assert(ResultPass && 
235
35.1k
         "getAnalysis*() called on an analysis that was not "
236
35.1k
         "'required' by pass!");
237
35.1k
238
35.1k
  // Because the AnalysisType may not be a subclass of pass (for
239
35.1k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
35.1k
  // adjust the return pointer (because the class may multiply inherit, once
241
35.1k
  // from pass, once from AnalysisType).
242
35.1k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
35.1k
}
llvm::ModuleSummaryIndexWrapperPass& llvm::Pass::getAnalysisID<llvm::ModuleSummaryIndexWrapperPass>(void const*) const
Line
Count
Source
227
289
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
289
  assert(PI && "getAnalysis for unregistered pass!");
229
289
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
289
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
289
  // should be a small number, we just do a linear search over a (dense)
232
289
  // vector.
233
289
  Pass *ResultPass = Resolver->findImplPass(PI);
234
289
  assert(ResultPass && 
235
289
         "getAnalysis*() called on an analysis that was not "
236
289
         "'required' by pass!");
237
289
238
289
  // Because the AnalysisType may not be a subclass of pass (for
239
289
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
289
  // adjust the return pointer (because the class may multiply inherit, once
241
289
  // from pass, once from AnalysisType).
242
289
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
289
}
llvm::OptimizationRemarkEmitterWrapperPass& llvm::Pass::getAnalysisID<llvm::OptimizationRemarkEmitterWrapperPass>(void const*) const
Line
Count
Source
227
5.66M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
5.66M
  assert(PI && "getAnalysis for unregistered pass!");
229
5.66M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
5.66M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
5.66M
  // should be a small number, we just do a linear search over a (dense)
232
5.66M
  // vector.
233
5.66M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
5.66M
  assert(ResultPass && 
235
5.66M
         "getAnalysis*() called on an analysis that was not "
236
5.66M
         "'required' by pass!");
237
5.66M
238
5.66M
  // Because the AnalysisType may not be a subclass of pass (for
239
5.66M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
5.66M
  // adjust the return pointer (because the class may multiply inherit, once
241
5.66M
  // from pass, once from AnalysisType).
242
5.66M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
5.66M
}
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::BlockFrequencyInfoWrapperPass>(void const*) const
Line
Count
Source
227
1.33M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.33M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.33M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.33M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.33M
  // should be a small number, we just do a linear search over a (dense)
232
1.33M
  // vector.
233
1.33M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.33M
  assert(ResultPass && 
235
1.33M
         "getAnalysis*() called on an analysis that was not "
236
1.33M
         "'required' by pass!");
237
1.33M
238
1.33M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.33M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.33M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.33M
  // from pass, once from AnalysisType).
242
1.33M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.33M
}
llvm::DemandedBitsWrapperPass& llvm::Pass::getAnalysisID<llvm::DemandedBitsWrapperPass>(void const*) const
Line
Count
Source
227
984k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
984k
  assert(PI && "getAnalysis for unregistered pass!");
229
984k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
984k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
984k
  // should be a small number, we just do a linear search over a (dense)
232
984k
  // vector.
233
984k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
984k
  assert(ResultPass && 
235
984k
         "getAnalysis*() called on an analysis that was not "
236
984k
         "'required' by pass!");
237
984k
238
984k
  // Because the AnalysisType may not be a subclass of pass (for
239
984k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
984k
  // adjust the return pointer (because the class may multiply inherit, once
241
984k
  // from pass, once from AnalysisType).
242
984k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
984k
}
llvm::LoopAccessLegacyAnalysis& llvm::Pass::getAnalysisID<llvm::LoopAccessLegacyAnalysis>(void const*) const
Line
Count
Source
227
829k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
829k
  assert(PI && "getAnalysis for unregistered pass!");
229
829k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
829k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
829k
  // should be a small number, we just do a linear search over a (dense)
232
829k
  // vector.
233
829k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
829k
  assert(ResultPass && 
235
829k
         "getAnalysis*() called on an analysis that was not "
236
829k
         "'required' by pass!");
237
829k
238
829k
  // Because the AnalysisType may not be a subclass of pass (for
239
829k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
829k
  // adjust the return pointer (because the class may multiply inherit, once
241
829k
  // from pass, once from AnalysisType).
242
829k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
829k
}
llvm::DependenceAnalysisWrapperPass& llvm::Pass::getAnalysisID<llvm::DependenceAnalysisWrapperPass>(void const*) const
Line
Count
Source
227
135
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
135
  assert(PI && "getAnalysis for unregistered pass!");
229
135
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
135
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
135
  // should be a small number, we just do a linear search over a (dense)
232
135
  // vector.
233
135
  Pass *ResultPass = Resolver->findImplPass(PI);
234
135
  assert(ResultPass && 
235
135
         "getAnalysis*() called on an analysis that was not "
236
135
         "'required' by pass!");
237
135
238
135
  // Because the AnalysisType may not be a subclass of pass (for
239
135
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
135
  // adjust the return pointer (because the class may multiply inherit, once
241
135
  // from pass, once from AnalysisType).
242
135
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
135
}
llvm::IVUsersWrapperPass& llvm::Pass::getAnalysisID<llvm::IVUsersWrapperPass>(void const*) const
Line
Count
Source
227
202k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
202k
  assert(PI && "getAnalysis for unregistered pass!");
229
202k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
202k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
202k
  // should be a small number, we just do a linear search over a (dense)
232
202k
  // vector.
233
202k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
202k
  assert(ResultPass && 
235
202k
         "getAnalysis*() called on an analysis that was not "
236
202k
         "'required' by pass!");
237
202k
238
202k
  // Because the AnalysisType may not be a subclass of pass (for
239
202k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
202k
  // adjust the return pointer (because the class may multiply inherit, once
241
202k
  // from pass, once from AnalysisType).
242
202k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
202k
}
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.17k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
4.17k
  assert(PI && "getAnalysis for unregistered pass!");
229
4.17k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
4.17k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
4.17k
  // should be a small number, we just do a linear search over a (dense)
232
4.17k
  // vector.
233
4.17k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
4.17k
  assert(ResultPass && 
235
4.17k
         "getAnalysis*() called on an analysis that was not "
236
4.17k
         "'required' by pass!");
237
4.17k
238
4.17k
  // Because the AnalysisType may not be a subclass of pass (for
239
4.17k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
4.17k
  // adjust the return pointer (because the class may multiply inherit, once
241
4.17k
  // from pass, once from AnalysisType).
242
4.17k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
4.17k
}
polly::ScopInfoRegionPass& llvm::Pass::getAnalysisID<polly::ScopInfoRegionPass>(void const*) const
Line
Count
Source
227
6.25k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
6.25k
  assert(PI && "getAnalysis for unregistered pass!");
229
6.25k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
6.25k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
6.25k
  // should be a small number, we just do a linear search over a (dense)
232
6.25k
  // vector.
233
6.25k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
6.25k
  assert(ResultPass && 
235
6.25k
         "getAnalysis*() called on an analysis that was not "
236
6.25k
         "'required' by pass!");
237
6.25k
238
6.25k
  // Because the AnalysisType may not be a subclass of pass (for
239
6.25k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
6.25k
  // adjust the return pointer (because the class may multiply inherit, once
241
6.25k
  // from pass, once from AnalysisType).
242
6.25k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
6.25k
}
polly::DependenceInfo& llvm::Pass::getAnalysisID<polly::DependenceInfo>(void const*) const
Line
Count
Source
227
607
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
607
  assert(PI && "getAnalysis for unregistered pass!");
229
607
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
607
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
607
  // should be a small number, we just do a linear search over a (dense)
232
607
  // vector.
233
607
  Pass *ResultPass = Resolver->findImplPass(PI);
234
607
  assert(ResultPass && 
235
607
         "getAnalysis*() called on an analysis that was not "
236
607
         "'required' by pass!");
237
607
238
607
  // Because the AnalysisType may not be a subclass of pass (for
239
607
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
607
  // adjust the return pointer (because the class may multiply inherit, once
241
607
  // from pass, once from AnalysisType).
242
607
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
607
}
polly::IslAstInfoWrapperPass& llvm::Pass::getAnalysisID<polly::IslAstInfoWrapperPass>(void const*) const
Line
Count
Source
227
293
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
293
  assert(PI && "getAnalysis for unregistered pass!");
229
293
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
293
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
293
  // should be a small number, we just do a linear search over a (dense)
232
293
  // vector.
233
293
  Pass *ResultPass = Resolver->findImplPass(PI);
234
293
  assert(ResultPass && 
235
293
         "getAnalysis*() called on an analysis that was not "
236
293
         "'required' by pass!");
237
293
238
293
  // Because the AnalysisType may not be a subclass of pass (for
239
293
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
293
  // adjust the return pointer (because the class may multiply inherit, once
241
293
  // from pass, once from AnalysisType).
242
293
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
293
}
llvm::Pass& llvm::Pass::getAnalysisID<llvm::Pass>(void const*) const
Line
Count
Source
227
11.5k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
11.5k
  assert(PI && "getAnalysis for unregistered pass!");
229
11.5k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
11.5k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
11.5k
  // should be a small number, we just do a linear search over a (dense)
232
11.5k
  // vector.
233
11.5k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
11.5k
  assert(ResultPass && 
235
11.5k
         "getAnalysis*() called on an analysis that was not "
236
11.5k
         "'required' by pass!");
237
11.5k
238
11.5k
  // Because the AnalysisType may not be a subclass of pass (for
239
11.5k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
11.5k
  // adjust the return pointer (because the class may multiply inherit, once
241
11.5k
  // from pass, once from AnalysisType).
242
11.5k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
11.5k
}
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
41.3k
AnalysisType &Pass::getAnalysis(Function &F) {
250
41.3k
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
251
41.3k
252
41.3k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
253
41.3k
}
llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysis<llvm::DominatorTreeWrapperPass>(llvm::Function&)
Line
Count
Source
249
5.77k
AnalysisType &Pass::getAnalysis(Function &F) {
250
5.77k
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
251
5.77k
252
5.77k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
253
5.77k
}
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysis<llvm::BlockFrequencyInfoWrapperPass>(llvm::Function&)
Line
Count
Source
249
35.4k
AnalysisType &Pass::getAnalysis(Function &F) {
250
35.4k
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
251
35.4k
252
35.4k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
253
35.4k
}
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
48
AnalysisType &Pass::getAnalysis(Function &F) {
250
48
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
251
48
252
48
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
253
48
}
254
255
template<typename AnalysisType>
256
41.3k
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
257
41.3k
  assert(PI && "getAnalysis for unregistered pass!");
258
41.3k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
259
41.3k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
260
41.3k
  // should be a small number, we just do a linear search over a (dense)
261
41.3k
  // vector.
262
41.3k
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
263
41.3k
  assert(ResultPass && "Unable to find requested analysis info");
264
41.3k
265
41.3k
  // Because the AnalysisType may not be a subclass of pass (for
266
41.3k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
267
41.3k
  // adjust the return pointer (because the class may multiply inherit, once
268
41.3k
  // from pass, once from AnalysisType).
269
41.3k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
270
41.3k
}
llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysisID<llvm::DominatorTreeWrapperPass>(void const*, llvm::Function&)
Line
Count
Source
256
5.77k
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
257
5.77k
  assert(PI && "getAnalysis for unregistered pass!");
258
5.77k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
259
5.77k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
260
5.77k
  // should be a small number, we just do a linear search over a (dense)
261
5.77k
  // vector.
262
5.77k
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
263
5.77k
  assert(ResultPass && "Unable to find requested analysis info");
264
5.77k
265
5.77k
  // Because the AnalysisType may not be a subclass of pass (for
266
5.77k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
267
5.77k
  // adjust the return pointer (because the class may multiply inherit, once
268
5.77k
  // from pass, once from AnalysisType).
269
5.77k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
270
5.77k
}
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::BlockFrequencyInfoWrapperPass>(void const*, llvm::Function&)
Line
Count
Source
256
35.4k
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
257
35.4k
  assert(PI && "getAnalysis for unregistered pass!");
258
35.4k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
259
35.4k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
260
35.4k
  // should be a small number, we just do a linear search over a (dense)
261
35.4k
  // vector.
262
35.4k
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
263
35.4k
  assert(ResultPass && "Unable to find requested analysis info");
264
35.4k
265
35.4k
  // Because the AnalysisType may not be a subclass of pass (for
266
35.4k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
267
35.4k
  // adjust the return pointer (because the class may multiply inherit, once
268
35.4k
  // from pass, once from AnalysisType).
269
35.4k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
270
35.4k
}
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
48
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
257
48
  assert(PI && "getAnalysis for unregistered pass!");
258
48
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
259
48
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
260
48
  // should be a small number, we just do a linear search over a (dense)
261
48
  // vector.
262
48
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
263
48
  assert(ResultPass && "Unable to find requested analysis info");
264
48
265
48
  // Because the AnalysisType may not be a subclass of pass (for
266
48
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
267
48
  // adjust the return pointer (because the class may multiply inherit, once
268
48
  // from pass, once from AnalysisType).
269
48
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
270
48
}
271
272
} // end namespace llvm
273
274
#endif // LLVM_PASSANALYSISSUPPORT_H