Coverage Report

Created: 2018-09-19 08:35

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/PassAnalysisSupport.h
Line
Count
Source (jump to first uncovered line)
1
//===- llvm/PassAnalysisSupport.h - Analysis Pass Support code --*- C++ -*-===//
2
//
3
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
//
10
// This file defines stuff that is used to define and "use" Analysis Passes.
11
// This file is automatically #included by Pass.h, so:
12
//
13
//           NO .CPP FILES SHOULD INCLUDE THIS FILE DIRECTLY
14
//
15
// Instead, #include Pass.h
16
//
17
//===----------------------------------------------------------------------===//
18
19
#ifndef LLVM_PASSANALYSISSUPPORT_H
20
#define LLVM_PASSANALYSISSUPPORT_H
21
22
#include "Pass.h"
23
#include "llvm/ADT/SmallVector.h"
24
#include "llvm/ADT/StringRef.h"
25
#include <cassert>
26
#include <utility>
27
#include <vector>
28
29
namespace llvm {
30
31
class Function;
32
class Pass;
33
class PMDataManager;
34
35
//===----------------------------------------------------------------------===//
36
/// Represent the analysis usage information of a pass.  This tracks analyses
37
/// that the pass REQUIRES (must be available when the pass runs), REQUIRES
38
/// TRANSITIVE (must be available throughout the lifetime of the pass), and
39
/// analyses that the pass PRESERVES (the pass does not invalidate the results
40
/// of these analyses).  This information is provided by a pass to the Pass
41
/// infrastructure through the getAnalysisUsage virtual function.
42
///
43
class AnalysisUsage {
44
public:
45
  using VectorType = SmallVectorImpl<AnalysisID>;
46
47
private:
48
  /// Sets of analyses required and preserved by a pass
49
  // TODO: It's not clear that SmallVector is an appropriate data structure for
50
  // this usecase.  The sizes were picked to minimize wasted space, but are
51
  // otherwise fairly meaningless.
52
  SmallVector<AnalysisID, 8> Required;
53
  SmallVector<AnalysisID, 2> RequiredTransitive;
54
  SmallVector<AnalysisID, 2> Preserved;
55
  SmallVector<AnalysisID, 0> Used;
56
  bool PreservesAll = false;
57
58
public:
59
9.29M
  AnalysisUsage() = default;
60
61
  ///@{
62
  /// Add the specified ID to the required set of the usage info for a pass.
63
  AnalysisUsage &addRequiredID(const void *ID);
64
  AnalysisUsage &addRequiredID(char &ID);
65
  template<class PassClass>
66
18.5M
  AnalysisUsage &addRequired() {
67
18.5M
    return addRequiredID(PassClass::ID);
68
18.5M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineDominatorTree>()
Line
Count
Source
66
456k
  AnalysisUsage &addRequired() {
67
456k
    return addRequiredID(PassClass::ID);
68
456k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ReachingDefAnalysis>()
Line
Count
Source
66
30.5k
  AnalysisUsage &addRequired() {
67
30.5k
    return addRequiredID(PassClass::ID);
68
30.5k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineBranchProbabilityInfo>()
Line
Count
Source
66
456k
  AnalysisUsage &addRequired() {
67
456k
    return addRequiredID(PassClass::ID);
68
456k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineLoopInfo>()
Line
Count
Source
66
561k
  AnalysisUsage &addRequired() {
67
561k
    return addRequiredID(PassClass::ID);
68
561k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineTraceMetrics>()
Line
Count
Source
66
58.2k
  AnalysisUsage &addRequired() {
67
58.2k
    return addRequiredID(PassClass::ID);
68
58.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::TargetPassConfig>()
Line
Count
Source
66
269k
  AnalysisUsage &addRequired() {
67
269k
    return addRequiredID(PassClass::ID);
68
269k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LoopInfoWrapperPass>()
Line
Count
Source
66
2.00M
  AnalysisUsage &addRequired() {
67
2.00M
    return addRequiredID(PassClass::ID);
68
2.00M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ScalarEvolutionWrapperPass>()
Line
Count
Source
66
365k
  AnalysisUsage &addRequired() {
67
365k
    return addRequiredID(PassClass::ID);
68
365k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AAResultsWrapperPass>()
Line
Count
Source
66
802k
  AnalysisUsage &addRequired() {
67
802k
    return addRequiredID(PassClass::ID);
68
802k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DominatorTreeWrapperPass>()
Line
Count
Source
66
2.50M
  AnalysisUsage &addRequired() {
67
2.50M
    return addRequiredID(PassClass::ID);
68
2.50M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LegacyDivergenceAnalysis>()
Line
Count
Source
66
11.7k
  AnalysisUsage &addRequired() {
67
11.7k
    return addRequiredID(PassClass::ID);
68
11.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MemoryDependenceWrapperPass>()
Line
Count
Source
66
55.0k
  AnalysisUsage &addRequired() {
67
55.0k
    return addRequiredID(PassClass::ID);
68
55.0k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AssumptionCacheTracker>()
Line
Count
Source
66
1.19M
  AnalysisUsage &addRequired() {
67
1.19M
    return addRequiredID(PassClass::ID);
68
1.19M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AMDGPUArgumentUsageInfo>()
Line
Count
Source
66
2.17k
  AnalysisUsage &addRequired() {
67
2.17k
    return addRequiredID(PassClass::ID);
68
2.17k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AMDGPUPerfHintAnalysis>()
Line
Count
Source
66
2.17k
  AnalysisUsage &addRequired() {
67
2.17k
    return addRequiredID(PassClass::ID);
68
2.17k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::TargetTransformInfoWrapperPass>()
Line
Count
Source
66
740k
  AnalysisUsage &addRequired() {
67
740k
    return addRequiredID(PassClass::ID);
68
740k
  }
Unexecuted instantiation: llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineRegionInfoPass>()
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::PostDominatorTreeWrapperPass>()
Line
Count
Source
66
42.1k
  AnalysisUsage &addRequired() {
67
42.1k
    return addRequiredID(PassClass::ID);
68
42.1k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachinePostDominatorTree>()
Line
Count
Source
66
93.5k
  AnalysisUsage &addRequired() {
67
93.5k
    return addRequiredID(PassClass::ID);
68
93.5k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveIntervals>()
Line
Count
Source
66
165k
  AnalysisUsage &addRequired() {
67
165k
    return addRequiredID(PassClass::ID);
68
165k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::TargetLibraryInfoWrapperPass>()
Line
Count
Source
66
2.12M
  AnalysisUsage &addRequired() {
67
2.12M
    return addRequiredID(PassClass::ID);
68
2.12M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineDominanceFrontier>()
Line
Count
Source
66
1.67k
  AnalysisUsage &addRequired() {
67
1.67k
    return addRequiredID(PassClass::ID);
68
1.67k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::SlotIndexes>()
Line
Count
Source
66
188k
  AnalysisUsage &addRequired() {
67
188k
    return addRequiredID(PassClass::ID);
68
188k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::EdgeBundles>()
Line
Count
Source
66
42.3k
  AnalysisUsage &addRequired() {
67
42.3k
    return addRequiredID(PassClass::ID);
68
42.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineModuleInfo>()
Line
Count
Source
66
3.33M
  AnalysisUsage &addRequired() {
67
3.33M
    return addRequiredID(PassClass::ID);
68
3.33M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::BasicAAWrapperPass>()
Line
Count
Source
66
326k
  AnalysisUsage &addRequired() {
67
326k
    return addRequiredID(PassClass::ID);
68
326k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::BranchProbabilityInfoWrapperPass>()
Line
Count
Source
66
142k
  AnalysisUsage &addRequired() {
67
142k
    return addRequiredID(PassClass::ID);
68
142k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::CallGraphWrapperPass>()
Line
Count
Source
66
130k
  AnalysisUsage &addRequired() {
67
130k
    return addRequiredID(PassClass::ID);
68
130k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyBranchProbabilityInfoPass>()
Line
Count
Source
66
401k
  AnalysisUsage &addRequired() {
67
401k
    return addRequiredID(PassClass::ID);
68
401k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyBlockFrequencyInfoPass>()
Line
Count
Source
66
208k
  AnalysisUsage &addRequired() {
67
208k
    return addRequiredID(PassClass::ID);
68
208k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyValueInfoWrapperPass>()
Line
Count
Source
66
52.6k
  AnalysisUsage &addRequired() {
67
52.6k
    return addRequiredID(PassClass::ID);
68
52.6k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::PhiValuesWrapperPass>()
Line
Count
Source
66
54.7k
  AnalysisUsage &addRequired() {
67
54.7k
    return addRequiredID(PassClass::ID);
68
54.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MemorySSAWrapperPass>()
Line
Count
Source
66
26.2k
  AnalysisUsage &addRequired() {
67
26.2k
    return addRequiredID(PassClass::ID);
68
26.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::BlockFrequencyInfoWrapperPass>()
Line
Count
Source
66
96.8k
  AnalysisUsage &addRequired() {
67
96.8k
    return addRequiredID(PassClass::ID);
68
96.8k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ProfileSummaryInfoWrapperPass>()
Line
Count
Source
66
56.0k
  AnalysisUsage &addRequired() {
67
56.0k
    return addRequiredID(PassClass::ID);
68
56.0k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DominanceFrontierWrapperPass>()
Line
Count
Source
66
3.47k
  AnalysisUsage &addRequired() {
67
3.47k
    return addRequiredID(PassClass::ID);
68
3.47k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::RegionInfoPass>()
Line
Count
Source
66
4.79k
  AnalysisUsage &addRequired() {
67
4.79k
    return addRequiredID(PassClass::ID);
68
4.79k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineBlockFrequencyInfo>()
Line
Count
Source
66
225k
  AnalysisUsage &addRequired() {
67
225k
    return addRequiredID(PassClass::ID);
68
225k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::GCModuleInfo>()
Line
Count
Source
66
130k
  AnalysisUsage &addRequired() {
67
130k
    return addRequiredID(PassClass::ID);
68
130k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyMachineBlockFrequencyInfoPass>()
Line
Count
Source
66
96.2k
  AnalysisUsage &addRequired() {
67
96.2k
    return addRequiredID(PassClass::ID);
68
96.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineOptimizationRemarkEmitterPass>()
Line
Count
Source
66
127k
  AnalysisUsage &addRequired() {
67
127k
    return addRequiredID(PassClass::ID);
68
127k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveDebugVariables>()
Line
Count
Source
66
61.9k
  AnalysisUsage &addRequired() {
67
61.9k
    return addRequiredID(PassClass::ID);
68
61.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveStacks>()
Line
Count
Source
66
93.0k
  AnalysisUsage &addRequired() {
67
93.0k
    return addRequiredID(PassClass::ID);
68
93.0k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::VirtRegMap>()
Line
Count
Source
66
61.9k
  AnalysisUsage &addRequired() {
67
61.9k
    return addRequiredID(PassClass::ID);
68
61.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveRegMatrix>()
Line
Count
Source
66
30.9k
  AnalysisUsage &addRequired() {
67
30.9k
    return addRequiredID(PassClass::ID);
68
30.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::SpillPlacement>()
Line
Count
Source
66
30.9k
  AnalysisUsage &addRequired() {
67
30.9k
    return addRequiredID(PassClass::ID);
68
30.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::PhysicalRegisterUsageInfo>()
Line
Count
Source
66
3.76k
  AnalysisUsage &addRequired() {
67
3.76k
    return addRequiredID(PassClass::ID);
68
3.76k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ModuleSummaryIndexWrapperPass>()
Line
Count
Source
66
292
  AnalysisUsage &addRequired() {
67
292
    return addRequiredID(PassClass::ID);
68
292
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::OptimizationRemarkEmitterWrapperPass>()
Line
Count
Source
66
209k
  AnalysisUsage &addRequired() {
67
209k
    return addRequiredID(PassClass::ID);
68
209k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::objcarc::ObjCARCAAWrapperPass>()
Line
Count
Source
66
31
  AnalysisUsage &addRequired() {
67
31
    return addRequiredID(PassClass::ID);
68
31
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DemandedBitsWrapperPass>()
Line
Count
Source
66
40.0k
  AnalysisUsage &addRequired() {
67
40.0k
    return addRequiredID(PassClass::ID);
68
40.0k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LoopAccessLegacyAnalysis>()
Line
Count
Source
66
39.5k
  AnalysisUsage &addRequired() {
67
39.5k
    return addRequiredID(PassClass::ID);
68
39.5k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DependenceAnalysisWrapperPass>()
Line
Count
Source
66
15
  AnalysisUsage &addRequired() {
67
15
    return addRequiredID(PassClass::ID);
68
15
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::IVUsersWrapperPass>()
Line
Count
Source
66
31.3k
  AnalysisUsage &addRequired() {
67
31.3k
    return addRequiredID(PassClass::ID);
68
31.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LCSSAVerificationPass>()
Line
Count
Source
66
257k
  AnalysisUsage &addRequired() {
67
257k
    return addRequiredID(PassClass::ID);
68
257k
  }
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
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::StackProtector>()
Line
Count
Source
66
41.3k
  AnalysisUsage &addRequired() {
67
41.3k
    return addRequiredID(PassClass::ID);
68
41.3k
  }
69
70
  AnalysisUsage &addRequiredTransitiveID(char &ID);
71
  template<class PassClass>
72
1.10M
  AnalysisUsage &addRequiredTransitive() {
73
1.10M
    return addRequiredTransitiveID(PassClass::ID);
74
1.10M
  }
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
69.2k
  AnalysisUsage &addRequiredTransitive() {
73
69.2k
    return addRequiredTransitiveID(PassClass::ID);
74
69.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::ScalarEvolutionWrapperPass>()
Line
Count
Source
72
2.49k
  AnalysisUsage &addRequiredTransitive() {
73
2.49k
    return addRequiredTransitiveID(PassClass::ID);
74
2.49k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::LoopInfoWrapperPass>()
Line
Count
Source
72
183k
  AnalysisUsage &addRequiredTransitive() {
73
183k
    return addRequiredTransitiveID(PassClass::ID);
74
183k
  }
Unexecuted instantiation: llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::MemoryDependenceWrapperPass>()
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::TargetLibraryInfoWrapperPass>()
Line
Count
Source
72
238k
  AnalysisUsage &addRequiredTransitive() {
73
238k
    return addRequiredTransitiveID(PassClass::ID);
74
238k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::DominatorTreeWrapperPass>()
Line
Count
Source
72
200k
  AnalysisUsage &addRequiredTransitive() {
73
200k
    return addRequiredTransitiveID(PassClass::ID);
74
200k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::AssumptionCacheTracker>()
Line
Count
Source
72
183k
  AnalysisUsage &addRequiredTransitive() {
73
183k
    return addRequiredTransitiveID(PassClass::ID);
74
183k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::LiveIntervals>()
Line
Count
Source
72
61.9k
  AnalysisUsage &addRequiredTransitive() {
73
61.9k
    return addRequiredTransitiveID(PassClass::ID);
74
61.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::SlotIndexes>()
Line
Count
Source
72
66.3k
  AnalysisUsage &addRequiredTransitive() {
73
66.3k
    return addRequiredTransitiveID(PassClass::ID);
74
66.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::VirtRegMap>()
Line
Count
Source
72
30.9k
  AnalysisUsage &addRequiredTransitive() {
73
30.9k
    return addRequiredTransitiveID(PassClass::ID);
74
30.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::EdgeBundles>()
Line
Count
Source
72
30.9k
  AnalysisUsage &addRequiredTransitive() {
73
30.9k
    return addRequiredTransitiveID(PassClass::ID);
74
30.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::MachineLoopInfo>()
Line
Count
Source
72
30.9k
  AnalysisUsage &addRequiredTransitive() {
73
30.9k
    return addRequiredTransitiveID(PassClass::ID);
74
30.9k
  }
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.08M
  AnalysisUsage &addPreservedID(char &ID) {
84
1.08M
    Preserved.push_back(&ID);
85
1.08M
    return *this;
86
1.08M
  }
87
  /// Add the specified Pass class to the set of analyses preserved by this pass.
88
  template<class PassClass>
89
42.2M
  AnalysisUsage &addPreserved() {
90
42.2M
    Preserved.push_back(&PassClass::ID);
91
42.2M
    return *this;
92
42.2M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineDominatorTree>()
Line
Count
Source
89
379k
  AnalysisUsage &addPreserved() {
90
379k
    Preserved.push_back(&PassClass::ID);
91
379k
    return *this;
92
379k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineLoopInfo>()
Line
Count
Source
89
391k
  AnalysisUsage &addPreserved() {
90
391k
    Preserved.push_back(&PassClass::ID);
91
391k
    return *this;
92
391k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineTraceMetrics>()
Line
Count
Source
89
58.2k
  AnalysisUsage &addPreserved() {
90
58.2k
    Preserved.push_back(&PassClass::ID);
91
58.2k
    return *this;
92
58.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::DominatorTreeWrapperPass>()
Line
Count
Source
89
4.10M
  AnalysisUsage &addPreserved() {
90
4.10M
    Preserved.push_back(&PassClass::ID);
91
4.10M
    return *this;
92
4.10M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LoopInfoWrapperPass>()
Line
Count
Source
89
3.68M
  AnalysisUsage &addPreserved() {
90
3.68M
    Preserved.push_back(&PassClass::ID);
91
3.68M
    return *this;
92
3.68M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::ScalarEvolutionWrapperPass>()
Line
Count
Source
89
3.67M
  AnalysisUsage &addPreserved() {
90
3.67M
    Preserved.push_back(&PassClass::ID);
91
3.67M
    return *this;
92
3.67M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LegacyDivergenceAnalysis>()
Line
Count
Source
89
1.89k
  AnalysisUsage &addPreserved() {
90
1.89k
    Preserved.push_back(&PassClass::ID);
91
1.89k
    return *this;
92
1.89k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::SlotIndexes>()
Line
Count
Source
89
325k
  AnalysisUsage &addPreserved() {
90
325k
    Preserved.push_back(&PassClass::ID);
91
325k
    return *this;
92
325k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveIntervals>()
Line
Count
Source
89
197k
  AnalysisUsage &addPreserved() {
90
197k
    Preserved.push_back(&PassClass::ID);
91
197k
    return *this;
92
197k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::PostDominatorTreeWrapperPass>()
Line
Count
Source
89
26.8k
  AnalysisUsage &addPreserved() {
90
26.8k
    Preserved.push_back(&PassClass::ID);
91
26.8k
    return *this;
92
26.8k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::AAResultsWrapperPass>()
Line
Count
Source
89
3.85M
  AnalysisUsage &addPreserved() {
90
3.85M
    Preserved.push_back(&PassClass::ID);
91
3.85M
    return *this;
92
3.85M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::TargetLibraryInfoWrapperPass>()
Line
Count
Source
89
15.7k
  AnalysisUsage &addPreserved() {
90
15.7k
    Preserved.push_back(&PassClass::ID);
91
15.7k
    return *this;
92
15.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::StackProtector>()
Line
Count
Source
89
39.5k
  AnalysisUsage &addPreserved() {
90
39.5k
    Preserved.push_back(&PassClass::ID);
91
39.5k
    return *this;
92
39.5k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineModuleInfo>()
Line
Count
Source
89
3.26M
  AnalysisUsage &addPreserved() {
90
3.26M
    Preserved.push_back(&PassClass::ID);
91
3.26M
    return *this;
92
3.26M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::CallGraphWrapperPass>()
Line
Count
Source
89
77.5k
  AnalysisUsage &addPreserved() {
90
77.5k
    Preserved.push_back(&PassClass::ID);
91
77.5k
    return *this;
92
77.5k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveVariables>()
Line
Count
Source
89
100k
  AnalysisUsage &addPreserved() {
90
100k
    Preserved.push_back(&PassClass::ID);
91
100k
    return *this;
92
100k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::BasicAAWrapperPass>()
Line
Count
Source
89
3.74M
  AnalysisUsage &addPreserved() {
90
3.74M
    Preserved.push_back(&PassClass::ID);
91
3.74M
    return *this;
92
3.74M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::DominanceFrontierWrapperPass>()
Line
Count
Source
89
3.21M
  AnalysisUsage &addPreserved() {
90
3.21M
    Preserved.push_back(&PassClass::ID);
91
3.21M
    return *this;
92
3.21M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::GlobalsAAWrapperPass>()
Line
Count
Source
89
4.28M
  AnalysisUsage &addPreserved() {
90
4.28M
    Preserved.push_back(&PassClass::ID);
91
4.28M
    return *this;
92
4.28M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::IVUsersWrapperPass>()
Line
Count
Source
89
3.24M
  AnalysisUsage &addPreserved() {
90
3.24M
    Preserved.push_back(&PassClass::ID);
91
3.24M
    return *this;
92
3.24M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MemoryDependenceWrapperPass>()
Line
Count
Source
89
3.24M
  AnalysisUsage &addPreserved() {
90
3.24M
    Preserved.push_back(&PassClass::ID);
91
3.24M
    return *this;
92
3.24M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::SCEVAAWrapperPass>()
Line
Count
Source
89
3.61M
  AnalysisUsage &addPreserved() {
90
3.61M
    Preserved.push_back(&PassClass::ID);
91
3.61M
    return *this;
92
3.61M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachinePostDominatorTree>()
Line
Count
Source
89
31.1k
  AnalysisUsage &addPreserved() {
90
31.1k
    Preserved.push_back(&PassClass::ID);
91
31.1k
    return *this;
92
31.1k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveDebugVariables>()
Line
Count
Source
89
30.9k
  AnalysisUsage &addPreserved() {
90
30.9k
    Preserved.push_back(&PassClass::ID);
91
30.9k
    return *this;
92
30.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveStacks>()
Line
Count
Source
89
61.9k
  AnalysisUsage &addPreserved() {
90
61.9k
    Preserved.push_back(&PassClass::ID);
91
61.9k
    return *this;
92
61.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineBlockFrequencyInfo>()
Line
Count
Source
89
62.1k
  AnalysisUsage &addPreserved() {
90
62.1k
    Preserved.push_back(&PassClass::ID);
91
62.1k
    return *this;
92
62.1k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::VirtRegMap>()
Line
Count
Source
89
30.9k
  AnalysisUsage &addPreserved() {
90
30.9k
    Preserved.push_back(&PassClass::ID);
91
30.9k
    return *this;
92
30.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveRegMatrix>()
Line
Count
Source
89
30.9k
  AnalysisUsage &addPreserved() {
90
30.9k
    Preserved.push_back(&PassClass::ID);
91
30.9k
    return *this;
92
30.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MemorySSAWrapperPass>()
Line
Count
Source
89
26.0k
  AnalysisUsage &addPreserved() {
90
26.0k
    Preserved.push_back(&PassClass::ID);
91
26.0k
    return *this;
92
26.0k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LazyValueInfoWrapperPass>()
Line
Count
Source
89
26.7k
  AnalysisUsage &addPreserved() {
90
26.7k
    Preserved.push_back(&PassClass::ID);
91
26.7k
    return *this;
92
26.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::DependenceAnalysisWrapperPass>()
Line
Count
Source
89
138k
  AnalysisUsage &addPreserved() {
90
138k
    Preserved.push_back(&PassClass::ID);
91
138k
    return *this;
92
138k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LCSSAVerificationPass>()
Line
Count
Source
89
257k
  AnalysisUsage &addPreserved() {
90
257k
    Preserved.push_back(&PassClass::ID);
91
257k
    return *this;
92
257k
  }
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
34.5k
  AnalysisUsage &addPreserved() {
90
34.5k
    Preserved.push_back(&PassClass::ID);
91
34.5k
    return *this;
92
34.5k
  }
93
  ///@}
94
95
  ///@{
96
  /// Add the specified ID to the set of analyses used by this pass if they are
97
  /// available..
98
0
  AnalysisUsage &addUsedIfAvailableID(const void *ID) {
99
0
    Used.push_back(ID);
100
0
    return *this;
101
0
  }
102
0
  AnalysisUsage &addUsedIfAvailableID(char &ID) {
103
0
    Used.push_back(&ID);
104
0
    return *this;
105
0
  }
106
  /// Add the specified Pass class to the set of analyses used by this pass.
107
  template<class PassClass>
108
3.02M
  AnalysisUsage &addUsedIfAvailable() {
109
3.02M
    Used.push_back(&PassClass::ID);
110
3.02M
    return *this;
111
3.02M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::ScopedNoAliasAAWrapperPass>()
Line
Count
Source
108
375k
  AnalysisUsage &addUsedIfAvailable() {
109
375k
    Used.push_back(&PassClass::ID);
110
375k
    return *this;
111
375k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::TypeBasedAAWrapperPass>()
Line
Count
Source
108
375k
  AnalysisUsage &addUsedIfAvailable() {
109
375k
    Used.push_back(&PassClass::ID);
110
375k
    return *this;
111
375k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::objcarc::ObjCARCAAWrapperPass>()
Line
Count
Source
108
375k
  AnalysisUsage &addUsedIfAvailable() {
109
375k
    Used.push_back(&PassClass::ID);
110
375k
    return *this;
111
375k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::GlobalsAAWrapperPass>()
Line
Count
Source
108
375k
  AnalysisUsage &addUsedIfAvailable() {
109
375k
    Used.push_back(&PassClass::ID);
110
375k
    return *this;
111
375k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::SCEVAAWrapperPass>()
Line
Count
Source
108
326k
  AnalysisUsage &addUsedIfAvailable() {
109
326k
    Used.push_back(&PassClass::ID);
110
326k
    return *this;
111
326k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::CFLAndersAAWrapperPass>()
Line
Count
Source
108
375k
  AnalysisUsage &addUsedIfAvailable() {
109
375k
    Used.push_back(&PassClass::ID);
110
375k
    return *this;
111
375k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::CFLSteensAAWrapperPass>()
Line
Count
Source
108
375k
  AnalysisUsage &addUsedIfAvailable() {
109
375k
    Used.push_back(&PassClass::ID);
110
375k
    return *this;
111
375k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::PhiValuesWrapperPass>()
Line
Count
Source
108
344k
  AnalysisUsage &addUsedIfAvailable() {
109
344k
    Used.push_back(&PassClass::ID);
110
344k
    return *this;
111
344k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::LiveVariables>()
Line
Count
Source
108
65.5k
  AnalysisUsage &addUsedIfAvailable() {
109
65.5k
    Used.push_back(&PassClass::ID);
110
65.5k
    return *this;
111
65.5k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::AAResultsWrapperPass>()
Line
Count
Source
108
32.7k
  AnalysisUsage &addUsedIfAvailable() {
109
32.7k
    Used.push_back(&PassClass::ID);
110
32.7k
    return *this;
111
32.7k
  }
112
  ///@}
113
114
  /// Add the Pass with the specified argument string to the set of analyses
115
  /// preserved by this pass. If no such Pass exists, do nothing. This can be
116
  /// useful when a pass is trivially preserved, but may not be linked in. Be
117
  /// careful about spelling!
118
  AnalysisUsage &addPreserved(StringRef Arg);
119
120
  /// Set by analyses that do not transform their input at all
121
5.00M
  void setPreservesAll() { PreservesAll = true; }
122
123
  /// Determine whether a pass said it does not transform its input at all
124
189M
  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
199M
  const VectorType &getRequiredSet() const { return Required; }
136
52.7M
  const VectorType &getRequiredTransitiveSet() const {
137
52.7M
    return RequiredTransitive;
138
52.7M
  }
139
92.1M
  const VectorType &getPreservedSet() const { return Preserved; }
140
27.5M
  const VectorType &getUsedSet() const { return Used; }
141
};
142
143
//===----------------------------------------------------------------------===//
144
/// AnalysisResolver - Simple interface used by Pass objects to pull all
145
/// analysis information out of pass manager that is responsible to manage
146
/// the pass.
147
///
148
class AnalysisResolver {
149
public:
150
  AnalysisResolver() = delete;
151
9.31M
  explicit AnalysisResolver(PMDataManager &P) : PM(P) {}
152
153
106M
  PMDataManager &getPMDataManager() { return PM; }
154
155
  /// Find pass that is implementing PI.
156
730M
  Pass *findImplPass(AnalysisID PI) {
157
730M
    Pass *ResultPass = nullptr;
158
1.71G
    for (const auto &AnalysisImpl : AnalysisImpls) {
159
1.71G
      if (AnalysisImpl.first == PI) {
160
708M
        ResultPass = AnalysisImpl.second;
161
708M
        break;
162
708M
      }
163
1.71G
    }
164
730M
    return ResultPass;
165
730M
  }
166
167
  /// Find pass that is implementing PI. Initialize pass for Function F.
168
  Pass *findImplPass(Pass *P, AnalysisID PI, Function &F);
169
170
407M
  void addAnalysisImplsPair(AnalysisID PI, Pass *P) {
171
407M
    if (findImplPass(PI) == P)
172
385M
      return;
173
22.0M
    std::pair<AnalysisID, Pass*> pir = std::make_pair(PI,P);
174
22.0M
    AnalysisImpls.push_back(pir);
175
22.0M
  }
176
177
  /// Clear cache that is used to connect a pass to the analysis (PassInfo).
178
4.44M
  void clearAnalysisImpls() {
179
4.44M
    AnalysisImpls.clear();
180
4.44M
  }
181
182
  /// Return analysis result or null if it doesn't exist.
183
  Pass *getAnalysisIfAvailable(AnalysisID ID, bool Direction) const;
184
185
private:
186
  /// This keeps track of which passes implements the interfaces that are
187
  /// required by the current pass (to implement getAnalysis()).
188
  std::vector<std::pair<AnalysisID, Pass *>> AnalysisImpls;
189
190
  /// PassManager that is used to resolve analysis info
191
  PMDataManager &PM;
192
};
193
194
/// getAnalysisIfAvailable<AnalysisType>() - Subclasses use this function to
195
/// get analysis information that might be around, for example to update it.
196
/// This is different than getAnalysis in that it can fail (if the analysis
197
/// results haven't been computed), so should only be used if you can handle
198
/// the case when the analysis is not available.  This method is often used by
199
/// transformation APIs to update analysis results for a pass automatically as
200
/// the transform is performed.
201
template<typename AnalysisType>
202
134M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
134M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
134M
205
134M
  const void *PI = &AnalysisType::ID;
206
134M
207
134M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
134M
  if (!ResultPass) 
return nullptr79.7M
;
209
54.3M
210
54.3M
  // Because the AnalysisType may not be a subclass of pass (for
211
54.3M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
54.3M
  // adjust the return pointer (because the class may multiply inherit, once
213
54.3M
  // from pass, once from AnalysisType).
214
54.3M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
54.3M
}
llvm::MachineLoopInfo* llvm::Pass::getAnalysisIfAvailable<llvm::MachineLoopInfo>() const
Line
Count
Source
202
1.90M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
1.90M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
1.90M
205
1.90M
  const void *PI = &AnalysisType::ID;
206
1.90M
207
1.90M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
1.90M
  if (!ResultPass) 
return nullptr367k
;
209
1.54M
210
1.54M
  // Because the AnalysisType may not be a subclass of pass (for
211
1.54M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
1.54M
  // adjust the return pointer (because the class may multiply inherit, once
213
1.54M
  // from pass, once from AnalysisType).
214
1.54M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
1.54M
}
llvm::TargetPassConfig* llvm::Pass::getAnalysisIfAvailable<llvm::TargetPassConfig>() const
Line
Count
Source
202
1.96M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
1.96M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
1.96M
205
1.96M
  const void *PI = &AnalysisType::ID;
206
1.96M
207
1.96M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
1.96M
  if (!ResultPass) 
return nullptr18
;
209
1.96M
210
1.96M
  // Because the AnalysisType may not be a subclass of pass (for
211
1.96M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
1.96M
  // adjust the return pointer (because the class may multiply inherit, once
213
1.96M
  // from pass, once from AnalysisType).
214
1.96M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
1.96M
}
llvm::AMDGPUAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::AMDGPUAAWrapperPass>() const
Line
Count
Source
202
133k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
133k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
133k
205
133k
  const void *PI = &AnalysisType::ID;
206
133k
207
133k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
133k
  if (!ResultPass) 
return nullptr0
;
209
133k
210
133k
  // Because the AnalysisType may not be a subclass of pass (for
211
133k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
133k
  // adjust the return pointer (because the class may multiply inherit, once
213
133k
  // from pass, once from AnalysisType).
214
133k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
133k
}
llvm::LiveIntervals* llvm::Pass::getAnalysisIfAvailable<llvm::LiveIntervals>() const
Line
Count
Source
202
2.86M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
2.86M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
2.86M
205
2.86M
  const void *PI = &AnalysisType::ID;
206
2.86M
207
2.86M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
2.86M
  if (!ResultPass) 
return nullptr2.66M
;
209
194k
210
194k
  // Because the AnalysisType may not be a subclass of pass (for
211
194k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
194k
  // adjust the return pointer (because the class may multiply inherit, once
213
194k
  // from pass, once from AnalysisType).
214
194k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
194k
}
llvm::TargetLibraryInfoWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::TargetLibraryInfoWrapperPass>() const
Line
Count
Source
202
2.95M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
2.95M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
2.95M
205
2.95M
  const void *PI = &AnalysisType::ID;
206
2.95M
207
2.95M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
2.95M
  if (!ResultPass) 
return nullptr0
;
209
2.95M
210
2.95M
  // Because the AnalysisType may not be a subclass of pass (for
211
2.95M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
2.95M
  // adjust the return pointer (because the class may multiply inherit, once
213
2.95M
  // from pass, once from AnalysisType).
214
2.95M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
2.95M
}
llvm::DominatorTreeWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::DominatorTreeWrapperPass>() const
Line
Count
Source
202
5.78M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
5.78M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
5.78M
205
5.78M
  const void *PI = &AnalysisType::ID;
206
5.78M
207
5.78M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
5.78M
  if (!ResultPass) 
return nullptr1.50M
;
209
4.28M
210
4.28M
  // Because the AnalysisType may not be a subclass of pass (for
211
4.28M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
4.28M
  // adjust the return pointer (because the class may multiply inherit, once
213
4.28M
  // from pass, once from AnalysisType).
214
4.28M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
4.28M
}
llvm::ScopedNoAliasAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::ScopedNoAliasAAWrapperPass>() const
Line
Count
Source
202
10.0M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
10.0M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
10.0M
205
10.0M
  const void *PI = &AnalysisType::ID;
206
10.0M
207
10.0M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
10.0M
  if (!ResultPass) 
return nullptr47.1k
;
209
10.0M
210
10.0M
  // Because the AnalysisType may not be a subclass of pass (for
211
10.0M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
10.0M
  // adjust the return pointer (because the class may multiply inherit, once
213
10.0M
  // from pass, once from AnalysisType).
214
10.0M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
10.0M
}
llvm::TypeBasedAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::TypeBasedAAWrapperPass>() const
Line
Count
Source
202
10.0M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
10.0M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
10.0M
205
10.0M
  const void *PI = &AnalysisType::ID;
206
10.0M
207
10.0M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
10.0M
  if (!ResultPass) 
return nullptr46.9k
;
209
10.0M
210
10.0M
  // Because the AnalysisType may not be a subclass of pass (for
211
10.0M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
10.0M
  // adjust the return pointer (because the class may multiply inherit, once
213
10.0M
  // from pass, once from AnalysisType).
214
10.0M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
10.0M
}
llvm::objcarc::ObjCARCAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::objcarc::ObjCARCAAWrapperPass>() const
Line
Count
Source
202
10.0M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
10.0M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
10.0M
205
10.0M
  const void *PI = &AnalysisType::ID;
206
10.0M
207
10.0M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
10.0M
  if (!ResultPass) 
return nullptr10.0M
;
209
1.00k
210
1.00k
  // Because the AnalysisType may not be a subclass of pass (for
211
1.00k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
1.00k
  // adjust the return pointer (because the class may multiply inherit, once
213
1.00k
  // from pass, once from AnalysisType).
214
1.00k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
1.00k
}
llvm::GlobalsAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::GlobalsAAWrapperPass>() const
Line
Count
Source
202
10.0M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
10.0M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
10.0M
205
10.0M
  const void *PI = &AnalysisType::ID;
206
10.0M
207
10.0M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
10.0M
  if (!ResultPass) 
return nullptr1.66M
;
209
8.41M
210
8.41M
  // Because the AnalysisType may not be a subclass of pass (for
211
8.41M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
8.41M
  // adjust the return pointer (because the class may multiply inherit, once
213
8.41M
  // from pass, once from AnalysisType).
214
8.41M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
8.41M
}
llvm::SCEVAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::SCEVAAWrapperPass>() const
Line
Count
Source
202
8.93M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
8.93M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
8.93M
205
8.93M
  const void *PI = &AnalysisType::ID;
206
8.93M
207
8.93M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
8.93M
  if (!ResultPass) 
return nullptr8.93M
;
209
6
210
6
  // Because the AnalysisType may not be a subclass of pass (for
211
6
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
6
  // adjust the return pointer (because the class may multiply inherit, once
213
6
  // from pass, once from AnalysisType).
214
6
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
6
}
llvm::CFLAndersAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::CFLAndersAAWrapperPass>() const
Line
Count
Source
202
10.0M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
10.0M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
10.0M
205
10.0M
  const void *PI = &AnalysisType::ID;
206
10.0M
207
10.0M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
10.0M
  if (!ResultPass) 
return nullptr10.0M
;
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::CFLSteensAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::CFLSteensAAWrapperPass>() const
Line
Count
Source
202
10.0M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
10.0M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
10.0M
205
10.0M
  const void *PI = &AnalysisType::ID;
206
10.0M
207
10.0M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
10.0M
  if (!ResultPass) 
return nullptr10.0M
;
209
63
210
63
  // Because the AnalysisType may not be a subclass of pass (for
211
63
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
63
  // adjust the return pointer (because the class may multiply inherit, once
213
63
  // from pass, once from AnalysisType).
214
63
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
63
}
AliasAnalysis.cpp:(anonymous namespace)::ExternalAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<(anonymous namespace)::ExternalAAWrapperPass>() const
Line
Count
Source
202
8.93M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
8.93M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
8.93M
205
8.93M
  const void *PI = &AnalysisType::ID;
206
8.93M
207
8.93M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
8.93M
  if (!ResultPass) 
return nullptr8.80M
;
209
133k
210
133k
  // Because the AnalysisType may not be a subclass of pass (for
211
133k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
133k
  // adjust the return pointer (because the class may multiply inherit, once
213
133k
  // from pass, once from AnalysisType).
214
133k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
133k
}
llvm::LoopInfoWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::LoopInfoWrapperPass>() const
Line
Count
Source
202
12.9M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
12.9M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
12.9M
205
12.9M
  const void *PI = &AnalysisType::ID;
206
12.9M
207
12.9M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
12.9M
  if (!ResultPass) 
return nullptr6.00M
;
209
6.95M
210
6.95M
  // Because the AnalysisType may not be a subclass of pass (for
211
6.95M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
6.95M
  // adjust the return pointer (because the class may multiply inherit, once
213
6.95M
  // from pass, once from AnalysisType).
214
6.95M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
6.95M
}
llvm::PhiValuesWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::PhiValuesWrapperPass>() const
Line
Count
Source
202
9.11M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
9.11M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
9.11M
205
9.11M
  const void *PI = &AnalysisType::ID;
206
9.11M
207
9.11M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
9.11M
  if (!ResultPass) 
return nullptr8.18M
;
209
927k
210
927k
  // Because the AnalysisType may not be a subclass of pass (for
211
927k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
927k
  // adjust the return pointer (because the class may multiply inherit, once
213
927k
  // from pass, once from AnalysisType).
214
927k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
927k
}
llvm::TargetTransformInfoWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::TargetTransformInfoWrapperPass>() const
Line
Count
Source
202
328k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
328k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
328k
205
328k
  const void *PI = &AnalysisType::ID;
206
328k
207
328k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
328k
  if (!ResultPass) 
return nullptr0
;
209
328k
210
328k
  // Because the AnalysisType may not be a subclass of pass (for
211
328k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
328k
  // adjust the return pointer (because the class may multiply inherit, once
213
328k
  // from pass, once from AnalysisType).
214
328k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
328k
}
llvm::AssumptionCacheTracker* llvm::Pass::getAnalysisIfAvailable<llvm::AssumptionCacheTracker>() const
Line
Count
Source
202
1.32M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
1.32M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
1.32M
205
1.32M
  const void *PI = &AnalysisType::ID;
206
1.32M
207
1.32M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
1.32M
  if (!ResultPass) 
return nullptr0
;
209
1.32M
210
1.32M
  // Because the AnalysisType may not be a subclass of pass (for
211
1.32M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
1.32M
  // adjust the return pointer (because the class may multiply inherit, once
213
1.32M
  // from pass, once from AnalysisType).
214
1.32M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
1.32M
}
llvm::MachineModuleInfo* llvm::Pass::getAnalysisIfAvailable<llvm::MachineModuleInfo>() const
Line
Count
Source
202
1.11M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
1.11M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
1.11M
205
1.11M
  const void *PI = &AnalysisType::ID;
206
1.11M
207
1.11M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
1.11M
  if (!ResultPass) 
return nullptr0
;
209
1.11M
210
1.11M
  // Because the AnalysisType may not be a subclass of pass (for
211
1.11M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
1.11M
  // adjust the return pointer (because the class may multiply inherit, once
213
1.11M
  // from pass, once from AnalysisType).
214
1.11M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
1.11M
}
llvm::GCModuleInfo* llvm::Pass::getAnalysisIfAvailable<llvm::GCModuleInfo>() const
Line
Count
Source
202
98.1k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
98.1k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
98.1k
205
98.1k
  const void *PI = &AnalysisType::ID;
206
98.1k
207
98.1k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
98.1k
  if (!ResultPass) 
return nullptr0
;
209
98.1k
210
98.1k
  // Because the AnalysisType may not be a subclass of pass (for
211
98.1k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
98.1k
  // adjust the return pointer (because the class may multiply inherit, once
213
98.1k
  // from pass, once from AnalysisType).
214
98.1k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
98.1k
}
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
926k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
926k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
926k
205
926k
  const void *PI = &AnalysisType::ID;
206
926k
207
926k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
926k
  if (!ResultPass) 
return nullptr359k
;
209
566k
210
566k
  // Because the AnalysisType may not be a subclass of pass (for
211
566k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
566k
  // adjust the return pointer (because the class may multiply inherit, once
213
566k
  // from pass, once from AnalysisType).
214
566k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
566k
}
llvm::SlotIndexes* llvm::Pass::getAnalysisIfAvailable<llvm::SlotIndexes>() const
Line
Count
Source
202
1.89M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
1.89M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
1.89M
205
1.89M
  const void *PI = &AnalysisType::ID;
206
1.89M
207
1.89M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
1.89M
  if (!ResultPass) 
return nullptr1.66M
;
209
232k
210
232k
  // Because the AnalysisType may not be a subclass of pass (for
211
232k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
232k
  // adjust the return pointer (because the class may multiply inherit, once
213
232k
  // from pass, once from AnalysisType).
214
232k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
232k
}
llvm::LiveVariables* llvm::Pass::getAnalysisIfAvailable<llvm::LiveVariables>() const
Line
Count
Source
202
2.63M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
2.63M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
2.63M
205
2.63M
  const void *PI = &AnalysisType::ID;
206
2.63M
207
2.63M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
2.63M
  if (!ResultPass) 
return nullptr1.57M
;
209
1.05M
210
1.05M
  // Because the AnalysisType may not be a subclass of pass (for
211
1.05M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
1.05M
  // adjust the return pointer (because the class may multiply inherit, once
213
1.05M
  // from pass, once from AnalysisType).
214
1.05M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
1.05M
}
llvm::LiveStacks* llvm::Pass::getAnalysisIfAvailable<llvm::LiveStacks>() const
Line
Count
Source
202
1.62M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
1.62M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
1.62M
205
1.62M
  const void *PI = &AnalysisType::ID;
206
1.62M
207
1.62M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
1.62M
  if (!ResultPass) 
return nullptr1.54M
;
209
76.0k
210
76.0k
  // Because the AnalysisType may not be a subclass of pass (for
211
76.0k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
76.0k
  // adjust the return pointer (because the class may multiply inherit, once
213
76.0k
  // from pass, once from AnalysisType).
214
76.0k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
76.0k
}
llvm::AAResultsWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::AAResultsWrapperPass>() const
Line
Count
Source
202
464k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
464k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
464k
205
464k
  const void *PI = &AnalysisType::ID;
206
464k
207
464k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
464k
  if (!ResultPass) 
return nullptr7.01k
;
209
457k
210
457k
  // Because the AnalysisType may not be a subclass of pass (for
211
457k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
457k
  // adjust the return pointer (because the class may multiply inherit, once
213
457k
  // from pass, once from AnalysisType).
214
457k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
457k
}
llvm::CallGraphWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::CallGraphWrapperPass>() const
Line
Count
Source
202
13
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
13
  assert(Resolver && "Pass not resident in a PassManager object!");
204
13
205
13
  const void *PI = &AnalysisType::ID;
206
13
207
13
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
13
  if (!ResultPass) return nullptr;
209
0
210
0
  // Because the AnalysisType may not be a subclass of pass (for
211
0
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
0
  // adjust the return pointer (because the class may multiply inherit, once
213
0
  // from pass, once from AnalysisType).
214
0
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
0
}
llvm::PostDominatorTreeWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::PostDominatorTreeWrapperPass>() const
Line
Count
Source
202
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 (
!ResultPass455k
) return nullptr;
209
18.4E
210
18.4E
  // Because the AnalysisType may not be a subclass of pass (for
211
18.4E
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
18.4E
  // adjust the return pointer (because the class may multiply inherit, once
213
18.4E
  // from pass, once from AnalysisType).
214
18.4E
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
18.4E
}
llvm::ScalarEvolutionWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::ScalarEvolutionWrapperPass>() const
Line
Count
Source
202
6.96M
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
6.96M
  assert(Resolver && "Pass not resident in a PassManager object!");
204
6.96M
205
6.96M
  const void *PI = &AnalysisType::ID;
206
6.96M
207
6.96M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
6.96M
  if (!ResultPass) 
return nullptr5.48M
;
209
1.48M
210
1.48M
  // Because the AnalysisType may not be a subclass of pass (for
211
1.48M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
1.48M
  // adjust the return pointer (because the class may multiply inherit, once
213
1.48M
  // from pass, once from AnalysisType).
214
1.48M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
1.48M
}
llvm::RegionInfoPass* llvm::Pass::getAnalysisIfAvailable<llvm::RegionInfoPass>() const
Line
Count
Source
202
13
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
13
  assert(Resolver && "Pass not resident in a PassManager object!");
204
13
205
13
  const void *PI = &AnalysisType::ID;
206
13
207
13
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
13
  if (!ResultPass) return nullptr;
209
0
210
0
  // Because the AnalysisType may not be a subclass of pass (for
211
0
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
0
  // adjust the return pointer (because the class may multiply inherit, once
213
0
  // from pass, once from AnalysisType).
214
0
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
0
}
Unexecuted instantiation: llvm::MachineBranchProbabilityInfo* llvm::Pass::getAnalysisIfAvailable<llvm::MachineBranchProbabilityInfo>() const
llvm::LegacyDivergenceAnalysis* llvm::Pass::getAnalysisIfAvailable<llvm::LegacyDivergenceAnalysis>() const
Line
Count
Source
202
272k
AnalysisType *Pass::getAnalysisIfAvailable() const {
203
272k
  assert(Resolver && "Pass not resident in a PassManager object!");
204
272k
205
272k
  const void *PI = &AnalysisType::ID;
206
272k
207
272k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
208
272k
  if (!ResultPass) 
return nullptr250k
;
209
21.7k
210
21.7k
  // Because the AnalysisType may not be a subclass of pass (for
211
21.7k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
212
21.7k
  // adjust the return pointer (because the class may multiply inherit, once
213
21.7k
  // from pass, once from AnalysisType).
214
21.7k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
215
21.7k
}
216
217
/// getAnalysis<AnalysisType>() - This function is used by subclasses to get
218
/// to the analysis information that they claim to use by overriding the
219
/// getAnalysisUsage function.
220
template<typename AnalysisType>
221
323M
AnalysisType &Pass::getAnalysis() const {
222
323M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
323M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
323M
}
llvm::MachineDominatorTree& llvm::Pass::getAnalysis<llvm::MachineDominatorTree>() const
Line
Count
Source
221
7.46M
AnalysisType &Pass::getAnalysis() const {
222
7.46M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
7.46M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
7.46M
}
llvm::MachineBranchProbabilityInfo& llvm::Pass::getAnalysis<llvm::MachineBranchProbabilityInfo>() const
Line
Count
Source
221
4.15M
AnalysisType &Pass::getAnalysis() const {
222
4.15M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
4.15M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
4.15M
}
llvm::MachineTraceMetrics& llvm::Pass::getAnalysis<llvm::MachineTraceMetrics>() const
Line
Count
Source
221
1.16M
AnalysisType &Pass::getAnalysis() const {
222
1.16M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.16M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.16M
}
llvm::TargetPassConfig& llvm::Pass::getAnalysis<llvm::TargetPassConfig>() const
Line
Count
Source
221
3.36M
AnalysisType &Pass::getAnalysis() const {
222
3.36M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
3.36M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
3.36M
}
llvm::LoopInfoWrapperPass& llvm::Pass::getAnalysis<llvm::LoopInfoWrapperPass>() const
Line
Count
Source
221
33.5M
AnalysisType &Pass::getAnalysis() const {
222
33.5M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
33.5M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
33.5M
}
llvm::ScalarEvolutionWrapperPass& llvm::Pass::getAnalysis<llvm::ScalarEvolutionWrapperPass>() const
Line
Count
Source
221
3.79M
AnalysisType &Pass::getAnalysis() const {
222
3.79M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
3.79M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
3.79M
}
llvm::MachineLoopInfo& llvm::Pass::getAnalysis<llvm::MachineLoopInfo>() const
Line
Count
Source
221
8.46M
AnalysisType &Pass::getAnalysis() const {
222
8.46M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
8.46M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
8.46M
}
llvm::AAResultsWrapperPass& llvm::Pass::getAnalysis<llvm::AAResultsWrapperPass>() const
Line
Count
Source
221
16.5M
AnalysisType &Pass::getAnalysis() const {
222
16.5M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
16.5M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
16.5M
}
llvm::LegacyDivergenceAnalysis& llvm::Pass::getAnalysis<llvm::LegacyDivergenceAnalysis>() const
Line
Count
Source
221
59.3k
AnalysisType &Pass::getAnalysis() const {
222
59.3k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
59.3k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
59.3k
}
llvm::MemoryDependenceWrapperPass& llvm::Pass::getAnalysis<llvm::MemoryDependenceWrapperPass>() const
Line
Count
Source
221
1.84M
AnalysisType &Pass::getAnalysis() const {
222
1.84M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.84M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.84M
}
llvm::AssumptionCacheTracker& llvm::Pass::getAnalysis<llvm::AssumptionCacheTracker>() const
Line
Count
Source
221
35.1M
AnalysisType &Pass::getAnalysis() const {
222
35.1M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
35.1M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
35.1M
}
llvm::TargetTransformInfoWrapperPass& llvm::Pass::getAnalysis<llvm::TargetTransformInfoWrapperPass>() const
Line
Count
Source
221
15.2M
AnalysisType &Pass::getAnalysis() const {
222
15.2M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
15.2M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
15.2M
}
Unexecuted instantiation: llvm::MachineRegionInfoPass& llvm::Pass::getAnalysis<llvm::MachineRegionInfoPass>() const
llvm::PostDominatorTreeWrapperPass& llvm::Pass::getAnalysis<llvm::PostDominatorTreeWrapperPass>() const
Line
Count
Source
221
1.05M
AnalysisType &Pass::getAnalysis() const {
222
1.05M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.05M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.05M
}
llvm::MachinePostDominatorTree& llvm::Pass::getAnalysis<llvm::MachinePostDominatorTree>() const
Line
Count
Source
221
951k
AnalysisType &Pass::getAnalysis() const {
222
951k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
951k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
951k
}
llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysis<llvm::DominatorTreeWrapperPass>() 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::LiveIntervals& llvm::Pass::getAnalysis<llvm::LiveIntervals>() const
Line
Count
Source
221
3.27M
AnalysisType &Pass::getAnalysis() const {
222
3.27M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
3.27M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
3.27M
}
llvm::AMDGPUArgumentUsageInfo& llvm::Pass::getAnalysis<llvm::AMDGPUArgumentUsageInfo>() const
Line
Count
Source
221
19.9k
AnalysisType &Pass::getAnalysis() const {
222
19.9k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
19.9k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
19.9k
}
llvm::TargetLibraryInfoWrapperPass& llvm::Pass::getAnalysis<llvm::TargetLibraryInfoWrapperPass>() const
Line
Count
Source
221
47.4M
AnalysisType &Pass::getAnalysis() const {
222
47.4M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
47.4M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
47.4M
}
llvm::MachineDominanceFrontier& llvm::Pass::getAnalysis<llvm::MachineDominanceFrontier>() const
Line
Count
Source
221
6.56k
AnalysisType &Pass::getAnalysis() const {
222
6.56k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
6.56k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
6.56k
}
llvm::EdgeBundles& llvm::Pass::getAnalysis<llvm::EdgeBundles>() const
Line
Count
Source
221
913k
AnalysisType &Pass::getAnalysis() const {
222
913k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
913k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
913k
}
llvm::MachineModuleInfo& llvm::Pass::getAnalysis<llvm::MachineModuleInfo>() const
Line
Count
Source
221
46.7M
AnalysisType &Pass::getAnalysis() const {
222
46.7M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
46.7M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
46.7M
}
llvm::BasicAAWrapperPass& llvm::Pass::getAnalysis<llvm::BasicAAWrapperPass>() const
Line
Count
Source
221
8.93M
AnalysisType &Pass::getAnalysis() const {
222
8.93M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
8.93M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
8.93M
}
llvm::BranchProbabilityInfoWrapperPass& llvm::Pass::getAnalysis<llvm::BranchProbabilityInfoWrapperPass>() 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::CallGraphWrapperPass& llvm::Pass::getAnalysis<llvm::CallGraphWrapperPass>() const
Line
Count
Source
221
2.13M
AnalysisType &Pass::getAnalysis() const {
222
2.13M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
2.13M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
2.13M
}
llvm::LazyBranchProbabilityInfoPass& llvm::Pass::getAnalysis<llvm::LazyBranchProbabilityInfoPass>() const
Line
Count
Source
221
5.58M
AnalysisType &Pass::getAnalysis() const {
222
5.58M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
5.58M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
5.58M
}
llvm::LazyValueInfoWrapperPass& llvm::Pass::getAnalysis<llvm::LazyValueInfoWrapperPass>() const
Line
Count
Source
221
1.82M
AnalysisType &Pass::getAnalysis() const {
222
1.82M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.82M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.82M
}
llvm::PhiValuesWrapperPass& llvm::Pass::getAnalysis<llvm::PhiValuesWrapperPass>() const
Line
Count
Source
221
1.84M
AnalysisType &Pass::getAnalysis() const {
222
1.84M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.84M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.84M
}
llvm::MemorySSAWrapperPass& llvm::Pass::getAnalysis<llvm::MemorySSAWrapperPass>() const
Line
Count
Source
221
911k
AnalysisType &Pass::getAnalysis() const {
222
911k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
911k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
911k
}
llvm::ProfileSummaryInfoWrapperPass& llvm::Pass::getAnalysis<llvm::ProfileSummaryInfoWrapperPass>() const
Line
Count
Source
221
1.27M
AnalysisType &Pass::getAnalysis() const {
222
1.27M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.27M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.27M
}
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
22.8k
AnalysisType &Pass::getAnalysis() const {
222
22.8k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
22.8k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
22.8k
}
llvm::RegionInfoPass& llvm::Pass::getAnalysis<llvm::RegionInfoPass>() const
Line
Count
Source
221
24.3k
AnalysisType &Pass::getAnalysis() const {
222
24.3k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
24.3k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
24.3k
}
llvm::MachineBlockFrequencyInfo& llvm::Pass::getAnalysis<llvm::MachineBlockFrequencyInfo>() const
Line
Count
Source
221
3.72M
AnalysisType &Pass::getAnalysis() const {
222
3.72M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
3.72M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
3.72M
}
llvm::ReachingDefAnalysis& llvm::Pass::getAnalysis<llvm::ReachingDefAnalysis>() const
Line
Count
Source
221
263k
AnalysisType &Pass::getAnalysis() const {
222
263k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
263k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
263k
}
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.36M
AnalysisType &Pass::getAnalysis() const {
222
1.36M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.36M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.36M
}
llvm::SlotIndexes& llvm::Pass::getAnalysis<llvm::SlotIndexes>() const
Line
Count
Source
221
1.85M
AnalysisType &Pass::getAnalysis() const {
222
1.85M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.85M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.85M
}
llvm::VirtRegMap& llvm::Pass::getAnalysis<llvm::VirtRegMap>() const
Line
Count
Source
221
1.36M
AnalysisType &Pass::getAnalysis() const {
222
1.36M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.36M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.36M
}
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.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::LiveRegMatrix& llvm::Pass::getAnalysis<llvm::LiveRegMatrix>() const
Line
Count
Source
221
456k
AnalysisType &Pass::getAnalysis() const {
222
456k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
456k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
456k
}
llvm::SpillPlacement& llvm::Pass::getAnalysis<llvm::SpillPlacement>() const
Line
Count
Source
221
455k
AnalysisType &Pass::getAnalysis() const {
222
455k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
455k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
455k
}
llvm::LiveDebugVariables& llvm::Pass::getAnalysis<llvm::LiveDebugVariables>() const
Line
Count
Source
221
911k
AnalysisType &Pass::getAnalysis() const {
222
911k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
911k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
911k
}
llvm::PhysicalRegisterUsageInfo& llvm::Pass::getAnalysis<llvm::PhysicalRegisterUsageInfo>() const
Line
Count
Source
221
38.2k
AnalysisType &Pass::getAnalysis() const {
222
38.2k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
38.2k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
38.2k
}
llvm::ModuleSummaryIndexWrapperPass& llvm::Pass::getAnalysis<llvm::ModuleSummaryIndexWrapperPass>() const
Line
Count
Source
221
292
AnalysisType &Pass::getAnalysis() const {
222
292
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
292
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
292
}
llvm::OptimizationRemarkEmitterWrapperPass& llvm::Pass::getAnalysis<llvm::OptimizationRemarkEmitterWrapperPass>() const
Line
Count
Source
221
5.86M
AnalysisType &Pass::getAnalysis() const {
222
5.86M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
5.86M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
5.86M
}
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysis<llvm::BlockFrequencyInfoWrapperPass>() const
Line
Count
Source
221
1.37M
AnalysisType &Pass::getAnalysis() const {
222
1.37M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.37M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.37M
}
llvm::DemandedBitsWrapperPass& llvm::Pass::getAnalysis<llvm::DemandedBitsWrapperPass>() const
Line
Count
Source
221
1.01M
AnalysisType &Pass::getAnalysis() const {
222
1.01M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
1.01M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
1.01M
}
llvm::LoopAccessLegacyAnalysis& llvm::Pass::getAnalysis<llvm::LoopAccessLegacyAnalysis>() const
Line
Count
Source
221
835k
AnalysisType &Pass::getAnalysis() const {
222
835k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
835k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
835k
}
llvm::DependenceAnalysisWrapperPass& llvm::Pass::getAnalysis<llvm::DependenceAnalysisWrapperPass>() const
Line
Count
Source
221
139
AnalysisType &Pass::getAnalysis() const {
222
139
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
139
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
139
}
llvm::IVUsersWrapperPass& llvm::Pass::getAnalysis<llvm::IVUsersWrapperPass>() const
Line
Count
Source
221
206k
AnalysisType &Pass::getAnalysis() const {
222
206k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
206k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
206k
}
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
}
llvm::StackProtector& llvm::Pass::getAnalysis<llvm::StackProtector>() const
Line
Count
Source
221
506k
AnalysisType &Pass::getAnalysis() const {
222
506k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
223
506k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
224
506k
}
225
226
template<typename AnalysisType>
227
323M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
323M
  assert(PI && "getAnalysis for unregistered pass!");
229
323M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
323M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
323M
  // should be a small number, we just do a linear search over a (dense)
232
323M
  // vector.
233
323M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
323M
  assert(ResultPass &&
235
323M
         "getAnalysis*() called on an analysis that was not "
236
323M
         "'required' by pass!");
237
323M
238
323M
  // Because the AnalysisType may not be a subclass of pass (for
239
323M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
323M
  // adjust the return pointer (because the class may multiply inherit, once
241
323M
  // from pass, once from AnalysisType).
242
323M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
323M
}
llvm::MachineDominatorTree& llvm::Pass::getAnalysisID<llvm::MachineDominatorTree>(void const*) const
Line
Count
Source
227
7.46M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
7.46M
  assert(PI && "getAnalysis for unregistered pass!");
229
7.46M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
7.46M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
7.46M
  // should be a small number, we just do a linear search over a (dense)
232
7.46M
  // vector.
233
7.46M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
7.46M
  assert(ResultPass &&
235
7.46M
         "getAnalysis*() called on an analysis that was not "
236
7.46M
         "'required' by pass!");
237
7.46M
238
7.46M
  // Because the AnalysisType may not be a subclass of pass (for
239
7.46M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
7.46M
  // adjust the return pointer (because the class may multiply inherit, once
241
7.46M
  // from pass, once from AnalysisType).
242
7.46M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
7.46M
}
llvm::MachineBranchProbabilityInfo& llvm::Pass::getAnalysisID<llvm::MachineBranchProbabilityInfo>(void const*) const
Line
Count
Source
227
4.15M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
4.15M
  assert(PI && "getAnalysis for unregistered pass!");
229
4.15M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
4.15M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
4.15M
  // should be a small number, we just do a linear search over a (dense)
232
4.15M
  // vector.
233
4.15M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
4.15M
  assert(ResultPass &&
235
4.15M
         "getAnalysis*() called on an analysis that was not "
236
4.15M
         "'required' by pass!");
237
4.15M
238
4.15M
  // Because the AnalysisType may not be a subclass of pass (for
239
4.15M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
4.15M
  // adjust the return pointer (because the class may multiply inherit, once
241
4.15M
  // from pass, once from AnalysisType).
242
4.15M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
4.15M
}
llvm::MachineTraceMetrics& llvm::Pass::getAnalysisID<llvm::MachineTraceMetrics>(void const*) const
Line
Count
Source
227
1.16M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.16M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.16M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.16M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.16M
  // should be a small number, we just do a linear search over a (dense)
232
1.16M
  // vector.
233
1.16M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.16M
  assert(ResultPass &&
235
1.16M
         "getAnalysis*() called on an analysis that was not "
236
1.16M
         "'required' by pass!");
237
1.16M
238
1.16M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.16M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.16M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.16M
  // from pass, once from AnalysisType).
242
1.16M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.16M
}
llvm::TargetPassConfig& llvm::Pass::getAnalysisID<llvm::TargetPassConfig>(void const*) const
Line
Count
Source
227
3.36M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
3.36M
  assert(PI && "getAnalysis for unregistered pass!");
229
3.36M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
3.36M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
3.36M
  // should be a small number, we just do a linear search over a (dense)
232
3.36M
  // vector.
233
3.36M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
3.36M
  assert(ResultPass &&
235
3.36M
         "getAnalysis*() called on an analysis that was not "
236
3.36M
         "'required' by pass!");
237
3.36M
238
3.36M
  // Because the AnalysisType may not be a subclass of pass (for
239
3.36M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
3.36M
  // adjust the return pointer (because the class may multiply inherit, once
241
3.36M
  // from pass, once from AnalysisType).
242
3.36M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
3.36M
}
llvm::LoopInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::LoopInfoWrapperPass>(void const*) const
Line
Count
Source
227
33.5M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
33.5M
  assert(PI && "getAnalysis for unregistered pass!");
229
33.5M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
33.5M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
33.5M
  // should be a small number, we just do a linear search over a (dense)
232
33.5M
  // vector.
233
33.5M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
33.5M
  assert(ResultPass &&
235
33.5M
         "getAnalysis*() called on an analysis that was not "
236
33.5M
         "'required' by pass!");
237
33.5M
238
33.5M
  // Because the AnalysisType may not be a subclass of pass (for
239
33.5M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
33.5M
  // adjust the return pointer (because the class may multiply inherit, once
241
33.5M
  // from pass, once from AnalysisType).
242
33.5M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
33.5M
}
llvm::ScalarEvolutionWrapperPass& llvm::Pass::getAnalysisID<llvm::ScalarEvolutionWrapperPass>(void const*) const
Line
Count
Source
227
3.79M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
3.79M
  assert(PI && "getAnalysis for unregistered pass!");
229
3.79M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
3.79M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
3.79M
  // should be a small number, we just do a linear search over a (dense)
232
3.79M
  // vector.
233
3.79M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
3.79M
  assert(ResultPass &&
235
3.79M
         "getAnalysis*() called on an analysis that was not "
236
3.79M
         "'required' by pass!");
237
3.79M
238
3.79M
  // Because the AnalysisType may not be a subclass of pass (for
239
3.79M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
3.79M
  // adjust the return pointer (because the class may multiply inherit, once
241
3.79M
  // from pass, once from AnalysisType).
242
3.79M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
3.79M
}
llvm::MachineLoopInfo& llvm::Pass::getAnalysisID<llvm::MachineLoopInfo>(void const*) const
Line
Count
Source
227
8.46M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
8.46M
  assert(PI && "getAnalysis for unregistered pass!");
229
8.46M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
8.46M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
8.46M
  // should be a small number, we just do a linear search over a (dense)
232
8.46M
  // vector.
233
8.46M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
8.46M
  assert(ResultPass &&
235
8.46M
         "getAnalysis*() called on an analysis that was not "
236
8.46M
         "'required' by pass!");
237
8.46M
238
8.46M
  // Because the AnalysisType may not be a subclass of pass (for
239
8.46M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
8.46M
  // adjust the return pointer (because the class may multiply inherit, once
241
8.46M
  // from pass, once from AnalysisType).
242
8.46M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
8.46M
}
llvm::AAResultsWrapperPass& llvm::Pass::getAnalysisID<llvm::AAResultsWrapperPass>(void const*) const
Line
Count
Source
227
16.5M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
16.5M
  assert(PI && "getAnalysis for unregistered pass!");
229
16.5M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
16.5M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
16.5M
  // should be a small number, we just do a linear search over a (dense)
232
16.5M
  // vector.
233
16.5M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
16.5M
  assert(ResultPass &&
235
16.5M
         "getAnalysis*() called on an analysis that was not "
236
16.5M
         "'required' by pass!");
237
16.5M
238
16.5M
  // Because the AnalysisType may not be a subclass of pass (for
239
16.5M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
16.5M
  // adjust the return pointer (because the class may multiply inherit, once
241
16.5M
  // from pass, once from AnalysisType).
242
16.5M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
16.5M
}
llvm::LegacyDivergenceAnalysis& llvm::Pass::getAnalysisID<llvm::LegacyDivergenceAnalysis>(void const*) const
Line
Count
Source
227
59.3k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
59.3k
  assert(PI && "getAnalysis for unregistered pass!");
229
59.3k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
59.3k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
59.3k
  // should be a small number, we just do a linear search over a (dense)
232
59.3k
  // vector.
233
59.3k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
59.3k
  assert(ResultPass &&
235
59.3k
         "getAnalysis*() called on an analysis that was not "
236
59.3k
         "'required' by pass!");
237
59.3k
238
59.3k
  // Because the AnalysisType may not be a subclass of pass (for
239
59.3k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
59.3k
  // adjust the return pointer (because the class may multiply inherit, once
241
59.3k
  // from pass, once from AnalysisType).
242
59.3k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
59.3k
}
llvm::MemoryDependenceWrapperPass& llvm::Pass::getAnalysisID<llvm::MemoryDependenceWrapperPass>(void const*) const
Line
Count
Source
227
1.84M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.84M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.84M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.84M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.84M
  // should be a small number, we just do a linear search over a (dense)
232
1.84M
  // vector.
233
1.84M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.84M
  assert(ResultPass &&
235
1.84M
         "getAnalysis*() called on an analysis that was not "
236
1.84M
         "'required' by pass!");
237
1.84M
238
1.84M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.84M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.84M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.84M
  // from pass, once from AnalysisType).
242
1.84M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.84M
}
llvm::AssumptionCacheTracker& llvm::Pass::getAnalysisID<llvm::AssumptionCacheTracker>(void const*) const
Line
Count
Source
227
35.1M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
35.1M
  assert(PI && "getAnalysis for unregistered pass!");
229
35.1M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
35.1M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
35.1M
  // should be a small number, we just do a linear search over a (dense)
232
35.1M
  // vector.
233
35.1M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
35.1M
  assert(ResultPass &&
235
35.1M
         "getAnalysis*() called on an analysis that was not "
236
35.1M
         "'required' by pass!");
237
35.1M
238
35.1M
  // Because the AnalysisType may not be a subclass of pass (for
239
35.1M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
35.1M
  // adjust the return pointer (because the class may multiply inherit, once
241
35.1M
  // from pass, once from AnalysisType).
242
35.1M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
35.1M
}
llvm::TargetTransformInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::TargetTransformInfoWrapperPass>(void const*) const
Line
Count
Source
227
15.2M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
15.2M
  assert(PI && "getAnalysis for unregistered pass!");
229
15.2M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
15.2M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
15.2M
  // should be a small number, we just do a linear search over a (dense)
232
15.2M
  // vector.
233
15.2M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
15.2M
  assert(ResultPass &&
235
15.2M
         "getAnalysis*() called on an analysis that was not "
236
15.2M
         "'required' by pass!");
237
15.2M
238
15.2M
  // Because the AnalysisType may not be a subclass of pass (for
239
15.2M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
15.2M
  // adjust the return pointer (because the class may multiply inherit, once
241
15.2M
  // from pass, once from AnalysisType).
242
15.2M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
15.2M
}
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
1.05M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.05M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.05M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.05M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.05M
  // should be a small number, we just do a linear search over a (dense)
232
1.05M
  // vector.
233
1.05M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.05M
  assert(ResultPass &&
235
1.05M
         "getAnalysis*() called on an analysis that was not "
236
1.05M
         "'required' by pass!");
237
1.05M
238
1.05M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.05M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.05M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.05M
  // from pass, once from AnalysisType).
242
1.05M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.05M
}
llvm::MachinePostDominatorTree& llvm::Pass::getAnalysisID<llvm::MachinePostDominatorTree>(void const*) const
Line
Count
Source
227
951k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
951k
  assert(PI && "getAnalysis for unregistered pass!");
229
951k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
951k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
951k
  // should be a small number, we just do a linear search over a (dense)
232
951k
  // vector.
233
951k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
951k
  assert(ResultPass &&
235
951k
         "getAnalysis*() called on an analysis that was not "
236
951k
         "'required' by pass!");
237
951k
238
951k
  // Because the AnalysisType may not be a subclass of pass (for
239
951k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
951k
  // adjust the return pointer (because the class may multiply inherit, once
241
951k
  // from pass, once from AnalysisType).
242
951k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
951k
}
llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysisID<llvm::DominatorTreeWrapperPass>(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::LiveIntervals& llvm::Pass::getAnalysisID<llvm::LiveIntervals>(void const*) const
Line
Count
Source
227
3.27M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
3.27M
  assert(PI && "getAnalysis for unregistered pass!");
229
3.27M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
3.27M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
3.27M
  // should be a small number, we just do a linear search over a (dense)
232
3.27M
  // vector.
233
3.27M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
3.27M
  assert(ResultPass &&
235
3.27M
         "getAnalysis*() called on an analysis that was not "
236
3.27M
         "'required' by pass!");
237
3.27M
238
3.27M
  // Because the AnalysisType may not be a subclass of pass (for
239
3.27M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
3.27M
  // adjust the return pointer (because the class may multiply inherit, once
241
3.27M
  // from pass, once from AnalysisType).
242
3.27M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
3.27M
}
llvm::AMDGPUArgumentUsageInfo& llvm::Pass::getAnalysisID<llvm::AMDGPUArgumentUsageInfo>(void const*) const
Line
Count
Source
227
19.9k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
19.9k
  assert(PI && "getAnalysis for unregistered pass!");
229
19.9k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
19.9k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
19.9k
  // should be a small number, we just do a linear search over a (dense)
232
19.9k
  // vector.
233
19.9k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
19.9k
  assert(ResultPass &&
235
19.9k
         "getAnalysis*() called on an analysis that was not "
236
19.9k
         "'required' by pass!");
237
19.9k
238
19.9k
  // Because the AnalysisType may not be a subclass of pass (for
239
19.9k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
19.9k
  // adjust the return pointer (because the class may multiply inherit, once
241
19.9k
  // from pass, once from AnalysisType).
242
19.9k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
19.9k
}
llvm::TargetLibraryInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::TargetLibraryInfoWrapperPass>(void const*) const
Line
Count
Source
227
47.4M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
47.4M
  assert(PI && "getAnalysis for unregistered pass!");
229
47.4M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
47.4M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
47.4M
  // should be a small number, we just do a linear search over a (dense)
232
47.4M
  // vector.
233
47.4M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
47.4M
  assert(ResultPass &&
235
47.4M
         "getAnalysis*() called on an analysis that was not "
236
47.4M
         "'required' by pass!");
237
47.4M
238
47.4M
  // Because the AnalysisType may not be a subclass of pass (for
239
47.4M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
47.4M
  // adjust the return pointer (because the class may multiply inherit, once
241
47.4M
  // from pass, once from AnalysisType).
242
47.4M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
47.4M
}
llvm::MachineDominanceFrontier& llvm::Pass::getAnalysisID<llvm::MachineDominanceFrontier>(void const*) const
Line
Count
Source
227
6.56k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
6.56k
  assert(PI && "getAnalysis for unregistered pass!");
229
6.56k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
6.56k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
6.56k
  // should be a small number, we just do a linear search over a (dense)
232
6.56k
  // vector.
233
6.56k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
6.56k
  assert(ResultPass &&
235
6.56k
         "getAnalysis*() called on an analysis that was not "
236
6.56k
         "'required' by pass!");
237
6.56k
238
6.56k
  // Because the AnalysisType may not be a subclass of pass (for
239
6.56k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
6.56k
  // adjust the return pointer (because the class may multiply inherit, once
241
6.56k
  // from pass, once from AnalysisType).
242
6.56k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
6.56k
}
llvm::EdgeBundles& llvm::Pass::getAnalysisID<llvm::EdgeBundles>(void const*) const
Line
Count
Source
227
913k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
913k
  assert(PI && "getAnalysis for unregistered pass!");
229
913k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
913k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
913k
  // should be a small number, we just do a linear search over a (dense)
232
913k
  // vector.
233
913k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
913k
  assert(ResultPass &&
235
913k
         "getAnalysis*() called on an analysis that was not "
236
913k
         "'required' by pass!");
237
913k
238
913k
  // Because the AnalysisType may not be a subclass of pass (for
239
913k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
913k
  // adjust the return pointer (because the class may multiply inherit, once
241
913k
  // from pass, once from AnalysisType).
242
913k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
913k
}
llvm::MachineModuleInfo& llvm::Pass::getAnalysisID<llvm::MachineModuleInfo>(void const*) const
Line
Count
Source
227
46.7M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
46.7M
  assert(PI && "getAnalysis for unregistered pass!");
229
46.7M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
46.7M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
46.7M
  // should be a small number, we just do a linear search over a (dense)
232
46.7M
  // vector.
233
46.7M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
46.7M
  assert(ResultPass &&
235
46.7M
         "getAnalysis*() called on an analysis that was not "
236
46.7M
         "'required' by pass!");
237
46.7M
238
46.7M
  // Because the AnalysisType may not be a subclass of pass (for
239
46.7M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
46.7M
  // adjust the return pointer (because the class may multiply inherit, once
241
46.7M
  // from pass, once from AnalysisType).
242
46.7M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
46.7M
}
llvm::BasicAAWrapperPass& llvm::Pass::getAnalysisID<llvm::BasicAAWrapperPass>(void const*) const
Line
Count
Source
227
8.93M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
8.93M
  assert(PI && "getAnalysis for unregistered pass!");
229
8.93M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
8.93M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
8.93M
  // should be a small number, we just do a linear search over a (dense)
232
8.93M
  // vector.
233
8.93M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
8.93M
  assert(ResultPass &&
235
8.93M
         "getAnalysis*() called on an analysis that was not "
236
8.93M
         "'required' by pass!");
237
8.93M
238
8.93M
  // Because the AnalysisType may not be a subclass of pass (for
239
8.93M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
8.93M
  // adjust the return pointer (because the class may multiply inherit, once
241
8.93M
  // from pass, once from AnalysisType).
242
8.93M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
8.93M
}
llvm::BranchProbabilityInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::BranchProbabilityInfoWrapperPass>(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::CallGraphWrapperPass& llvm::Pass::getAnalysisID<llvm::CallGraphWrapperPass>(void const*) const
Line
Count
Source
227
2.13M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
2.13M
  assert(PI && "getAnalysis for unregistered pass!");
229
2.13M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
2.13M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
2.13M
  // should be a small number, we just do a linear search over a (dense)
232
2.13M
  // vector.
233
2.13M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
2.13M
  assert(ResultPass &&
235
2.13M
         "getAnalysis*() called on an analysis that was not "
236
2.13M
         "'required' by pass!");
237
2.13M
238
2.13M
  // Because the AnalysisType may not be a subclass of pass (for
239
2.13M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
2.13M
  // adjust the return pointer (because the class may multiply inherit, once
241
2.13M
  // from pass, once from AnalysisType).
242
2.13M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
2.13M
}
llvm::LazyBranchProbabilityInfoPass& llvm::Pass::getAnalysisID<llvm::LazyBranchProbabilityInfoPass>(void const*) const
Line
Count
Source
227
5.58M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
5.58M
  assert(PI && "getAnalysis for unregistered pass!");
229
5.58M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
5.58M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
5.58M
  // should be a small number, we just do a linear search over a (dense)
232
5.58M
  // vector.
233
5.58M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
5.58M
  assert(ResultPass &&
235
5.58M
         "getAnalysis*() called on an analysis that was not "
236
5.58M
         "'required' by pass!");
237
5.58M
238
5.58M
  // Because the AnalysisType may not be a subclass of pass (for
239
5.58M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
5.58M
  // adjust the return pointer (because the class may multiply inherit, once
241
5.58M
  // from pass, once from AnalysisType).
242
5.58M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
5.58M
}
llvm::LazyValueInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::LazyValueInfoWrapperPass>(void const*) const
Line
Count
Source
227
1.82M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.82M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.82M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.82M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.82M
  // should be a small number, we just do a linear search over a (dense)
232
1.82M
  // vector.
233
1.82M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.82M
  assert(ResultPass &&
235
1.82M
         "getAnalysis*() called on an analysis that was not "
236
1.82M
         "'required' by pass!");
237
1.82M
238
1.82M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.82M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.82M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.82M
  // from pass, once from AnalysisType).
242
1.82M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.82M
}
llvm::PhiValuesWrapperPass& llvm::Pass::getAnalysisID<llvm::PhiValuesWrapperPass>(void const*) const
Line
Count
Source
227
1.84M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.84M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.84M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.84M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.84M
  // should be a small number, we just do a linear search over a (dense)
232
1.84M
  // vector.
233
1.84M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.84M
  assert(ResultPass &&
235
1.84M
         "getAnalysis*() called on an analysis that was not "
236
1.84M
         "'required' by pass!");
237
1.84M
238
1.84M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.84M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.84M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.84M
  // from pass, once from AnalysisType).
242
1.84M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.84M
}
llvm::MemorySSAWrapperPass& llvm::Pass::getAnalysisID<llvm::MemorySSAWrapperPass>(void const*) const
Line
Count
Source
227
911k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
911k
  assert(PI && "getAnalysis for unregistered pass!");
229
911k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
911k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
911k
  // should be a small number, we just do a linear search over a (dense)
232
911k
  // vector.
233
911k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
911k
  assert(ResultPass &&
235
911k
         "getAnalysis*() called on an analysis that was not "
236
911k
         "'required' by pass!");
237
911k
238
911k
  // Because the AnalysisType may not be a subclass of pass (for
239
911k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
911k
  // adjust the return pointer (because the class may multiply inherit, once
241
911k
  // from pass, once from AnalysisType).
242
911k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
911k
}
llvm::ProfileSummaryInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::ProfileSummaryInfoWrapperPass>(void const*) const
Line
Count
Source
227
1.27M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.27M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.27M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.27M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.27M
  // should be a small number, we just do a linear search over a (dense)
232
1.27M
  // vector.
233
1.27M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.27M
  assert(ResultPass &&
235
1.27M
         "getAnalysis*() called on an analysis that was not "
236
1.27M
         "'required' by pass!");
237
1.27M
238
1.27M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.27M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.27M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.27M
  // from pass, once from AnalysisType).
242
1.27M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.27M
}
llvm::LazyBlockFrequencyInfoPass& llvm::Pass::getAnalysisID<llvm::LazyBlockFrequencyInfoPass>(void const*) const
Line
Count
Source
227
206
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
206
  assert(PI && "getAnalysis for unregistered pass!");
229
206
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
206
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
206
  // should be a small number, we just do a linear search over a (dense)
232
206
  // vector.
233
206
  Pass *ResultPass = Resolver->findImplPass(PI);
234
206
  assert(ResultPass &&
235
206
         "getAnalysis*() called on an analysis that was not "
236
206
         "'required' by pass!");
237
206
238
206
  // Because the AnalysisType may not be a subclass of pass (for
239
206
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
206
  // adjust the return pointer (because the class may multiply inherit, once
241
206
  // from pass, once from AnalysisType).
242
206
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
206
}
llvm::DominanceFrontierWrapperPass& llvm::Pass::getAnalysisID<llvm::DominanceFrontierWrapperPass>(void const*) const
Line
Count
Source
227
22.8k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
22.8k
  assert(PI && "getAnalysis for unregistered pass!");
229
22.8k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
22.8k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
22.8k
  // should be a small number, we just do a linear search over a (dense)
232
22.8k
  // vector.
233
22.8k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
22.8k
  assert(ResultPass &&
235
22.8k
         "getAnalysis*() called on an analysis that was not "
236
22.8k
         "'required' by pass!");
237
22.8k
238
22.8k
  // Because the AnalysisType may not be a subclass of pass (for
239
22.8k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
22.8k
  // adjust the return pointer (because the class may multiply inherit, once
241
22.8k
  // from pass, once from AnalysisType).
242
22.8k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
22.8k
}
llvm::RegionInfoPass& llvm::Pass::getAnalysisID<llvm::RegionInfoPass>(void const*) const
Line
Count
Source
227
24.3k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
24.3k
  assert(PI && "getAnalysis for unregistered pass!");
229
24.3k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
24.3k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
24.3k
  // should be a small number, we just do a linear search over a (dense)
232
24.3k
  // vector.
233
24.3k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
24.3k
  assert(ResultPass &&
235
24.3k
         "getAnalysis*() called on an analysis that was not "
236
24.3k
         "'required' by pass!");
237
24.3k
238
24.3k
  // Because the AnalysisType may not be a subclass of pass (for
239
24.3k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
24.3k
  // adjust the return pointer (because the class may multiply inherit, once
241
24.3k
  // from pass, once from AnalysisType).
242
24.3k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
24.3k
}
llvm::MachineBlockFrequencyInfo& llvm::Pass::getAnalysisID<llvm::MachineBlockFrequencyInfo>(void const*) const
Line
Count
Source
227
3.72M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
3.72M
  assert(PI && "getAnalysis for unregistered pass!");
229
3.72M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
3.72M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
3.72M
  // should be a small number, we just do a linear search over a (dense)
232
3.72M
  // vector.
233
3.72M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
3.72M
  assert(ResultPass &&
235
3.72M
         "getAnalysis*() called on an analysis that was not "
236
3.72M
         "'required' by pass!");
237
3.72M
238
3.72M
  // Because the AnalysisType may not be a subclass of pass (for
239
3.72M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
3.72M
  // adjust the return pointer (because the class may multiply inherit, once
241
3.72M
  // from pass, once from AnalysisType).
242
3.72M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
3.72M
}
llvm::ReachingDefAnalysis& llvm::Pass::getAnalysisID<llvm::ReachingDefAnalysis>(void const*) const
Line
Count
Source
227
263k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
263k
  assert(PI && "getAnalysis for unregistered pass!");
229
263k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
263k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
263k
  // should be a small number, we just do a linear search over a (dense)
232
263k
  // vector.
233
263k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
263k
  assert(ResultPass &&
235
263k
         "getAnalysis*() called on an analysis that was not "
236
263k
         "'required' by pass!");
237
263k
238
263k
  // Because the AnalysisType may not be a subclass of pass (for
239
263k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
263k
  // adjust the return pointer (because the class may multiply inherit, once
241
263k
  // from pass, once from AnalysisType).
242
263k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
263k
}
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.36M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.36M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.36M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.36M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.36M
  // should be a small number, we just do a linear search over a (dense)
232
1.36M
  // vector.
233
1.36M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.36M
  assert(ResultPass &&
235
1.36M
         "getAnalysis*() called on an analysis that was not "
236
1.36M
         "'required' by pass!");
237
1.36M
238
1.36M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.36M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.36M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.36M
  // from pass, once from AnalysisType).
242
1.36M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.36M
}
llvm::SlotIndexes& llvm::Pass::getAnalysisID<llvm::SlotIndexes>(void const*) const
Line
Count
Source
227
1.85M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.85M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.85M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.85M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.85M
  // should be a small number, we just do a linear search over a (dense)
232
1.85M
  // vector.
233
1.85M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.85M
  assert(ResultPass &&
235
1.85M
         "getAnalysis*() called on an analysis that was not "
236
1.85M
         "'required' by pass!");
237
1.85M
238
1.85M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.85M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.85M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.85M
  // from pass, once from AnalysisType).
242
1.85M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.85M
}
llvm::VirtRegMap& llvm::Pass::getAnalysisID<llvm::VirtRegMap>(void const*) const
Line
Count
Source
227
1.36M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.36M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.36M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.36M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.36M
  // should be a small number, we just do a linear search over a (dense)
232
1.36M
  // vector.
233
1.36M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.36M
  assert(ResultPass &&
235
1.36M
         "getAnalysis*() called on an analysis that was not "
236
1.36M
         "'required' by pass!");
237
1.36M
238
1.36M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.36M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.36M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.36M
  // from pass, once from AnalysisType).
242
1.36M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.36M
}
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.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::LiveRegMatrix& llvm::Pass::getAnalysisID<llvm::LiveRegMatrix>(void const*) const
Line
Count
Source
227
456k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
456k
  assert(PI && "getAnalysis for unregistered pass!");
229
456k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
456k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
456k
  // should be a small number, we just do a linear search over a (dense)
232
456k
  // vector.
233
456k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
456k
  assert(ResultPass &&
235
456k
         "getAnalysis*() called on an analysis that was not "
236
456k
         "'required' by pass!");
237
456k
238
456k
  // Because the AnalysisType may not be a subclass of pass (for
239
456k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
456k
  // adjust the return pointer (because the class may multiply inherit, once
241
456k
  // from pass, once from AnalysisType).
242
456k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
456k
}
llvm::SpillPlacement& llvm::Pass::getAnalysisID<llvm::SpillPlacement>(void const*) const
Line
Count
Source
227
455k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
455k
  assert(PI && "getAnalysis for unregistered pass!");
229
455k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
455k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
455k
  // should be a small number, we just do a linear search over a (dense)
232
455k
  // vector.
233
455k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
455k
  assert(ResultPass &&
235
455k
         "getAnalysis*() called on an analysis that was not "
236
455k
         "'required' by pass!");
237
455k
238
455k
  // Because the AnalysisType may not be a subclass of pass (for
239
455k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
455k
  // adjust the return pointer (because the class may multiply inherit, once
241
455k
  // from pass, once from AnalysisType).
242
455k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
455k
}
llvm::LiveDebugVariables& llvm::Pass::getAnalysisID<llvm::LiveDebugVariables>(void const*) const
Line
Count
Source
227
911k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
911k
  assert(PI && "getAnalysis for unregistered pass!");
229
911k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
911k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
911k
  // should be a small number, we just do a linear search over a (dense)
232
911k
  // vector.
233
911k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
911k
  assert(ResultPass &&
235
911k
         "getAnalysis*() called on an analysis that was not "
236
911k
         "'required' by pass!");
237
911k
238
911k
  // Because the AnalysisType may not be a subclass of pass (for
239
911k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
911k
  // adjust the return pointer (because the class may multiply inherit, once
241
911k
  // from pass, once from AnalysisType).
242
911k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
911k
}
llvm::PhysicalRegisterUsageInfo& llvm::Pass::getAnalysisID<llvm::PhysicalRegisterUsageInfo>(void const*) const
Line
Count
Source
227
38.2k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
38.2k
  assert(PI && "getAnalysis for unregistered pass!");
229
38.2k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
38.2k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
38.2k
  // should be a small number, we just do a linear search over a (dense)
232
38.2k
  // vector.
233
38.2k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
38.2k
  assert(ResultPass &&
235
38.2k
         "getAnalysis*() called on an analysis that was not "
236
38.2k
         "'required' by pass!");
237
38.2k
238
38.2k
  // Because the AnalysisType may not be a subclass of pass (for
239
38.2k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
38.2k
  // adjust the return pointer (because the class may multiply inherit, once
241
38.2k
  // from pass, once from AnalysisType).
242
38.2k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
38.2k
}
llvm::ModuleSummaryIndexWrapperPass& llvm::Pass::getAnalysisID<llvm::ModuleSummaryIndexWrapperPass>(void const*) const
Line
Count
Source
227
292
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
292
  assert(PI && "getAnalysis for unregistered pass!");
229
292
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
292
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
292
  // should be a small number, we just do a linear search over a (dense)
232
292
  // vector.
233
292
  Pass *ResultPass = Resolver->findImplPass(PI);
234
292
  assert(ResultPass &&
235
292
         "getAnalysis*() called on an analysis that was not "
236
292
         "'required' by pass!");
237
292
238
292
  // Because the AnalysisType may not be a subclass of pass (for
239
292
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
292
  // adjust the return pointer (because the class may multiply inherit, once
241
292
  // from pass, once from AnalysisType).
242
292
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
292
}
llvm::OptimizationRemarkEmitterWrapperPass& llvm::Pass::getAnalysisID<llvm::OptimizationRemarkEmitterWrapperPass>(void const*) const
Line
Count
Source
227
5.86M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
5.86M
  assert(PI && "getAnalysis for unregistered pass!");
229
5.86M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
5.86M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
5.86M
  // should be a small number, we just do a linear search over a (dense)
232
5.86M
  // vector.
233
5.86M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
5.86M
  assert(ResultPass &&
235
5.86M
         "getAnalysis*() called on an analysis that was not "
236
5.86M
         "'required' by pass!");
237
5.86M
238
5.86M
  // Because the AnalysisType may not be a subclass of pass (for
239
5.86M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
5.86M
  // adjust the return pointer (because the class may multiply inherit, once
241
5.86M
  // from pass, once from AnalysisType).
242
5.86M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
5.86M
}
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::BlockFrequencyInfoWrapperPass>(void const*) const
Line
Count
Source
227
1.37M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.37M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.37M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.37M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.37M
  // should be a small number, we just do a linear search over a (dense)
232
1.37M
  // vector.
233
1.37M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.37M
  assert(ResultPass &&
235
1.37M
         "getAnalysis*() called on an analysis that was not "
236
1.37M
         "'required' by pass!");
237
1.37M
238
1.37M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.37M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.37M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.37M
  // from pass, once from AnalysisType).
242
1.37M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.37M
}
llvm::DemandedBitsWrapperPass& llvm::Pass::getAnalysisID<llvm::DemandedBitsWrapperPass>(void const*) const
Line
Count
Source
227
1.01M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
1.01M
  assert(PI && "getAnalysis for unregistered pass!");
229
1.01M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
1.01M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
1.01M
  // should be a small number, we just do a linear search over a (dense)
232
1.01M
  // vector.
233
1.01M
  Pass *ResultPass = Resolver->findImplPass(PI);
234
1.01M
  assert(ResultPass &&
235
1.01M
         "getAnalysis*() called on an analysis that was not "
236
1.01M
         "'required' by pass!");
237
1.01M
238
1.01M
  // Because the AnalysisType may not be a subclass of pass (for
239
1.01M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
1.01M
  // adjust the return pointer (because the class may multiply inherit, once
241
1.01M
  // from pass, once from AnalysisType).
242
1.01M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
1.01M
}
llvm::LoopAccessLegacyAnalysis& llvm::Pass::getAnalysisID<llvm::LoopAccessLegacyAnalysis>(void const*) const
Line
Count
Source
227
835k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
835k
  assert(PI && "getAnalysis for unregistered pass!");
229
835k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
835k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
835k
  // should be a small number, we just do a linear search over a (dense)
232
835k
  // vector.
233
835k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
835k
  assert(ResultPass &&
235
835k
         "getAnalysis*() called on an analysis that was not "
236
835k
         "'required' by pass!");
237
835k
238
835k
  // Because the AnalysisType may not be a subclass of pass (for
239
835k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
835k
  // adjust the return pointer (because the class may multiply inherit, once
241
835k
  // from pass, once from AnalysisType).
242
835k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
835k
}
llvm::DependenceAnalysisWrapperPass& llvm::Pass::getAnalysisID<llvm::DependenceAnalysisWrapperPass>(void const*) const
Line
Count
Source
227
139
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
139
  assert(PI && "getAnalysis for unregistered pass!");
229
139
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
139
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
139
  // should be a small number, we just do a linear search over a (dense)
232
139
  // vector.
233
139
  Pass *ResultPass = Resolver->findImplPass(PI);
234
139
  assert(ResultPass &&
235
139
         "getAnalysis*() called on an analysis that was not "
236
139
         "'required' by pass!");
237
139
238
139
  // Because the AnalysisType may not be a subclass of pass (for
239
139
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
139
  // adjust the return pointer (because the class may multiply inherit, once
241
139
  // from pass, once from AnalysisType).
242
139
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
139
}
llvm::IVUsersWrapperPass& llvm::Pass::getAnalysisID<llvm::IVUsersWrapperPass>(void const*) const
Line
Count
Source
227
206k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
206k
  assert(PI && "getAnalysis for unregistered pass!");
229
206k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
206k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
206k
  // should be a small number, we just do a linear search over a (dense)
232
206k
  // vector.
233
206k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
206k
  assert(ResultPass &&
235
206k
         "getAnalysis*() called on an analysis that was not "
236
206k
         "'required' by pass!");
237
206k
238
206k
  // Because the AnalysisType may not be a subclass of pass (for
239
206k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
206k
  // adjust the return pointer (because the class may multiply inherit, once
241
206k
  // from pass, once from AnalysisType).
242
206k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
206k
}
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::StackProtector& llvm::Pass::getAnalysisID<llvm::StackProtector>(void const*) const
Line
Count
Source
227
506k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
506k
  assert(PI && "getAnalysis for unregistered pass!");
229
506k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
506k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
506k
  // should be a small number, we just do a linear search over a (dense)
232
506k
  // vector.
233
506k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
506k
  assert(ResultPass &&
235
506k
         "getAnalysis*() called on an analysis that was not "
236
506k
         "'required' by pass!");
237
506k
238
506k
  // Because the AnalysisType may not be a subclass of pass (for
239
506k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
506k
  // adjust the return pointer (because the class may multiply inherit, once
241
506k
  // from pass, once from AnalysisType).
242
506k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
506k
}
llvm::Pass& llvm::Pass::getAnalysisID<llvm::Pass>(void const*) const
Line
Count
Source
227
11.6k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
228
11.6k
  assert(PI && "getAnalysis for unregistered pass!");
229
11.6k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
230
11.6k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
231
11.6k
  // should be a small number, we just do a linear search over a (dense)
232
11.6k
  // vector.
233
11.6k
  Pass *ResultPass = Resolver->findImplPass(PI);
234
11.6k
  assert(ResultPass &&
235
11.6k
         "getAnalysis*() called on an analysis that was not "
236
11.6k
         "'required' by pass!");
237
11.6k
238
11.6k
  // Because the AnalysisType may not be a subclass of pass (for
239
11.6k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
240
11.6k
  // adjust the return pointer (because the class may multiply inherit, once
241
11.6k
  // from pass, once from AnalysisType).
242
11.6k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
243
11.6k
}
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
621k
AnalysisType &Pass::getAnalysis(Function &F) {
250
621k
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
251
621k
252
621k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
253
621k
}
llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysis<llvm::DominatorTreeWrapperPass>(llvm::Function&)
Line
Count
Source
249
585k
AnalysisType &Pass::getAnalysis(Function &F) {
250
585k
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
251
585k
252
585k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
253
585k
}
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysis<llvm::BlockFrequencyInfoWrapperPass>(llvm::Function&)
Line
Count
Source
249
35.8k
AnalysisType &Pass::getAnalysis(Function &F) {
250
35.8k
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
251
35.8k
252
35.8k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
253
35.8k
}
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
49
AnalysisType &Pass::getAnalysis(Function &F) {
250
49
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
251
49
252
49
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
253
49
}
254
255
template<typename AnalysisType>
256
621k
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
257
621k
  assert(PI && "getAnalysis for unregistered pass!");
258
621k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
259
621k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
260
621k
  // should be a small number, we just do a linear search over a (dense)
261
621k
  // vector.
262
621k
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
263
621k
  assert(ResultPass && "Unable to find requested analysis info");
264
621k
265
621k
  // Because the AnalysisType may not be a subclass of pass (for
266
621k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
267
621k
  // adjust the return pointer (because the class may multiply inherit, once
268
621k
  // from pass, once from AnalysisType).
269
621k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
270
621k
}
llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysisID<llvm::DominatorTreeWrapperPass>(void const*, llvm::Function&)
Line
Count
Source
256
585k
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
257
585k
  assert(PI && "getAnalysis for unregistered pass!");
258
585k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
259
585k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
260
585k
  // should be a small number, we just do a linear search over a (dense)
261
585k
  // vector.
262
585k
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
263
585k
  assert(ResultPass && "Unable to find requested analysis info");
264
585k
265
585k
  // Because the AnalysisType may not be a subclass of pass (for
266
585k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
267
585k
  // adjust the return pointer (because the class may multiply inherit, once
268
585k
  // from pass, once from AnalysisType).
269
585k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
270
585k
}
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::BlockFrequencyInfoWrapperPass>(void const*, llvm::Function&)
Line
Count
Source
256
35.8k
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
257
35.8k
  assert(PI && "getAnalysis for unregistered pass!");
258
35.8k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
259
35.8k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
260
35.8k
  // should be a small number, we just do a linear search over a (dense)
261
35.8k
  // vector.
262
35.8k
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
263
35.8k
  assert(ResultPass && "Unable to find requested analysis info");
264
35.8k
265
35.8k
  // Because the AnalysisType may not be a subclass of pass (for
266
35.8k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
267
35.8k
  // adjust the return pointer (because the class may multiply inherit, once
268
35.8k
  // from pass, once from AnalysisType).
269
35.8k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
270
35.8k
}
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
49
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
257
49
  assert(PI && "getAnalysis for unregistered pass!");
258
49
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
259
49
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
260
49
  // should be a small number, we just do a linear search over a (dense)
261
49
  // vector.
262
49
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
263
49
  assert(ResultPass && "Unable to find requested analysis info");
264
49
265
49
  // Because the AnalysisType may not be a subclass of pass (for
266
49
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
267
49
  // adjust the return pointer (because the class may multiply inherit, once
268
49
  // from pass, once from AnalysisType).
269
49
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
270
49
}
271
272
} // end namespace llvm
273
274
#endif // LLVM_PASSANALYSISSUPPORT_H