Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/PassAnalysisSupport.h
Line
Count
Source (jump to first uncovered line)
1
//===- llvm/PassAnalysisSupport.h - Analysis Pass Support code --*- C++ -*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
// This file defines stuff that is used to define and "use" Analysis Passes.
10
// This file is automatically #included by Pass.h, so:
11
//
12
//           NO .CPP FILES SHOULD INCLUDE THIS FILE DIRECTLY
13
//
14
// Instead, #include Pass.h
15
//
16
//===----------------------------------------------------------------------===//
17
18
#ifndef LLVM_PASSANALYSISSUPPORT_H
19
#define LLVM_PASSANALYSISSUPPORT_H
20
21
#include "Pass.h"
22
#include "llvm/ADT/SmallVector.h"
23
#include "llvm/ADT/StringRef.h"
24
#include <cassert>
25
#include <utility>
26
#include <vector>
27
28
namespace llvm {
29
30
class Function;
31
class Pass;
32
class PMDataManager;
33
34
//===----------------------------------------------------------------------===//
35
/// Represent the analysis usage information of a pass.  This tracks analyses
36
/// that the pass REQUIRES (must be available when the pass runs), REQUIRES
37
/// TRANSITIVE (must be available throughout the lifetime of the pass), and
38
/// analyses that the pass PRESERVES (the pass does not invalidate the results
39
/// of these analyses).  This information is provided by a pass to the Pass
40
/// infrastructure through the getAnalysisUsage virtual function.
41
///
42
class AnalysisUsage {
43
public:
44
  using VectorType = SmallVectorImpl<AnalysisID>;
45
46
private:
47
  /// Sets of analyses required and preserved by a pass
48
  // TODO: It's not clear that SmallVector is an appropriate data structure for
49
  // this usecase.  The sizes were picked to minimize wasted space, but are
50
  // otherwise fairly meaningless.
51
  SmallVector<AnalysisID, 8> Required;
52
  SmallVector<AnalysisID, 2> RequiredTransitive;
53
  SmallVector<AnalysisID, 2> Preserved;
54
  SmallVector<AnalysisID, 0> Used;
55
  bool PreservesAll = false;
56
57
public:
58
10.1M
  AnalysisUsage() = default;
59
60
  ///@{
61
  /// Add the specified ID to the required set of the usage info for a pass.
62
  AnalysisUsage &addRequiredID(const void *ID);
63
  AnalysisUsage &addRequiredID(char &ID);
64
  template<class PassClass>
65
20.6M
  AnalysisUsage &addRequired() {
66
20.6M
    return addRequiredID(PassClass::ID);
67
20.6M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineDominatorTree>()
Line
Count
Source
65
507k
  AnalysisUsage &addRequired() {
66
507k
    return addRequiredID(PassClass::ID);
67
507k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineBranchProbabilityInfo>()
Line
Count
Source
65
499k
  AnalysisUsage &addRequired() {
66
499k
    return addRequiredID(PassClass::ID);
67
499k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineLoopInfo>()
Line
Count
Source
65
620k
  AnalysisUsage &addRequired() {
66
620k
    return addRequiredID(PassClass::ID);
67
620k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineTraceMetrics>()
Line
Count
Source
65
61.2k
  AnalysisUsage &addRequired() {
66
61.2k
    return addRequiredID(PassClass::ID);
67
61.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::TargetPassConfig>()
Line
Count
Source
65
298k
  AnalysisUsage &addRequired() {
66
298k
    return addRequiredID(PassClass::ID);
67
298k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LoopInfoWrapperPass>()
Line
Count
Source
65
2.39M
  AnalysisUsage &addRequired() {
66
2.39M
    return addRequiredID(PassClass::ID);
67
2.39M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ScalarEvolutionWrapperPass>()
Line
Count
Source
65
379k
  AnalysisUsage &addRequired() {
66
379k
    return addRequiredID(PassClass::ID);
67
379k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AAResultsWrapperPass>()
Line
Count
Source
65
870k
  AnalysisUsage &addRequired() {
66
870k
    return addRequiredID(PassClass::ID);
67
870k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DominatorTreeWrapperPass>()
Line
Count
Source
65
2.29M
  AnalysisUsage &addRequired() {
66
2.29M
    return addRequiredID(PassClass::ID);
67
2.29M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LegacyDivergenceAnalysis>()
Line
Count
Source
65
14.9k
  AnalysisUsage &addRequired() {
66
14.9k
    return addRequiredID(PassClass::ID);
67
14.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MemoryDependenceWrapperPass>()
Line
Count
Source
65
42.8k
  AnalysisUsage &addRequired() {
66
42.8k
    return addRequiredID(PassClass::ID);
67
42.8k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AssumptionCacheTracker>()
Line
Count
Source
65
1.28M
  AnalysisUsage &addRequired() {
66
1.28M
    return addRequiredID(PassClass::ID);
67
1.28M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::AMDGPUArgumentUsageInfo>()
Line
Count
Source
65
2.66k
  AnalysisUsage &addRequired() {
66
2.66k
    return addRequiredID(PassClass::ID);
67
2.66k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::TargetTransformInfoWrapperPass>()
Line
Count
Source
65
797k
  AnalysisUsage &addRequired() {
66
797k
    return addRequiredID(PassClass::ID);
67
797k
  }
Unexecuted instantiation: llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineRegionInfoPass>()
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::PostDominatorTreeWrapperPass>()
Line
Count
Source
65
32.9k
  AnalysisUsage &addRequired() {
66
32.9k
    return addRequiredID(PassClass::ID);
67
32.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachinePostDominatorTree>()
Line
Count
Source
65
105k
  AnalysisUsage &addRequired() {
66
105k
    return addRequiredID(PassClass::ID);
67
105k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveIntervals>()
Line
Count
Source
65
191k
  AnalysisUsage &addRequired() {
66
191k
    return addRequiredID(PassClass::ID);
67
191k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::VirtRegMap>()
Line
Count
Source
65
74.3k
  AnalysisUsage &addRequired() {
66
74.3k
    return addRequiredID(PassClass::ID);
67
74.3k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveRegMatrix>()
Line
Count
Source
65
40.7k
  AnalysisUsage &addRequired() {
66
40.7k
    return addRequiredID(PassClass::ID);
67
40.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::TargetLibraryInfoWrapperPass>()
Line
Count
Source
65
2.44M
  AnalysisUsage &addRequired() {
66
2.44M
    return addRequiredID(PassClass::ID);
67
2.44M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ReachingDefAnalysis>()
Line
Count
Source
65
32.4k
  AnalysisUsage &addRequired() {
66
32.4k
    return addRequiredID(PassClass::ID);
67
32.4k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineDominanceFrontier>()
Line
Count
Source
65
2.13k
  AnalysisUsage &addRequired() {
66
2.13k
    return addRequiredID(PassClass::ID);
67
2.13k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineBlockFrequencyInfo>()
Line
Count
Source
65
284k
  AnalysisUsage &addRequired() {
66
284k
    return addRequiredID(PassClass::ID);
67
284k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::SlotIndexes>()
Line
Count
Source
65
206k
  AnalysisUsage &addRequired() {
66
206k
    return addRequiredID(PassClass::ID);
67
206k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::WebAssemblyExceptionInfo>()
Line
Count
Source
65
855
  AnalysisUsage &addRequired() {
66
855
    return addRequiredID(PassClass::ID);
67
855
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::EdgeBundles>()
Line
Count
Source
65
45.7k
  AnalysisUsage &addRequired() {
66
45.7k
    return addRequiredID(PassClass::ID);
67
45.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineModuleInfo>()
Line
Count
Source
65
3.80M
  AnalysisUsage &addRequired() {
66
3.80M
    return addRequiredID(PassClass::ID);
67
3.80M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::BasicAAWrapperPass>()
Line
Count
Source
65
360k
  AnalysisUsage &addRequired() {
66
360k
    return addRequiredID(PassClass::ID);
67
360k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::BranchProbabilityInfoWrapperPass>()
Line
Count
Source
65
149k
  AnalysisUsage &addRequired() {
66
149k
    return addRequiredID(PassClass::ID);
67
149k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::CallGraphWrapperPass>()
Line
Count
Source
65
137k
  AnalysisUsage &addRequired() {
66
137k
    return addRequiredID(PassClass::ID);
67
137k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyBranchProbabilityInfoPass>()
Line
Count
Source
65
563k
  AnalysisUsage &addRequired() {
66
563k
    return addRequiredID(PassClass::ID);
67
563k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyBlockFrequencyInfoPass>()
Line
Count
Source
65
342k
  AnalysisUsage &addRequired() {
66
342k
    return addRequiredID(PassClass::ID);
67
342k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyValueInfoWrapperPass>()
Line
Count
Source
65
58.2k
  AnalysisUsage &addRequired() {
66
58.2k
    return addRequiredID(PassClass::ID);
67
58.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::PhiValuesWrapperPass>()
Line
Count
Source
65
42.4k
  AnalysisUsage &addRequired() {
66
42.4k
    return addRequiredID(PassClass::ID);
67
42.4k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MemorySSAWrapperPass>()
Line
Count
Source
65
21.8k
  AnalysisUsage &addRequired() {
66
21.8k
    return addRequiredID(PassClass::ID);
67
21.8k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::BlockFrequencyInfoWrapperPass>()
Line
Count
Source
65
100k
  AnalysisUsage &addRequired() {
66
100k
    return addRequiredID(PassClass::ID);
67
100k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ProfileSummaryInfoWrapperPass>()
Line
Count
Source
65
229k
  AnalysisUsage &addRequired() {
66
229k
    return addRequiredID(PassClass::ID);
67
229k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DominanceFrontierWrapperPass>()
Line
Count
Source
65
4.02k
  AnalysisUsage &addRequired() {
66
4.02k
    return addRequiredID(PassClass::ID);
67
4.02k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::RegionInfoPass>()
Line
Count
Source
65
5.37k
  AnalysisUsage &addRequired() {
66
5.37k
    return addRequiredID(PassClass::ID);
67
5.37k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::StackSafetyInfoWrapperPass>()
Line
Count
Source
65
5
  AnalysisUsage &addRequired() {
66
5
    return addRequiredID(PassClass::ID);
67
5
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::GCModuleInfo>()
Line
Count
Source
65
143k
  AnalysisUsage &addRequired() {
66
143k
    return addRequiredID(PassClass::ID);
67
143k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LazyMachineBlockFrequencyInfoPass>()
Line
Count
Source
65
105k
  AnalysisUsage &addRequired() {
66
105k
    return addRequiredID(PassClass::ID);
67
105k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::MachineOptimizationRemarkEmitterPass>()
Line
Count
Source
65
139k
  AnalysisUsage &addRequired() {
66
139k
    return addRequiredID(PassClass::ID);
67
139k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveDebugVariables>()
Line
Count
Source
65
67.2k
  AnalysisUsage &addRequired() {
66
67.2k
    return addRequiredID(PassClass::ID);
67
67.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LiveStacks>()
Line
Count
Source
65
101k
  AnalysisUsage &addRequired() {
66
101k
    return addRequiredID(PassClass::ID);
67
101k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::SpillPlacement>()
Line
Count
Source
65
33.5k
  AnalysisUsage &addRequired() {
66
33.5k
    return addRequiredID(PassClass::ID);
67
33.5k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::PhysicalRegisterUsageInfo>()
Line
Count
Source
65
4.82k
  AnalysisUsage &addRequired() {
66
4.82k
    return addRequiredID(PassClass::ID);
67
4.82k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::ModuleSummaryIndexWrapperPass>()
Line
Count
Source
65
390
  AnalysisUsage &addRequired() {
66
390
    return addRequiredID(PassClass::ID);
67
390
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::OptimizationRemarkEmitterWrapperPass>()
Line
Count
Source
65
224k
  AnalysisUsage &addRequired() {
66
224k
    return addRequiredID(PassClass::ID);
67
224k
  }
AddressSanitizer.cpp:llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<(anonymous namespace)::ASanGlobalsMetadataWrapperPass>()
Line
Count
Source
65
351
  AnalysisUsage &addRequired() {
66
351
    return addRequiredID(PassClass::ID);
67
351
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::objcarc::ObjCARCAAWrapperPass>()
Line
Count
Source
65
35
  AnalysisUsage &addRequired() {
66
35
    return addRequiredID(PassClass::ID);
67
35
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DemandedBitsWrapperPass>()
Line
Count
Source
65
40.4k
  AnalysisUsage &addRequired() {
66
40.4k
    return addRequiredID(PassClass::ID);
67
40.4k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LoopAccessLegacyAnalysis>()
Line
Count
Source
65
39.6k
  AnalysisUsage &addRequired() {
66
39.6k
    return addRequiredID(PassClass::ID);
67
39.6k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::DependenceAnalysisWrapperPass>()
Line
Count
Source
65
27
  AnalysisUsage &addRequired() {
66
27
    return addRequiredID(PassClass::ID);
67
27
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::IVUsersWrapperPass>()
Line
Count
Source
65
34.4k
  AnalysisUsage &addRequired() {
66
34.4k
    return addRequiredID(PassClass::ID);
67
34.4k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::LCSSAVerificationPass>()
Line
Count
Source
65
262k
  AnalysisUsage &addRequired() {
66
262k
    return addRequiredID(PassClass::ID);
67
262k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<polly::ScopDetectionWrapperPass>()
Line
Count
Source
65
328
  AnalysisUsage &addRequired() {
66
328
    return addRequiredID(PassClass::ID);
67
328
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<polly::ScopInfoRegionPass>()
Line
Count
Source
65
1.31k
  AnalysisUsage &addRequired() {
66
1.31k
    return addRequiredID(PassClass::ID);
67
1.31k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<polly::DependenceInfo>()
Line
Count
Source
65
661
  AnalysisUsage &addRequired() {
66
661
    return addRequiredID(PassClass::ID);
67
661
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<polly::IslAstInfoWrapperPass>()
Line
Count
Source
65
327
  AnalysisUsage &addRequired() {
66
327
    return addRequiredID(PassClass::ID);
67
327
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::StackProtector>()
Line
Count
Source
65
44.8k
  AnalysisUsage &addRequired() {
66
44.8k
    return addRequiredID(PassClass::ID);
67
44.8k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequired<llvm::GISelCSEAnalysisWrapperPass>()
Line
Count
Source
65
14.3k
  AnalysisUsage &addRequired() {
66
14.3k
    return addRequiredID(PassClass::ID);
67
14.3k
  }
68
69
  AnalysisUsage &addRequiredTransitiveID(char &ID);
70
  template<class PassClass>
71
1.50M
  AnalysisUsage &addRequiredTransitive() {
72
1.50M
    return addRequiredTransitiveID(PassClass::ID);
73
1.50M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::CallGraphWrapperPass>()
Line
Count
Source
71
5
  AnalysisUsage &addRequiredTransitive() {
72
5
    return addRequiredTransitiveID(PassClass::ID);
73
5
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::AAResultsWrapperPass>()
Line
Count
Source
71
65.6k
  AnalysisUsage &addRequiredTransitive() {
72
65.6k
    return addRequiredTransitiveID(PassClass::ID);
73
65.6k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::ScalarEvolutionWrapperPass>()
Line
Count
Source
71
2.53k
  AnalysisUsage &addRequiredTransitive() {
72
2.53k
    return addRequiredTransitiveID(PassClass::ID);
73
2.53k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::LoopInfoWrapperPass>()
Line
Count
Source
71
191k
  AnalysisUsage &addRequiredTransitive() {
72
191k
    return addRequiredTransitiveID(PassClass::ID);
73
191k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::DominatorTreeWrapperPass>()
Line
Count
Source
71
561k
  AnalysisUsage &addRequiredTransitive() {
72
561k
    return addRequiredTransitiveID(PassClass::ID);
73
561k
  }
Unexecuted instantiation: llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::MemoryDependenceWrapperPass>()
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::TargetLibraryInfoWrapperPass>()
Line
Count
Source
71
233k
  AnalysisUsage &addRequiredTransitive() {
72
233k
    return addRequiredTransitiveID(PassClass::ID);
73
233k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::AssumptionCacheTracker>()
Line
Count
Source
71
191k
  AnalysisUsage &addRequiredTransitive() {
72
191k
    return addRequiredTransitiveID(PassClass::ID);
73
191k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::LiveIntervals>()
Line
Count
Source
71
69.6k
  AnalysisUsage &addRequiredTransitive() {
72
69.6k
    return addRequiredTransitiveID(PassClass::ID);
73
69.6k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::SlotIndexes>()
Line
Count
Source
71
76.7k
  AnalysisUsage &addRequiredTransitive() {
72
76.7k
    return addRequiredTransitiveID(PassClass::ID);
73
76.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::VirtRegMap>()
Line
Count
Source
71
35.9k
  AnalysisUsage &addRequiredTransitive() {
72
35.9k
    return addRequiredTransitiveID(PassClass::ID);
73
35.9k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::EdgeBundles>()
Line
Count
Source
71
33.5k
  AnalysisUsage &addRequiredTransitive() {
72
33.5k
    return addRequiredTransitiveID(PassClass::ID);
73
33.5k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::MachineLoopInfo>()
Line
Count
Source
71
33.5k
  AnalysisUsage &addRequiredTransitive() {
72
33.5k
    return addRequiredTransitiveID(PassClass::ID);
73
33.5k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<polly::ScopInfoRegionPass>()
Line
Count
Source
71
1.24k
  AnalysisUsage &addRequiredTransitive() {
72
1.24k
    return addRequiredTransitiveID(PassClass::ID);
73
1.24k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<polly::ScopInfoWrapperPass>()
Line
Count
Source
71
45
  AnalysisUsage &addRequiredTransitive() {
72
45
    return addRequiredTransitiveID(PassClass::ID);
73
45
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<polly::DependenceInfoWrapperPass>()
Line
Count
Source
71
19
  AnalysisUsage &addRequiredTransitive() {
72
19
    return addRequiredTransitiveID(PassClass::ID);
73
19
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<llvm::RegionInfoPass>()
Line
Count
Source
71
1.29k
  AnalysisUsage &addRequiredTransitive() {
72
1.29k
    return addRequiredTransitiveID(PassClass::ID);
73
1.29k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addRequiredTransitive<polly::ScopDetectionWrapperPass>()
Line
Count
Source
71
1.18k
  AnalysisUsage &addRequiredTransitive() {
72
1.18k
    return addRequiredTransitiveID(PassClass::ID);
73
1.18k
  }
74
  ///@}
75
76
  ///@{
77
  /// Add the specified ID to the set of analyses preserved by this pass.
78
0
  AnalysisUsage &addPreservedID(const void *ID) {
79
0
    Preserved.push_back(ID);
80
0
    return *this;
81
0
  }
82
1.14M
  AnalysisUsage &addPreservedID(char &ID) {
83
1.14M
    Preserved.push_back(&ID);
84
1.14M
    return *this;
85
1.14M
  }
86
  /// Add the specified Pass class to the set of analyses preserved by this pass.
87
  template<class PassClass>
88
47.9M
  AnalysisUsage &addPreserved() {
89
47.9M
    Preserved.push_back(&PassClass::ID);
90
47.9M
    return *this;
91
47.9M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineDominatorTree>()
Line
Count
Source
88
414k
  AnalysisUsage &addPreserved() {
89
414k
    Preserved.push_back(&PassClass::ID);
90
414k
    return *this;
91
414k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineLoopInfo>()
Line
Count
Source
88
427k
  AnalysisUsage &addPreserved() {
89
427k
    Preserved.push_back(&PassClass::ID);
90
427k
    return *this;
91
427k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineTraceMetrics>()
Line
Count
Source
88
61.2k
  AnalysisUsage &addPreserved() {
89
61.2k
    Preserved.push_back(&PassClass::ID);
90
61.2k
    return *this;
91
61.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::DominatorTreeWrapperPass>()
Line
Count
Source
88
4.60M
  AnalysisUsage &addPreserved() {
89
4.60M
    Preserved.push_back(&PassClass::ID);
90
4.60M
    return *this;
91
4.60M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LoopInfoWrapperPass>()
Line
Count
Source
88
4.14M
  AnalysisUsage &addPreserved() {
89
4.14M
    Preserved.push_back(&PassClass::ID);
90
4.14M
    return *this;
91
4.14M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::ScalarEvolutionWrapperPass>()
Line
Count
Source
88
4.13M
  AnalysisUsage &addPreserved() {
89
4.13M
    Preserved.push_back(&PassClass::ID);
90
4.13M
    return *this;
91
4.13M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LegacyDivergenceAnalysis>()
Line
Count
Source
88
2.42k
  AnalysisUsage &addPreserved() {
89
2.42k
    Preserved.push_back(&PassClass::ID);
90
2.42k
    return *this;
91
2.42k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveIntervals>()
Line
Count
Source
88
220k
  AnalysisUsage &addPreserved() {
89
220k
    Preserved.push_back(&PassClass::ID);
90
220k
    return *this;
91
220k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::SlotIndexes>()
Line
Count
Source
88
364k
  AnalysisUsage &addPreserved() {
89
364k
    Preserved.push_back(&PassClass::ID);
90
364k
    return *this;
91
364k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::PostDominatorTreeWrapperPass>()
Line
Count
Source
88
27.2k
  AnalysisUsage &addPreserved() {
89
27.2k
    Preserved.push_back(&PassClass::ID);
90
27.2k
    return *this;
91
27.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::AAResultsWrapperPass>()
Line
Count
Source
88
4.32M
  AnalysisUsage &addPreserved() {
89
4.32M
    Preserved.push_back(&PassClass::ID);
90
4.32M
    return *this;
91
4.32M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::TargetLibraryInfoWrapperPass>()
Line
Count
Source
88
16.4k
  AnalysisUsage &addPreserved() {
89
16.4k
    Preserved.push_back(&PassClass::ID);
90
16.4k
    return *this;
91
16.4k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::StackProtector>()
Line
Count
Source
88
48.1k
  AnalysisUsage &addPreserved() {
89
48.1k
    Preserved.push_back(&PassClass::ID);
90
48.1k
    return *this;
91
48.1k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachinePostDominatorTree>()
Line
Count
Source
88
35.8k
  AnalysisUsage &addPreserved() {
89
35.8k
    Preserved.push_back(&PassClass::ID);
90
35.8k
    return *this;
91
35.8k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineBlockFrequencyInfo>()
Line
Count
Source
88
108k
  AnalysisUsage &addPreserved() {
89
108k
    Preserved.push_back(&PassClass::ID);
90
108k
    return *this;
91
108k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::WebAssemblyExceptionInfo>()
Line
Count
Source
88
426
  AnalysisUsage &addPreserved() {
89
426
    Preserved.push_back(&PassClass::ID);
90
426
    return *this;
91
426
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MachineModuleInfo>()
Line
Count
Source
88
3.71M
  AnalysisUsage &addPreserved() {
89
3.71M
    Preserved.push_back(&PassClass::ID);
90
3.71M
    return *this;
91
3.71M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::CallGraphWrapperPass>()
Line
Count
Source
88
79.7k
  AnalysisUsage &addPreserved() {
89
79.7k
    Preserved.push_back(&PassClass::ID);
90
79.7k
    return *this;
91
79.7k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveVariables>()
Line
Count
Source
88
115k
  AnalysisUsage &addPreserved() {
89
115k
    Preserved.push_back(&PassClass::ID);
90
115k
    return *this;
91
115k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::BasicAAWrapperPass>()
Line
Count
Source
88
4.19M
  AnalysisUsage &addPreserved() {
89
4.19M
    Preserved.push_back(&PassClass::ID);
90
4.19M
    return *this;
91
4.19M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::DominanceFrontierWrapperPass>()
Line
Count
Source
88
3.66M
  AnalysisUsage &addPreserved() {
89
3.66M
    Preserved.push_back(&PassClass::ID);
90
3.66M
    return *this;
91
3.66M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::GlobalsAAWrapperPass>()
Line
Count
Source
88
4.76M
  AnalysisUsage &addPreserved() {
89
4.76M
    Preserved.push_back(&PassClass::ID);
90
4.76M
    return *this;
91
4.76M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::IVUsersWrapperPass>()
Line
Count
Source
88
3.69M
  AnalysisUsage &addPreserved() {
89
3.69M
    Preserved.push_back(&PassClass::ID);
90
3.69M
    return *this;
91
3.69M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MemoryDependenceWrapperPass>()
Line
Count
Source
88
3.68M
  AnalysisUsage &addPreserved() {
89
3.68M
    Preserved.push_back(&PassClass::ID);
90
3.68M
    return *this;
91
3.68M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::SCEVAAWrapperPass>()
Line
Count
Source
88
4.06M
  AnalysisUsage &addPreserved() {
89
4.06M
    Preserved.push_back(&PassClass::ID);
90
4.06M
    return *this;
91
4.06M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveDebugVariables>()
Line
Count
Source
88
33.6k
  AnalysisUsage &addPreserved() {
89
33.6k
    Preserved.push_back(&PassClass::ID);
90
33.6k
    return *this;
91
33.6k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveStacks>()
Line
Count
Source
88
67.2k
  AnalysisUsage &addPreserved() {
89
67.2k
    Preserved.push_back(&PassClass::ID);
90
67.2k
    return *this;
91
67.2k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::VirtRegMap>()
Line
Count
Source
88
33.6k
  AnalysisUsage &addPreserved() {
89
33.6k
    Preserved.push_back(&PassClass::ID);
90
33.6k
    return *this;
91
33.6k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LiveRegMatrix>()
Line
Count
Source
88
33.6k
  AnalysisUsage &addPreserved() {
89
33.6k
    Preserved.push_back(&PassClass::ID);
90
33.6k
    return *this;
91
33.6k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::MemorySSAWrapperPass>()
Line
Count
Source
88
112k
  AnalysisUsage &addPreserved() {
89
112k
    Preserved.push_back(&PassClass::ID);
90
112k
    return *this;
91
112k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LazyValueInfoWrapperPass>()
Line
Count
Source
88
26.8k
  AnalysisUsage &addPreserved() {
89
26.8k
    Preserved.push_back(&PassClass::ID);
90
26.8k
    return *this;
91
26.8k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::DependenceAnalysisWrapperPass>()
Line
Count
Source
88
142k
  AnalysisUsage &addPreserved() {
89
142k
    Preserved.push_back(&PassClass::ID);
90
142k
    return *this;
91
142k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::BranchProbabilityInfoWrapperPass>()
Line
Count
Source
88
242k
  AnalysisUsage &addPreserved() {
89
242k
    Preserved.push_back(&PassClass::ID);
90
242k
    return *this;
91
242k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::LCSSAVerificationPass>()
Line
Count
Source
88
262k
  AnalysisUsage &addPreserved() {
89
262k
    Preserved.push_back(&PassClass::ID);
90
262k
    return *this;
91
262k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<polly::ScopDetectionWrapperPass>()
Line
Count
Source
88
988
  AnalysisUsage &addPreserved() {
89
988
    Preserved.push_back(&PassClass::ID);
90
988
    return *this;
91
988
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::OptimizationRemarkEmitterWrapperPass>()
Line
Count
Source
88
988
  AnalysisUsage &addPreserved() {
89
988
    Preserved.push_back(&PassClass::ID);
90
988
    return *this;
91
988
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::RegionInfoPass>()
Line
Count
Source
88
1.00k
  AnalysisUsage &addPreserved() {
89
1.00k
    Preserved.push_back(&PassClass::ID);
90
1.00k
    return *this;
91
1.00k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<polly::ScopInfoRegionPass>()
Line
Count
Source
88
988
  AnalysisUsage &addPreserved() {
89
988
    Preserved.push_back(&PassClass::ID);
90
988
    return *this;
91
988
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::TargetTransformInfoWrapperPass>()
Line
Count
Source
88
988
  AnalysisUsage &addPreserved() {
89
988
    Preserved.push_back(&PassClass::ID);
90
988
    return *this;
91
988
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<polly::DependenceInfo>()
Line
Count
Source
88
963
  AnalysisUsage &addPreserved() {
89
963
    Preserved.push_back(&PassClass::ID);
90
963
    return *this;
91
963
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<polly::IslAstInfoWrapperPass>()
Line
Count
Source
88
327
  AnalysisUsage &addPreserved() {
89
327
    Preserved.push_back(&PassClass::ID);
90
327
    return *this;
91
327
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::GISelCSEAnalysisWrapperPass>()
Line
Count
Source
88
7.34k
  AnalysisUsage &addPreserved() {
89
7.34k
    Preserved.push_back(&PassClass::ID);
90
7.34k
    return *this;
91
7.34k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addPreserved<llvm::GCModuleInfo>()
Line
Count
Source
88
37.8k
  AnalysisUsage &addPreserved() {
89
37.8k
    Preserved.push_back(&PassClass::ID);
90
37.8k
    return *this;
91
37.8k
  }
92
  ///@}
93
94
  ///@{
95
  /// Add the specified ID to the set of analyses used by this pass if they are
96
  /// available..
97
0
  AnalysisUsage &addUsedIfAvailableID(const void *ID) {
98
0
    Used.push_back(ID);
99
0
    return *this;
100
0
  }
101
0
  AnalysisUsage &addUsedIfAvailableID(char &ID) {
102
0
    Used.push_back(&ID);
103
0
    return *this;
104
0
  }
105
  /// Add the specified Pass class to the set of analyses used by this pass.
106
  template<class PassClass>
107
3.31M
  AnalysisUsage &addUsedIfAvailable() {
108
3.31M
    Used.push_back(&PassClass::ID);
109
3.31M
    return *this;
110
3.31M
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::ScopedNoAliasAAWrapperPass>()
Line
Count
Source
107
410k
  AnalysisUsage &addUsedIfAvailable() {
108
410k
    Used.push_back(&PassClass::ID);
109
410k
    return *this;
110
410k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::TypeBasedAAWrapperPass>()
Line
Count
Source
107
410k
  AnalysisUsage &addUsedIfAvailable() {
108
410k
    Used.push_back(&PassClass::ID);
109
410k
    return *this;
110
410k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::objcarc::ObjCARCAAWrapperPass>()
Line
Count
Source
107
410k
  AnalysisUsage &addUsedIfAvailable() {
108
410k
    Used.push_back(&PassClass::ID);
109
410k
    return *this;
110
410k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::GlobalsAAWrapperPass>()
Line
Count
Source
107
410k
  AnalysisUsage &addUsedIfAvailable() {
108
410k
    Used.push_back(&PassClass::ID);
109
410k
    return *this;
110
410k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::SCEVAAWrapperPass>()
Line
Count
Source
107
360k
  AnalysisUsage &addUsedIfAvailable() {
108
360k
    Used.push_back(&PassClass::ID);
109
360k
    return *this;
110
360k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::CFLAndersAAWrapperPass>()
Line
Count
Source
107
410k
  AnalysisUsage &addUsedIfAvailable() {
108
410k
    Used.push_back(&PassClass::ID);
109
410k
    return *this;
110
410k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::CFLSteensAAWrapperPass>()
Line
Count
Source
107
410k
  AnalysisUsage &addUsedIfAvailable() {
108
410k
    Used.push_back(&PassClass::ID);
109
410k
    return *this;
110
410k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::PhiValuesWrapperPass>()
Line
Count
Source
107
381k
  AnalysisUsage &addUsedIfAvailable() {
108
381k
    Used.push_back(&PassClass::ID);
109
381k
    return *this;
110
381k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::SlotIndexes>()
Line
Count
Source
107
1.14k
  AnalysisUsage &addUsedIfAvailable() {
108
1.14k
    Used.push_back(&PassClass::ID);
109
1.14k
    return *this;
110
1.14k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::LiveVariables>()
Line
Count
Source
107
72.1k
  AnalysisUsage &addUsedIfAvailable() {
108
72.1k
    Used.push_back(&PassClass::ID);
109
72.1k
    return *this;
110
72.1k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::AAResultsWrapperPass>()
Line
Count
Source
107
36.0k
  AnalysisUsage &addUsedIfAvailable() {
108
36.0k
    Used.push_back(&PassClass::ID);
109
36.0k
    return *this;
110
36.0k
  }
llvm::AnalysisUsage& llvm::AnalysisUsage::addUsedIfAvailable<llvm::AssumptionCacheTracker>()
Line
Count
Source
107
39
  AnalysisUsage &addUsedIfAvailable() {
108
39
    Used.push_back(&PassClass::ID);
109
39
    return *this;
110
39
  }
111
  ///@}
112
113
  /// Add the Pass with the specified argument string to the set of analyses
114
  /// preserved by this pass. If no such Pass exists, do nothing. This can be
115
  /// useful when a pass is trivially preserved, but may not be linked in. Be
116
  /// careful about spelling!
117
  AnalysisUsage &addPreserved(StringRef Arg);
118
119
  /// Set by analyses that do not transform their input at all
120
5.50M
  void setPreservesAll() { PreservesAll = true; }
121
122
  /// Determine whether a pass said it does not transform its input at all
123
203M
  bool getPreservesAll() const { return PreservesAll; }
124
125
  /// This function should be called by the pass, iff they do not:
126
  ///
127
  ///  1. Add or remove basic blocks from the function
128
  ///  2. Modify terminator instructions in any way.
129
  ///
130
  /// This function annotates the AnalysisUsage info object to say that analyses
131
  /// that only depend on the CFG are preserved by this pass.
132
  void setPreservesCFG();
133
134
214M
  const VectorType &getRequiredSet() const { return Required; }
135
61.8M
  const VectorType &getRequiredTransitiveSet() const {
136
61.8M
    return RequiredTransitive;
137
61.8M
  }
138
99.1M
  const VectorType &getPreservedSet() const { return Preserved; }
139
30.3M
  const VectorType &getUsedSet() const { return Used; }
140
};
141
142
//===----------------------------------------------------------------------===//
143
/// AnalysisResolver - Simple interface used by Pass objects to pull all
144
/// analysis information out of pass manager that is responsible to manage
145
/// the pass.
146
///
147
class AnalysisResolver {
148
public:
149
  AnalysisResolver() = delete;
150
10.2M
  explicit AnalysisResolver(PMDataManager &P) : PM(P) {}
151
152
132M
  PMDataManager &getPMDataManager() { return PM; }
153
154
  /// Find pass that is implementing PI.
155
796M
  Pass *findImplPass(AnalysisID PI) {
156
796M
    Pass *ResultPass = nullptr;
157
1.96G
    for (const auto &AnalysisImpl : AnalysisImpls) {
158
1.96G
      if (AnalysisImpl.first == PI) {
159
772M
        ResultPass = AnalysisImpl.second;
160
772M
        break;
161
772M
      }
162
1.96G
    }
163
796M
    return ResultPass;
164
796M
  }
165
166
  /// Find pass that is implementing PI. Initialize pass for Function F.
167
  Pass *findImplPass(Pass *P, AnalysisID PI, Function &F);
168
169
452M
  void addAnalysisImplsPair(AnalysisID PI, Pass *P) {
170
452M
    if (findImplPass(PI) == P)
171
428M
      return;
172
23.9M
    std::pair<AnalysisID, Pass*> pir = std::make_pair(PI,P);
173
23.9M
    AnalysisImpls.push_back(pir);
174
23.9M
  }
175
176
  /// Clear cache that is used to connect a pass to the analysis (PassInfo).
177
4.46M
  void clearAnalysisImpls() {
178
4.46M
    AnalysisImpls.clear();
179
4.46M
  }
180
181
  /// Return analysis result or null if it doesn't exist.
182
  Pass *getAnalysisIfAvailable(AnalysisID ID, bool Direction) const;
183
184
private:
185
  /// This keeps track of which passes implements the interfaces that are
186
  /// required by the current pass (to implement getAnalysis()).
187
  std::vector<std::pair<AnalysisID, Pass *>> AnalysisImpls;
188
189
  /// PassManager that is used to resolve analysis info
190
  PMDataManager &PM;
191
};
192
193
/// getAnalysisIfAvailable<AnalysisType>() - Subclasses use this function to
194
/// get analysis information that might be around, for example to update it.
195
/// This is different than getAnalysis in that it can fail (if the analysis
196
/// results haven't been computed), so should only be used if you can handle
197
/// the case when the analysis is not available.  This method is often used by
198
/// transformation APIs to update analysis results for a pass automatically as
199
/// the transform is performed.
200
template<typename AnalysisType>
201
145M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
145M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
145M
204
145M
  const void *PI = &AnalysisType::ID;
205
145M
206
145M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
145M
  if (!ResultPass) 
return nullptr86.0M
;
208
59.4M
209
59.4M
  // Because the AnalysisType may not be a subclass of pass (for
210
59.4M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
59.4M
  // adjust the return pointer (because the class may multiply inherit, once
212
59.4M
  // from pass, once from AnalysisType).
213
59.4M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
59.4M
}
llvm::MachineLoopInfo* llvm::Pass::getAnalysisIfAvailable<llvm::MachineLoopInfo>() const
Line
Count
Source
201
1.98M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
1.98M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
1.98M
204
1.98M
  const void *PI = &AnalysisType::ID;
205
1.98M
206
1.98M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
1.98M
  if (!ResultPass) 
return nullptr413k
;
208
1.57M
209
1.57M
  // Because the AnalysisType may not be a subclass of pass (for
210
1.57M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
1.57M
  // adjust the return pointer (because the class may multiply inherit, once
212
1.57M
  // from pass, once from AnalysisType).
213
1.57M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
1.57M
}
llvm::DominatorTreeWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::DominatorTreeWrapperPass>() const
Line
Count
Source
201
5.85M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
5.85M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
5.85M
204
5.85M
  const void *PI = &AnalysisType::ID;
205
5.85M
206
5.85M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
5.85M
  if (!ResultPass) 
return nullptr1.02M
;
208
4.82M
209
4.82M
  // Because the AnalysisType may not be a subclass of pass (for
210
4.82M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
4.82M
  // adjust the return pointer (because the class may multiply inherit, once
212
4.82M
  // from pass, once from AnalysisType).
213
4.82M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
4.82M
}
llvm::AMDGPUAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::AMDGPUAAWrapperPass>() const
Line
Count
Source
201
198k
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
198k
  assert(Resolver && "Pass not resident in a PassManager object!");
203
198k
204
198k
  const void *PI = &AnalysisType::ID;
205
198k
206
198k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
198k
  if (!ResultPass) 
return nullptr0
;
208
198k
209
198k
  // Because the AnalysisType may not be a subclass of pass (for
210
198k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
198k
  // adjust the return pointer (because the class may multiply inherit, once
212
198k
  // from pass, once from AnalysisType).
213
198k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
198k
}
llvm::TargetPassConfig* llvm::Pass::getAnalysisIfAvailable<llvm::TargetPassConfig>() const
Line
Count
Source
201
4.98M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
4.98M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
4.98M
204
4.98M
  const void *PI = &AnalysisType::ID;
205
4.98M
206
4.98M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
4.98M
  if (!ResultPass) 
return nullptr23
;
208
4.98M
209
4.98M
  // Because the AnalysisType may not be a subclass of pass (for
210
4.98M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
4.98M
  // adjust the return pointer (because the class may multiply inherit, once
212
4.98M
  // from pass, once from AnalysisType).
213
4.98M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
4.98M
}
llvm::LiveIntervals* llvm::Pass::getAnalysisIfAvailable<llvm::LiveIntervals>() const
Line
Count
Source
201
3.55M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
3.55M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
3.55M
204
3.55M
  const void *PI = &AnalysisType::ID;
205
3.55M
206
3.55M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
3.55M
  if (!ResultPass) 
return nullptr3.26M
;
208
289k
209
289k
  // Because the AnalysisType may not be a subclass of pass (for
210
289k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
289k
  // adjust the return pointer (because the class may multiply inherit, once
212
289k
  // from pass, once from AnalysisType).
213
289k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
289k
}
llvm::VirtRegMap* llvm::Pass::getAnalysisIfAvailable<llvm::VirtRegMap>() const
Line
Count
Source
201
25.4k
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
25.4k
  assert(Resolver && "Pass not resident in a PassManager object!");
203
25.4k
204
25.4k
  const void *PI = &AnalysisType::ID;
205
25.4k
206
25.4k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
25.4k
  if (!ResultPass) return nullptr;
208
0
209
0
  // Because the AnalysisType may not be a subclass of pass (for
210
0
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
0
  // adjust the return pointer (because the class may multiply inherit, once
212
0
  // from pass, once from AnalysisType).
213
0
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
0
}
llvm::ScopedNoAliasAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::ScopedNoAliasAAWrapperPass>() const
Line
Count
Source
201
10.5M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
10.5M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
10.5M
204
10.5M
  const void *PI = &AnalysisType::ID;
205
10.5M
206
10.5M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
10.5M
  if (!ResultPass) 
return nullptr54.2k
;
208
10.5M
209
10.5M
  // Because the AnalysisType may not be a subclass of pass (for
210
10.5M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
10.5M
  // adjust the return pointer (because the class may multiply inherit, once
212
10.5M
  // from pass, once from AnalysisType).
213
10.5M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
10.5M
}
llvm::TypeBasedAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::TypeBasedAAWrapperPass>() const
Line
Count
Source
201
10.5M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
10.5M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
10.5M
204
10.5M
  const void *PI = &AnalysisType::ID;
205
10.5M
206
10.5M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
10.5M
  if (!ResultPass) 
return nullptr54.0k
;
208
10.5M
209
10.5M
  // Because the AnalysisType may not be a subclass of pass (for
210
10.5M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
10.5M
  // adjust the return pointer (because the class may multiply inherit, once
212
10.5M
  // from pass, once from AnalysisType).
213
10.5M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
10.5M
}
llvm::objcarc::ObjCARCAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::objcarc::ObjCARCAAWrapperPass>() const
Line
Count
Source
201
10.5M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
10.5M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
10.5M
204
10.5M
  const void *PI = &AnalysisType::ID;
205
10.5M
206
10.5M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
10.5M
  if (!ResultPass) 
return nullptr10.5M
;
208
1.41k
209
1.41k
  // Because the AnalysisType may not be a subclass of pass (for
210
1.41k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
1.41k
  // adjust the return pointer (because the class may multiply inherit, once
212
1.41k
  // from pass, once from AnalysisType).
213
1.41k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
1.41k
}
llvm::GlobalsAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::GlobalsAAWrapperPass>() const
Line
Count
Source
201
10.5M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
10.5M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
10.5M
204
10.5M
  const void *PI = &AnalysisType::ID;
205
10.5M
206
10.5M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
10.5M
  if (!ResultPass) 
return nullptr2.47M
;
208
8.10M
209
8.10M
  // Because the AnalysisType may not be a subclass of pass (for
210
8.10M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
8.10M
  // adjust the return pointer (because the class may multiply inherit, once
212
8.10M
  // from pass, once from AnalysisType).
213
8.10M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
8.10M
}
llvm::SCEVAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::SCEVAAWrapperPass>() const
Line
Count
Source
201
9.40M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
9.40M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
9.40M
204
9.40M
  const void *PI = &AnalysisType::ID;
205
9.40M
206
9.40M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
9.40M
  if (!ResultPass) 
return nullptr9.40M
;
208
6
209
6
  // Because the AnalysisType may not be a subclass of pass (for
210
6
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
6
  // adjust the return pointer (because the class may multiply inherit, once
212
6
  // from pass, once from AnalysisType).
213
6
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
6
}
llvm::CFLAndersAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::CFLAndersAAWrapperPass>() const
Line
Count
Source
201
10.5M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
10.5M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
10.5M
204
10.5M
  const void *PI = &AnalysisType::ID;
205
10.5M
206
10.5M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
10.5M
  if (!ResultPass) 
return nullptr10.5M
;
208
40
209
40
  // Because the AnalysisType may not be a subclass of pass (for
210
40
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
40
  // adjust the return pointer (because the class may multiply inherit, once
212
40
  // from pass, once from AnalysisType).
213
40
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
40
}
llvm::CFLSteensAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::CFLSteensAAWrapperPass>() const
Line
Count
Source
201
10.5M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
10.5M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
10.5M
204
10.5M
  const void *PI = &AnalysisType::ID;
205
10.5M
206
10.5M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
10.5M
  if (!ResultPass) 
return nullptr10.5M
;
208
59
209
59
  // Because the AnalysisType may not be a subclass of pass (for
210
59
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
59
  // adjust the return pointer (because the class may multiply inherit, once
212
59
  // from pass, once from AnalysisType).
213
59
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
59
}
llvm::ExternalAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::ExternalAAWrapperPass>() const
Line
Count
Source
201
9.40M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
9.40M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
9.40M
204
9.40M
  const void *PI = &AnalysisType::ID;
205
9.40M
206
9.40M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
9.40M
  if (!ResultPass) 
return nullptr9.20M
;
208
198k
209
198k
  // Because the AnalysisType may not be a subclass of pass (for
210
198k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
198k
  // adjust the return pointer (because the class may multiply inherit, once
212
198k
  // from pass, once from AnalysisType).
213
198k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
198k
}
llvm::LoopInfoWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::LoopInfoWrapperPass>() const
Line
Count
Source
201
13.5M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
13.5M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
13.5M
204
13.5M
  const void *PI = &AnalysisType::ID;
205
13.5M
206
13.5M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
13.5M
  if (!ResultPass) 
return nullptr6.47M
;
208
7.06M
209
7.06M
  // Because the AnalysisType may not be a subclass of pass (for
210
7.06M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
7.06M
  // adjust the return pointer (because the class may multiply inherit, once
212
7.06M
  // from pass, once from AnalysisType).
213
7.06M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
7.06M
}
llvm::PhiValuesWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::PhiValuesWrapperPass>() const
Line
Count
Source
201
9.61M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
9.61M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
9.61M
204
9.61M
  const void *PI = &AnalysisType::ID;
205
9.61M
206
9.61M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
9.61M
  if (!ResultPass) 
return nullptr8.66M
;
208
952k
209
952k
  // Because the AnalysisType may not be a subclass of pass (for
210
952k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
952k
  // adjust the return pointer (because the class may multiply inherit, once
212
952k
  // from pass, once from AnalysisType).
213
952k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
952k
}
llvm::TargetTransformInfoWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::TargetTransformInfoWrapperPass>() const
Line
Count
Source
201
360k
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
360k
  assert(Resolver && "Pass not resident in a PassManager object!");
203
360k
204
360k
  const void *PI = &AnalysisType::ID;
205
360k
206
360k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
360k
  if (!ResultPass) 
return nullptr0
;
208
360k
209
360k
  // Because the AnalysisType may not be a subclass of pass (for
210
360k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
360k
  // adjust the return pointer (because the class may multiply inherit, once
212
360k
  // from pass, once from AnalysisType).
213
360k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
360k
}
llvm::TargetLibraryInfoWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::TargetLibraryInfoWrapperPass>() const
Line
Count
Source
201
2.98M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
2.98M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
2.98M
204
2.98M
  const void *PI = &AnalysisType::ID;
205
2.98M
206
2.98M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
2.98M
  if (!ResultPass) 
return nullptr0
;
208
2.98M
209
2.98M
  // Because the AnalysisType may not be a subclass of pass (for
210
2.98M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
2.98M
  // adjust the return pointer (because the class may multiply inherit, once
212
2.98M
  // from pass, once from AnalysisType).
213
2.98M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
2.98M
}
llvm::AssumptionCacheTracker* llvm::Pass::getAnalysisIfAvailable<llvm::AssumptionCacheTracker>() const
Line
Count
Source
201
1.38M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
1.38M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
1.38M
204
1.38M
  const void *PI = &AnalysisType::ID;
205
1.38M
206
1.38M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
1.38M
  if (!ResultPass) 
return nullptr41
;
208
1.38M
209
1.38M
  // Because the AnalysisType may not be a subclass of pass (for
210
1.38M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
1.38M
  // adjust the return pointer (because the class may multiply inherit, once
212
1.38M
  // from pass, once from AnalysisType).
213
1.38M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
1.38M
}
llvm::MachineModuleInfo* llvm::Pass::getAnalysisIfAvailable<llvm::MachineModuleInfo>() const
Line
Count
Source
201
1.18M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
1.18M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
1.18M
204
1.18M
  const void *PI = &AnalysisType::ID;
205
1.18M
206
1.18M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
1.18M
  if (!ResultPass) 
return nullptr0
;
208
1.18M
209
1.18M
  // Because the AnalysisType may not be a subclass of pass (for
210
1.18M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
1.18M
  // adjust the return pointer (because the class may multiply inherit, once
212
1.18M
  // from pass, once from AnalysisType).
213
1.18M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
1.18M
}
llvm::GCModuleInfo* llvm::Pass::getAnalysisIfAvailable<llvm::GCModuleInfo>() const
Line
Count
Source
201
130k
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
130k
  assert(Resolver && "Pass not resident in a PassManager object!");
203
130k
204
130k
  const void *PI = &AnalysisType::ID;
205
130k
206
130k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
130k
  if (!ResultPass) 
return nullptr0
;
208
130k
209
130k
  // Because the AnalysisType may not be a subclass of pass (for
210
130k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
130k
  // adjust the return pointer (because the class may multiply inherit, once
212
130k
  // from pass, once from AnalysisType).
213
130k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
130k
}
llvm::MachineBlockFrequencyInfo* llvm::Pass::getAnalysisIfAvailable<llvm::MachineBlockFrequencyInfo>() const
Line
Count
Source
201
60
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
60
  assert(Resolver && "Pass not resident in a PassManager object!");
203
60
204
60
  const void *PI = &AnalysisType::ID;
205
60
206
60
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
60
  if (!ResultPass) 
return nullptr20
;
208
40
209
40
  // Because the AnalysisType may not be a subclass of pass (for
210
40
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
40
  // adjust the return pointer (because the class may multiply inherit, once
212
40
  // from pass, once from AnalysisType).
213
40
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
40
}
llvm::MachineDominatorTree* llvm::Pass::getAnalysisIfAvailable<llvm::MachineDominatorTree>() const
Line
Count
Source
201
965k
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
965k
  assert(Resolver && "Pass not resident in a PassManager object!");
203
965k
204
965k
  const void *PI = &AnalysisType::ID;
205
965k
206
965k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
965k
  if (!ResultPass) 
return nullptr408k
;
208
556k
209
556k
  // Because the AnalysisType may not be a subclass of pass (for
210
556k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
556k
  // adjust the return pointer (because the class may multiply inherit, once
212
556k
  // from pass, once from AnalysisType).
213
556k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
556k
}
llvm::SlotIndexes* llvm::Pass::getAnalysisIfAvailable<llvm::SlotIndexes>() const
Line
Count
Source
201
2.53M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
2.53M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
2.53M
204
2.53M
  const void *PI = &AnalysisType::ID;
205
2.53M
206
2.53M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
2.53M
  if (!ResultPass) 
return nullptr2.19M
;
208
339k
209
339k
  // Because the AnalysisType may not be a subclass of pass (for
210
339k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
339k
  // adjust the return pointer (because the class may multiply inherit, once
212
339k
  // from pass, once from AnalysisType).
213
339k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
339k
}
llvm::LiveVariables* llvm::Pass::getAnalysisIfAvailable<llvm::LiveVariables>() const
Line
Count
Source
201
3.23M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
3.23M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
3.23M
204
3.23M
  const void *PI = &AnalysisType::ID;
205
3.23M
206
3.23M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
3.23M
  if (!ResultPass) 
return nullptr2.11M
;
208
1.12M
209
1.12M
  // Because the AnalysisType may not be a subclass of pass (for
210
1.12M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
1.12M
  // adjust the return pointer (because the class may multiply inherit, once
212
1.12M
  // from pass, once from AnalysisType).
213
1.12M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
1.12M
}
llvm::LiveStacks* llvm::Pass::getAnalysisIfAvailable<llvm::LiveStacks>() const
Line
Count
Source
201
2.27M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
2.27M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
2.27M
204
2.27M
  const void *PI = &AnalysisType::ID;
205
2.27M
206
2.27M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
2.27M
  if (!ResultPass) 
return nullptr2.13M
;
208
146k
209
146k
  // Because the AnalysisType may not be a subclass of pass (for
210
146k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
146k
  // adjust the return pointer (because the class may multiply inherit, once
212
146k
  // from pass, once from AnalysisType).
213
146k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
146k
}
llvm::AAResultsWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::AAResultsWrapperPass>() const
Line
Count
Source
201
498k
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
498k
  assert(Resolver && "Pass not resident in a PassManager object!");
203
498k
204
498k
  const void *PI = &AnalysisType::ID;
205
498k
206
498k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
498k
  if (!ResultPass) 
return nullptr8.14k
;
208
490k
209
490k
  // Because the AnalysisType may not be a subclass of pass (for
210
490k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
490k
  // adjust the return pointer (because the class may multiply inherit, once
212
490k
  // from pass, once from AnalysisType).
213
490k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
490k
}
llvm::CallGraphWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::CallGraphWrapperPass>() const
Line
Count
Source
201
13
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
13
  assert(Resolver && "Pass not resident in a PassManager object!");
203
13
204
13
  const void *PI = &AnalysisType::ID;
205
13
206
13
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
13
  if (!ResultPass) return nullptr;
208
0
209
0
  // Because the AnalysisType may not be a subclass of pass (for
210
0
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
0
  // adjust the return pointer (because the class may multiply inherit, once
212
0
  // from pass, once from AnalysisType).
213
0
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
0
}
llvm::PostDominatorTreeWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::PostDominatorTreeWrapperPass>() const
Line
Count
Source
201
465k
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
465k
  assert(Resolver && "Pass not resident in a PassManager object!");
203
465k
204
465k
  const void *PI = &AnalysisType::ID;
205
465k
206
465k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
465k
  if (
!ResultPass465k
) return nullptr;
208
18.4E
209
18.4E
  // Because the AnalysisType may not be a subclass of pass (for
210
18.4E
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
18.4E
  // adjust the return pointer (because the class may multiply inherit, once
212
18.4E
  // from pass, once from AnalysisType).
213
18.4E
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
18.4E
}
llvm::ScalarEvolutionWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::ScalarEvolutionWrapperPass>() const
Line
Count
Source
201
7.08M
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
7.08M
  assert(Resolver && "Pass not resident in a PassManager object!");
203
7.08M
204
7.08M
  const void *PI = &AnalysisType::ID;
205
7.08M
206
7.08M
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
7.08M
  if (!ResultPass) 
return nullptr5.61M
;
208
1.46M
209
1.46M
  // Because the AnalysisType may not be a subclass of pass (for
210
1.46M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
1.46M
  // adjust the return pointer (because the class may multiply inherit, once
212
1.46M
  // from pass, once from AnalysisType).
213
1.46M
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
1.46M
}
llvm::MemorySSAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::MemorySSAWrapperPass>() const
Line
Count
Source
201
273
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
273
  assert(Resolver && "Pass not resident in a PassManager object!");
203
273
204
273
  const void *PI = &AnalysisType::ID;
205
273
206
273
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
273
  if (!ResultPass) 
return nullptr3
;
208
270
209
270
  // Because the AnalysisType may not be a subclass of pass (for
210
270
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
270
  // adjust the return pointer (because the class may multiply inherit, once
212
270
  // from pass, once from AnalysisType).
213
270
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
270
}
llvm::RegionInfoPass* llvm::Pass::getAnalysisIfAvailable<llvm::RegionInfoPass>() const
Line
Count
Source
201
13
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
13
  assert(Resolver && "Pass not resident in a PassManager object!");
203
13
204
13
  const void *PI = &AnalysisType::ID;
205
13
206
13
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
13
  if (!ResultPass) return nullptr;
208
0
209
0
  // Because the AnalysisType may not be a subclass of pass (for
210
0
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
0
  // adjust the return pointer (because the class may multiply inherit, once
212
0
  // from pass, once from AnalysisType).
213
0
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
0
}
Unexecuted instantiation: llvm::MachineBranchProbabilityInfo* llvm::Pass::getAnalysisIfAvailable<llvm::MachineBranchProbabilityInfo>() const
llvm::LegacyDivergenceAnalysis* llvm::Pass::getAnalysisIfAvailable<llvm::LegacyDivergenceAnalysis>() const
Line
Count
Source
201
278k
AnalysisType *Pass::getAnalysisIfAvailable() const {
202
278k
  assert(Resolver && "Pass not resident in a PassManager object!");
203
278k
204
278k
  const void *PI = &AnalysisType::ID;
205
278k
206
278k
  Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
207
278k
  if (!ResultPass) 
return nullptr250k
;
208
27.4k
209
27.4k
  // Because the AnalysisType may not be a subclass of pass (for
210
27.4k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
211
27.4k
  // adjust the return pointer (because the class may multiply inherit, once
212
27.4k
  // from pass, once from AnalysisType).
213
27.4k
  return (AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
214
27.4k
}
215
216
/// getAnalysis<AnalysisType>() - This function is used by subclasses to get
217
/// to the analysis information that they claim to use by overriding the
218
/// getAnalysisUsage function.
219
template<typename AnalysisType>
220
344M
AnalysisType &Pass::getAnalysis() const {
221
344M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
344M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
344M
}
llvm::MachineDominatorTree& llvm::Pass::getAnalysis<llvm::MachineDominatorTree>() const
Line
Count
Source
220
8.02M
AnalysisType &Pass::getAnalysis() const {
221
8.02M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
8.02M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
8.02M
}
llvm::MachineBranchProbabilityInfo& llvm::Pass::getAnalysis<llvm::MachineBranchProbabilityInfo>() const
Line
Count
Source
220
4.45M
AnalysisType &Pass::getAnalysis() const {
221
4.45M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
4.45M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
4.45M
}
llvm::MachineTraceMetrics& llvm::Pass::getAnalysis<llvm::MachineTraceMetrics>() const
Line
Count
Source
220
1.19M
AnalysisType &Pass::getAnalysis() const {
221
1.19M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
1.19M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
1.19M
}
llvm::TargetPassConfig& llvm::Pass::getAnalysis<llvm::TargetPassConfig>() const
Line
Count
Source
220
3.78M
AnalysisType &Pass::getAnalysis() const {
221
3.78M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
3.78M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
3.78M
}
llvm::LoopInfoWrapperPass& llvm::Pass::getAnalysis<llvm::LoopInfoWrapperPass>() const
Line
Count
Source
220
35.2M
AnalysisType &Pass::getAnalysis() const {
221
35.2M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
35.2M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
35.2M
}
llvm::ScalarEvolutionWrapperPass& llvm::Pass::getAnalysis<llvm::ScalarEvolutionWrapperPass>() const
Line
Count
Source
220
3.85M
AnalysisType &Pass::getAnalysis() const {
221
3.85M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
3.85M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
3.85M
}
llvm::MachineLoopInfo& llvm::Pass::getAnalysis<llvm::MachineLoopInfo>() const
Line
Count
Source
220
9.00M
AnalysisType &Pass::getAnalysis() const {
221
9.00M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
9.00M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
9.00M
}
llvm::AAResultsWrapperPass& llvm::Pass::getAnalysis<llvm::AAResultsWrapperPass>() const
Line
Count
Source
220
17.2M
AnalysisType &Pass::getAnalysis() const {
221
17.2M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
17.2M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
17.2M
}
llvm::LegacyDivergenceAnalysis& llvm::Pass::getAnalysis<llvm::LegacyDivergenceAnalysis>() const
Line
Count
Source
220
78.4k
AnalysisType &Pass::getAnalysis() const {
221
78.4k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
78.4k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
78.4k
}
llvm::MemoryDependenceWrapperPass& llvm::Pass::getAnalysis<llvm::MemoryDependenceWrapperPass>() const
Line
Count
Source
220
1.42M
AnalysisType &Pass::getAnalysis() const {
221
1.42M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
1.42M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
1.42M
}
llvm::AssumptionCacheTracker& llvm::Pass::getAnalysis<llvm::AssumptionCacheTracker>() const
Line
Count
Source
220
35.9M
AnalysisType &Pass::getAnalysis() const {
221
35.9M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
35.9M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
35.9M
}
llvm::TargetTransformInfoWrapperPass& llvm::Pass::getAnalysis<llvm::TargetTransformInfoWrapperPass>() const
Line
Count
Source
220
14.4M
AnalysisType &Pass::getAnalysis() const {
221
14.4M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
14.4M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
14.4M
}
Unexecuted instantiation: llvm::MachineRegionInfoPass& llvm::Pass::getAnalysis<llvm::MachineRegionInfoPass>() const
llvm::PostDominatorTreeWrapperPass& llvm::Pass::getAnalysis<llvm::PostDominatorTreeWrapperPass>() const
Line
Count
Source
220
650k
AnalysisType &Pass::getAnalysis() const {
221
650k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
650k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
650k
}
llvm::MachinePostDominatorTree& llvm::Pass::getAnalysis<llvm::MachinePostDominatorTree>() const
Line
Count
Source
220
1.03M
AnalysisType &Pass::getAnalysis() const {
221
1.03M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
1.03M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
1.03M
}
llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysis<llvm::DominatorTreeWrapperPass>() const
Line
Count
Source
220
47.2M
AnalysisType &Pass::getAnalysis() const {
221
47.2M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
47.2M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
47.2M
}
llvm::LiveIntervals& llvm::Pass::getAnalysis<llvm::LiveIntervals>() const
Line
Count
Source
220
3.56M
AnalysisType &Pass::getAnalysis() const {
221
3.56M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
3.56M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
3.56M
}
llvm::LiveRegMatrix& llvm::Pass::getAnalysis<llvm::LiveRegMatrix>() const
Line
Count
Source
220
514k
AnalysisType &Pass::getAnalysis() const {
221
514k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
514k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
514k
}
llvm::VirtRegMap& llvm::Pass::getAnalysis<llvm::VirtRegMap>() const
Line
Count
Source
220
1.50M
AnalysisType &Pass::getAnalysis() const {
221
1.50M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
1.50M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
1.50M
}
llvm::AMDGPUArgumentUsageInfo& llvm::Pass::getAnalysis<llvm::AMDGPUArgumentUsageInfo>() const
Line
Count
Source
220
25.8k
AnalysisType &Pass::getAnalysis() const {
221
25.8k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
25.8k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
25.8k
}
llvm::TargetLibraryInfoWrapperPass& llvm::Pass::getAnalysis<llvm::TargetLibraryInfoWrapperPass>() const
Line
Count
Source
220
49.2M
AnalysisType &Pass::getAnalysis() const {
221
49.2M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
49.2M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
49.2M
}
llvm::MachineDominanceFrontier& llvm::Pass::getAnalysis<llvm::MachineDominanceFrontier>() const
Line
Count
Source
220
11.1k
AnalysisType &Pass::getAnalysis() const {
221
11.1k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
11.1k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
11.1k
}
llvm::MachineBlockFrequencyInfo& llvm::Pass::getAnalysis<llvm::MachineBlockFrequencyInfo>() const
Line
Count
Source
220
4.49M
AnalysisType &Pass::getAnalysis() const {
221
4.49M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
4.49M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
4.49M
}
llvm::WebAssemblyExceptionInfo& llvm::Pass::getAnalysis<llvm::WebAssemblyExceptionInfo>() const
Line
Count
Source
220
4.52k
AnalysisType &Pass::getAnalysis() const {
221
4.52k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
4.52k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
4.52k
}
llvm::EdgeBundles& llvm::Pass::getAnalysis<llvm::EdgeBundles>() const
Line
Count
Source
220
970k
AnalysisType &Pass::getAnalysis() const {
221
970k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
970k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
970k
}
llvm::MachineModuleInfo& llvm::Pass::getAnalysis<llvm::MachineModuleInfo>() const
Line
Count
Source
220
52.8M
AnalysisType &Pass::getAnalysis() const {
221
52.8M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
52.8M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
52.8M
}
llvm::BasicAAWrapperPass& llvm::Pass::getAnalysis<llvm::BasicAAWrapperPass>() const
Line
Count
Source
220
9.40M
AnalysisType &Pass::getAnalysis() const {
221
9.40M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
9.40M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
9.40M
}
llvm::BranchProbabilityInfoWrapperPass& llvm::Pass::getAnalysis<llvm::BranchProbabilityInfoWrapperPass>() const
Line
Count
Source
220
2.07M
AnalysisType &Pass::getAnalysis() const {
221
2.07M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
2.07M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
2.07M
}
llvm::CallGraphWrapperPass& llvm::Pass::getAnalysis<llvm::CallGraphWrapperPass>() const
Line
Count
Source
220
2.19M
AnalysisType &Pass::getAnalysis() const {
221
2.19M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
2.19M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
2.19M
}
llvm::LazyBranchProbabilityInfoPass& llvm::Pass::getAnalysis<llvm::LazyBranchProbabilityInfoPass>() const
Line
Count
Source
220
6.22M
AnalysisType &Pass::getAnalysis() const {
221
6.22M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
6.22M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
6.22M
}
llvm::LazyValueInfoWrapperPass& llvm::Pass::getAnalysis<llvm::LazyValueInfoWrapperPass>() const
Line
Count
Source
220
1.91M
AnalysisType &Pass::getAnalysis() const {
221
1.91M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
1.91M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
1.91M
}
llvm::PhiValuesWrapperPass& llvm::Pass::getAnalysis<llvm::PhiValuesWrapperPass>() const
Line
Count
Source
220
1.42M
AnalysisType &Pass::getAnalysis() const {
221
1.42M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
1.42M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
1.42M
}
llvm::MemorySSAWrapperPass& llvm::Pass::getAnalysis<llvm::MemorySSAWrapperPass>() const
Line
Count
Source
220
723k
AnalysisType &Pass::getAnalysis() const {
221
723k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
723k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
723k
}
llvm::ProfileSummaryInfoWrapperPass& llvm::Pass::getAnalysis<llvm::ProfileSummaryInfoWrapperPass>() const
Line
Count
Source
220
5.56M
AnalysisType &Pass::getAnalysis() const {
221
5.56M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
5.56M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
5.56M
}
llvm::LazyBlockFrequencyInfoPass& llvm::Pass::getAnalysis<llvm::LazyBlockFrequencyInfoPass>() const
Line
Count
Source
220
653
AnalysisType &Pass::getAnalysis() const {
221
653
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
653
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
653
}
llvm::DominanceFrontierWrapperPass& llvm::Pass::getAnalysis<llvm::DominanceFrontierWrapperPass>() const
Line
Count
Source
220
29.0k
AnalysisType &Pass::getAnalysis() const {
221
29.0k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
29.0k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
29.0k
}
llvm::RegionInfoPass& llvm::Pass::getAnalysis<llvm::RegionInfoPass>() const
Line
Count
Source
220
30.5k
AnalysisType &Pass::getAnalysis() const {
221
30.5k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
30.5k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
30.5k
}
llvm::ReachingDefAnalysis& llvm::Pass::getAnalysis<llvm::ReachingDefAnalysis>() const
Line
Count
Source
220
288k
AnalysisType &Pass::getAnalysis() const {
221
288k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
288k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
288k
}
llvm::GCModuleInfo& llvm::Pass::getAnalysis<llvm::GCModuleInfo>() const
Line
Count
Source
220
243
AnalysisType &Pass::getAnalysis() const {
221
243
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
243
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
243
}
llvm::LiveStacks& llvm::Pass::getAnalysis<llvm::LiveStacks>() const
Line
Count
Source
220
1.45M
AnalysisType &Pass::getAnalysis() const {
221
1.45M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
1.45M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
1.45M
}
llvm::SlotIndexes& llvm::Pass::getAnalysis<llvm::SlotIndexes>() const
Line
Count
Source
220
2.02M
AnalysisType &Pass::getAnalysis() const {
221
2.02M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
2.02M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
2.02M
}
llvm::LazyMachineBlockFrequencyInfoPass& llvm::Pass::getAnalysis<llvm::LazyMachineBlockFrequencyInfoPass>() const
Line
Count
Source
220
60
AnalysisType &Pass::getAnalysis() const {
221
60
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
60
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
60
}
llvm::MachineOptimizationRemarkEmitterPass& llvm::Pass::getAnalysis<llvm::MachineOptimizationRemarkEmitterPass>() const
Line
Count
Source
220
1.84M
AnalysisType &Pass::getAnalysis() const {
221
1.84M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
1.84M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
1.84M
}
llvm::SpillPlacement& llvm::Pass::getAnalysis<llvm::SpillPlacement>() const
Line
Count
Source
220
484k
AnalysisType &Pass::getAnalysis() const {
221
484k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
484k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
484k
}
llvm::LiveDebugVariables& llvm::Pass::getAnalysis<llvm::LiveDebugVariables>() const
Line
Count
Source
220
968k
AnalysisType &Pass::getAnalysis() const {
221
968k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
968k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
968k
}
llvm::PhysicalRegisterUsageInfo& llvm::Pass::getAnalysis<llvm::PhysicalRegisterUsageInfo>() const
Line
Count
Source
220
25.2k
AnalysisType &Pass::getAnalysis() const {
221
25.2k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
25.2k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
25.2k
}
llvm::ModuleSummaryIndexWrapperPass& llvm::Pass::getAnalysis<llvm::ModuleSummaryIndexWrapperPass>() const
Line
Count
Source
220
390
AnalysisType &Pass::getAnalysis() const {
221
390
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
390
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
390
}
llvm::OptimizationRemarkEmitterWrapperPass& llvm::Pass::getAnalysis<llvm::OptimizationRemarkEmitterWrapperPass>() const
Line
Count
Source
220
6.22M
AnalysisType &Pass::getAnalysis() const {
221
6.22M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
6.22M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
6.22M
}
AddressSanitizer.cpp:(anonymous namespace)::ASanGlobalsMetadataWrapperPass& llvm::Pass::getAnalysis<(anonymous namespace)::ASanGlobalsMetadataWrapperPass>() const
Line
Count
Source
220
971
AnalysisType &Pass::getAnalysis() const {
221
971
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
971
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
971
}
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysis<llvm::BlockFrequencyInfoWrapperPass>() const
Line
Count
Source
220
1.41M
AnalysisType &Pass::getAnalysis() const {
221
1.41M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
1.41M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
1.41M
}
llvm::DemandedBitsWrapperPass& llvm::Pass::getAnalysis<llvm::DemandedBitsWrapperPass>() const
Line
Count
Source
220
1.02M
AnalysisType &Pass::getAnalysis() const {
221
1.02M
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
1.02M
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
1.02M
}
llvm::LoopAccessLegacyAnalysis& llvm::Pass::getAnalysis<llvm::LoopAccessLegacyAnalysis>() const
Line
Count
Source
220
836k
AnalysisType &Pass::getAnalysis() const {
221
836k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
836k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
836k
}
llvm::DependenceAnalysisWrapperPass& llvm::Pass::getAnalysis<llvm::DependenceAnalysisWrapperPass>() const
Line
Count
Source
220
168
AnalysisType &Pass::getAnalysis() const {
221
168
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
168
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
168
}
llvm::IVUsersWrapperPass& llvm::Pass::getAnalysis<llvm::IVUsersWrapperPass>() const
Line
Count
Source
220
208k
AnalysisType &Pass::getAnalysis() const {
221
208k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
208k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
208k
}
polly::ScopInfoWrapperPass& llvm::Pass::getAnalysis<polly::ScopInfoWrapperPass>() const
Line
Count
Source
220
45
AnalysisType &Pass::getAnalysis() const {
221
45
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
45
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
45
}
polly::DependenceInfoWrapperPass& llvm::Pass::getAnalysis<polly::DependenceInfoWrapperPass>() const
Line
Count
Source
220
19
AnalysisType &Pass::getAnalysis() const {
221
19
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
19
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
19
}
polly::ScopDetectionWrapperPass& llvm::Pass::getAnalysis<polly::ScopDetectionWrapperPass>() const
Line
Count
Source
220
4.34k
AnalysisType &Pass::getAnalysis() const {
221
4.34k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
4.34k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
4.34k
}
polly::ScopInfoRegionPass& llvm::Pass::getAnalysis<polly::ScopInfoRegionPass>() const
Line
Count
Source
220
6.82k
AnalysisType &Pass::getAnalysis() const {
221
6.82k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
6.82k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
6.82k
}
polly::DependenceInfo& llvm::Pass::getAnalysis<polly::DependenceInfo>() const
Line
Count
Source
220
623
AnalysisType &Pass::getAnalysis() const {
221
623
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
623
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
623
}
polly::IslAstInfoWrapperPass& llvm::Pass::getAnalysis<polly::IslAstInfoWrapperPass>() const
Line
Count
Source
220
306
AnalysisType &Pass::getAnalysis() const {
221
306
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
306
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
306
}
llvm::GISelCSEAnalysisWrapperPass& llvm::Pass::getAnalysis<llvm::GISelCSEAnalysisWrapperPass>() const
Line
Count
Source
220
477k
AnalysisType &Pass::getAnalysis() const {
221
477k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
477k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
477k
}
llvm::StackProtector& llvm::Pass::getAnalysis<llvm::StackProtector>() const
Line
Count
Source
220
515k
AnalysisType &Pass::getAnalysis() const {
221
515k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
222
515k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID);
223
515k
}
224
225
template<typename AnalysisType>
226
344M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
344M
  assert(PI && "getAnalysis for unregistered pass!");
228
344M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
344M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
344M
  // should be a small number, we just do a linear search over a (dense)
231
344M
  // vector.
232
344M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
344M
  assert(ResultPass &&
234
344M
         "getAnalysis*() called on an analysis that was not "
235
344M
         "'required' by pass!");
236
344M
237
344M
  // Because the AnalysisType may not be a subclass of pass (for
238
344M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
344M
  // adjust the return pointer (because the class may multiply inherit, once
240
344M
  // from pass, once from AnalysisType).
241
344M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
344M
}
llvm::MachineDominatorTree& llvm::Pass::getAnalysisID<llvm::MachineDominatorTree>(void const*) const
Line
Count
Source
226
8.02M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
8.02M
  assert(PI && "getAnalysis for unregistered pass!");
228
8.02M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
8.02M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
8.02M
  // should be a small number, we just do a linear search over a (dense)
231
8.02M
  // vector.
232
8.02M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
8.02M
  assert(ResultPass &&
234
8.02M
         "getAnalysis*() called on an analysis that was not "
235
8.02M
         "'required' by pass!");
236
8.02M
237
8.02M
  // Because the AnalysisType may not be a subclass of pass (for
238
8.02M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
8.02M
  // adjust the return pointer (because the class may multiply inherit, once
240
8.02M
  // from pass, once from AnalysisType).
241
8.02M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
8.02M
}
llvm::MachineBranchProbabilityInfo& llvm::Pass::getAnalysisID<llvm::MachineBranchProbabilityInfo>(void const*) const
Line
Count
Source
226
4.45M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
4.45M
  assert(PI && "getAnalysis for unregistered pass!");
228
4.45M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
4.45M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
4.45M
  // should be a small number, we just do a linear search over a (dense)
231
4.45M
  // vector.
232
4.45M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
4.45M
  assert(ResultPass &&
234
4.45M
         "getAnalysis*() called on an analysis that was not "
235
4.45M
         "'required' by pass!");
236
4.45M
237
4.45M
  // Because the AnalysisType may not be a subclass of pass (for
238
4.45M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
4.45M
  // adjust the return pointer (because the class may multiply inherit, once
240
4.45M
  // from pass, once from AnalysisType).
241
4.45M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
4.45M
}
llvm::MachineTraceMetrics& llvm::Pass::getAnalysisID<llvm::MachineTraceMetrics>(void const*) const
Line
Count
Source
226
1.19M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
1.19M
  assert(PI && "getAnalysis for unregistered pass!");
228
1.19M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
1.19M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
1.19M
  // should be a small number, we just do a linear search over a (dense)
231
1.19M
  // vector.
232
1.19M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
1.19M
  assert(ResultPass &&
234
1.19M
         "getAnalysis*() called on an analysis that was not "
235
1.19M
         "'required' by pass!");
236
1.19M
237
1.19M
  // Because the AnalysisType may not be a subclass of pass (for
238
1.19M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
1.19M
  // adjust the return pointer (because the class may multiply inherit, once
240
1.19M
  // from pass, once from AnalysisType).
241
1.19M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
1.19M
}
llvm::TargetPassConfig& llvm::Pass::getAnalysisID<llvm::TargetPassConfig>(void const*) const
Line
Count
Source
226
3.78M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
3.78M
  assert(PI && "getAnalysis for unregistered pass!");
228
3.78M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
3.78M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
3.78M
  // should be a small number, we just do a linear search over a (dense)
231
3.78M
  // vector.
232
3.78M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
3.78M
  assert(ResultPass &&
234
3.78M
         "getAnalysis*() called on an analysis that was not "
235
3.78M
         "'required' by pass!");
236
3.78M
237
3.78M
  // Because the AnalysisType may not be a subclass of pass (for
238
3.78M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
3.78M
  // adjust the return pointer (because the class may multiply inherit, once
240
3.78M
  // from pass, once from AnalysisType).
241
3.78M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
3.78M
}
llvm::LoopInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::LoopInfoWrapperPass>(void const*) const
Line
Count
Source
226
35.2M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
35.2M
  assert(PI && "getAnalysis for unregistered pass!");
228
35.2M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
35.2M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
35.2M
  // should be a small number, we just do a linear search over a (dense)
231
35.2M
  // vector.
232
35.2M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
35.2M
  assert(ResultPass &&
234
35.2M
         "getAnalysis*() called on an analysis that was not "
235
35.2M
         "'required' by pass!");
236
35.2M
237
35.2M
  // Because the AnalysisType may not be a subclass of pass (for
238
35.2M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
35.2M
  // adjust the return pointer (because the class may multiply inherit, once
240
35.2M
  // from pass, once from AnalysisType).
241
35.2M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
35.2M
}
llvm::ScalarEvolutionWrapperPass& llvm::Pass::getAnalysisID<llvm::ScalarEvolutionWrapperPass>(void const*) const
Line
Count
Source
226
3.85M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
3.85M
  assert(PI && "getAnalysis for unregistered pass!");
228
3.85M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
3.85M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
3.85M
  // should be a small number, we just do a linear search over a (dense)
231
3.85M
  // vector.
232
3.85M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
3.85M
  assert(ResultPass &&
234
3.85M
         "getAnalysis*() called on an analysis that was not "
235
3.85M
         "'required' by pass!");
236
3.85M
237
3.85M
  // Because the AnalysisType may not be a subclass of pass (for
238
3.85M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
3.85M
  // adjust the return pointer (because the class may multiply inherit, once
240
3.85M
  // from pass, once from AnalysisType).
241
3.85M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
3.85M
}
llvm::MachineLoopInfo& llvm::Pass::getAnalysisID<llvm::MachineLoopInfo>(void const*) const
Line
Count
Source
226
9.00M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
9.00M
  assert(PI && "getAnalysis for unregistered pass!");
228
9.00M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
9.00M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
9.00M
  // should be a small number, we just do a linear search over a (dense)
231
9.00M
  // vector.
232
9.00M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
9.00M
  assert(ResultPass &&
234
9.00M
         "getAnalysis*() called on an analysis that was not "
235
9.00M
         "'required' by pass!");
236
9.00M
237
9.00M
  // Because the AnalysisType may not be a subclass of pass (for
238
9.00M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
9.00M
  // adjust the return pointer (because the class may multiply inherit, once
240
9.00M
  // from pass, once from AnalysisType).
241
9.00M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
9.00M
}
llvm::AAResultsWrapperPass& llvm::Pass::getAnalysisID<llvm::AAResultsWrapperPass>(void const*) const
Line
Count
Source
226
17.2M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
17.2M
  assert(PI && "getAnalysis for unregistered pass!");
228
17.2M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
17.2M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
17.2M
  // should be a small number, we just do a linear search over a (dense)
231
17.2M
  // vector.
232
17.2M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
17.2M
  assert(ResultPass &&
234
17.2M
         "getAnalysis*() called on an analysis that was not "
235
17.2M
         "'required' by pass!");
236
17.2M
237
17.2M
  // Because the AnalysisType may not be a subclass of pass (for
238
17.2M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
17.2M
  // adjust the return pointer (because the class may multiply inherit, once
240
17.2M
  // from pass, once from AnalysisType).
241
17.2M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
17.2M
}
llvm::LegacyDivergenceAnalysis& llvm::Pass::getAnalysisID<llvm::LegacyDivergenceAnalysis>(void const*) const
Line
Count
Source
226
78.4k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
78.4k
  assert(PI && "getAnalysis for unregistered pass!");
228
78.4k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
78.4k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
78.4k
  // should be a small number, we just do a linear search over a (dense)
231
78.4k
  // vector.
232
78.4k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
78.4k
  assert(ResultPass &&
234
78.4k
         "getAnalysis*() called on an analysis that was not "
235
78.4k
         "'required' by pass!");
236
78.4k
237
78.4k
  // Because the AnalysisType may not be a subclass of pass (for
238
78.4k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
78.4k
  // adjust the return pointer (because the class may multiply inherit, once
240
78.4k
  // from pass, once from AnalysisType).
241
78.4k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
78.4k
}
llvm::MemoryDependenceWrapperPass& llvm::Pass::getAnalysisID<llvm::MemoryDependenceWrapperPass>(void const*) const
Line
Count
Source
226
1.42M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
1.42M
  assert(PI && "getAnalysis for unregistered pass!");
228
1.42M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
1.42M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
1.42M
  // should be a small number, we just do a linear search over a (dense)
231
1.42M
  // vector.
232
1.42M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
1.42M
  assert(ResultPass &&
234
1.42M
         "getAnalysis*() called on an analysis that was not "
235
1.42M
         "'required' by pass!");
236
1.42M
237
1.42M
  // Because the AnalysisType may not be a subclass of pass (for
238
1.42M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
1.42M
  // adjust the return pointer (because the class may multiply inherit, once
240
1.42M
  // from pass, once from AnalysisType).
241
1.42M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
1.42M
}
llvm::AssumptionCacheTracker& llvm::Pass::getAnalysisID<llvm::AssumptionCacheTracker>(void const*) const
Line
Count
Source
226
35.9M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
35.9M
  assert(PI && "getAnalysis for unregistered pass!");
228
35.9M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
35.9M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
35.9M
  // should be a small number, we just do a linear search over a (dense)
231
35.9M
  // vector.
232
35.9M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
35.9M
  assert(ResultPass &&
234
35.9M
         "getAnalysis*() called on an analysis that was not "
235
35.9M
         "'required' by pass!");
236
35.9M
237
35.9M
  // Because the AnalysisType may not be a subclass of pass (for
238
35.9M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
35.9M
  // adjust the return pointer (because the class may multiply inherit, once
240
35.9M
  // from pass, once from AnalysisType).
241
35.9M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
35.9M
}
llvm::TargetTransformInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::TargetTransformInfoWrapperPass>(void const*) const
Line
Count
Source
226
14.4M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
14.4M
  assert(PI && "getAnalysis for unregistered pass!");
228
14.4M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
14.4M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
14.4M
  // should be a small number, we just do a linear search over a (dense)
231
14.4M
  // vector.
232
14.4M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
14.4M
  assert(ResultPass &&
234
14.4M
         "getAnalysis*() called on an analysis that was not "
235
14.4M
         "'required' by pass!");
236
14.4M
237
14.4M
  // Because the AnalysisType may not be a subclass of pass (for
238
14.4M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
14.4M
  // adjust the return pointer (because the class may multiply inherit, once
240
14.4M
  // from pass, once from AnalysisType).
241
14.4M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
14.4M
}
Unexecuted instantiation: llvm::MachineRegionInfoPass& llvm::Pass::getAnalysisID<llvm::MachineRegionInfoPass>(void const*) const
llvm::PostDominatorTreeWrapperPass& llvm::Pass::getAnalysisID<llvm::PostDominatorTreeWrapperPass>(void const*) const
Line
Count
Source
226
650k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
650k
  assert(PI && "getAnalysis for unregistered pass!");
228
650k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
650k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
650k
  // should be a small number, we just do a linear search over a (dense)
231
650k
  // vector.
232
650k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
650k
  assert(ResultPass &&
234
650k
         "getAnalysis*() called on an analysis that was not "
235
650k
         "'required' by pass!");
236
650k
237
650k
  // Because the AnalysisType may not be a subclass of pass (for
238
650k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
650k
  // adjust the return pointer (because the class may multiply inherit, once
240
650k
  // from pass, once from AnalysisType).
241
650k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
650k
}
llvm::MachinePostDominatorTree& llvm::Pass::getAnalysisID<llvm::MachinePostDominatorTree>(void const*) const
Line
Count
Source
226
1.03M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
1.03M
  assert(PI && "getAnalysis for unregistered pass!");
228
1.03M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
1.03M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
1.03M
  // should be a small number, we just do a linear search over a (dense)
231
1.03M
  // vector.
232
1.03M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
1.03M
  assert(ResultPass &&
234
1.03M
         "getAnalysis*() called on an analysis that was not "
235
1.03M
         "'required' by pass!");
236
1.03M
237
1.03M
  // Because the AnalysisType may not be a subclass of pass (for
238
1.03M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
1.03M
  // adjust the return pointer (because the class may multiply inherit, once
240
1.03M
  // from pass, once from AnalysisType).
241
1.03M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
1.03M
}
llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysisID<llvm::DominatorTreeWrapperPass>(void const*) const
Line
Count
Source
226
47.2M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
47.2M
  assert(PI && "getAnalysis for unregistered pass!");
228
47.2M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
47.2M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
47.2M
  // should be a small number, we just do a linear search over a (dense)
231
47.2M
  // vector.
232
47.2M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
47.2M
  assert(ResultPass &&
234
47.2M
         "getAnalysis*() called on an analysis that was not "
235
47.2M
         "'required' by pass!");
236
47.2M
237
47.2M
  // Because the AnalysisType may not be a subclass of pass (for
238
47.2M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
47.2M
  // adjust the return pointer (because the class may multiply inherit, once
240
47.2M
  // from pass, once from AnalysisType).
241
47.2M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
47.2M
}
llvm::LiveIntervals& llvm::Pass::getAnalysisID<llvm::LiveIntervals>(void const*) const
Line
Count
Source
226
3.56M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
3.56M
  assert(PI && "getAnalysis for unregistered pass!");
228
3.56M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
3.56M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
3.56M
  // should be a small number, we just do a linear search over a (dense)
231
3.56M
  // vector.
232
3.56M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
3.56M
  assert(ResultPass &&
234
3.56M
         "getAnalysis*() called on an analysis that was not "
235
3.56M
         "'required' by pass!");
236
3.56M
237
3.56M
  // Because the AnalysisType may not be a subclass of pass (for
238
3.56M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
3.56M
  // adjust the return pointer (because the class may multiply inherit, once
240
3.56M
  // from pass, once from AnalysisType).
241
3.56M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
3.56M
}
llvm::LiveRegMatrix& llvm::Pass::getAnalysisID<llvm::LiveRegMatrix>(void const*) const
Line
Count
Source
226
514k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
514k
  assert(PI && "getAnalysis for unregistered pass!");
228
514k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
514k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
514k
  // should be a small number, we just do a linear search over a (dense)
231
514k
  // vector.
232
514k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
514k
  assert(ResultPass &&
234
514k
         "getAnalysis*() called on an analysis that was not "
235
514k
         "'required' by pass!");
236
514k
237
514k
  // Because the AnalysisType may not be a subclass of pass (for
238
514k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
514k
  // adjust the return pointer (because the class may multiply inherit, once
240
514k
  // from pass, once from AnalysisType).
241
514k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
514k
}
llvm::VirtRegMap& llvm::Pass::getAnalysisID<llvm::VirtRegMap>(void const*) const
Line
Count
Source
226
1.50M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
1.50M
  assert(PI && "getAnalysis for unregistered pass!");
228
1.50M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
1.50M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
1.50M
  // should be a small number, we just do a linear search over a (dense)
231
1.50M
  // vector.
232
1.50M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
1.50M
  assert(ResultPass &&
234
1.50M
         "getAnalysis*() called on an analysis that was not "
235
1.50M
         "'required' by pass!");
236
1.50M
237
1.50M
  // Because the AnalysisType may not be a subclass of pass (for
238
1.50M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
1.50M
  // adjust the return pointer (because the class may multiply inherit, once
240
1.50M
  // from pass, once from AnalysisType).
241
1.50M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
1.50M
}
llvm::AMDGPUArgumentUsageInfo& llvm::Pass::getAnalysisID<llvm::AMDGPUArgumentUsageInfo>(void const*) const
Line
Count
Source
226
25.8k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
25.8k
  assert(PI && "getAnalysis for unregistered pass!");
228
25.8k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
25.8k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
25.8k
  // should be a small number, we just do a linear search over a (dense)
231
25.8k
  // vector.
232
25.8k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
25.8k
  assert(ResultPass &&
234
25.8k
         "getAnalysis*() called on an analysis that was not "
235
25.8k
         "'required' by pass!");
236
25.8k
237
25.8k
  // Because the AnalysisType may not be a subclass of pass (for
238
25.8k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
25.8k
  // adjust the return pointer (because the class may multiply inherit, once
240
25.8k
  // from pass, once from AnalysisType).
241
25.8k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
25.8k
}
llvm::TargetLibraryInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::TargetLibraryInfoWrapperPass>(void const*) const
Line
Count
Source
226
49.2M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
49.2M
  assert(PI && "getAnalysis for unregistered pass!");
228
49.2M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
49.2M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
49.2M
  // should be a small number, we just do a linear search over a (dense)
231
49.2M
  // vector.
232
49.2M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
49.2M
  assert(ResultPass &&
234
49.2M
         "getAnalysis*() called on an analysis that was not "
235
49.2M
         "'required' by pass!");
236
49.2M
237
49.2M
  // Because the AnalysisType may not be a subclass of pass (for
238
49.2M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
49.2M
  // adjust the return pointer (because the class may multiply inherit, once
240
49.2M
  // from pass, once from AnalysisType).
241
49.2M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
49.2M
}
llvm::MachineDominanceFrontier& llvm::Pass::getAnalysisID<llvm::MachineDominanceFrontier>(void const*) const
Line
Count
Source
226
11.1k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
11.1k
  assert(PI && "getAnalysis for unregistered pass!");
228
11.1k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
11.1k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
11.1k
  // should be a small number, we just do a linear search over a (dense)
231
11.1k
  // vector.
232
11.1k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
11.1k
  assert(ResultPass &&
234
11.1k
         "getAnalysis*() called on an analysis that was not "
235
11.1k
         "'required' by pass!");
236
11.1k
237
11.1k
  // Because the AnalysisType may not be a subclass of pass (for
238
11.1k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
11.1k
  // adjust the return pointer (because the class may multiply inherit, once
240
11.1k
  // from pass, once from AnalysisType).
241
11.1k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
11.1k
}
llvm::MachineBlockFrequencyInfo& llvm::Pass::getAnalysisID<llvm::MachineBlockFrequencyInfo>(void const*) const
Line
Count
Source
226
4.49M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
4.49M
  assert(PI && "getAnalysis for unregistered pass!");
228
4.49M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
4.49M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
4.49M
  // should be a small number, we just do a linear search over a (dense)
231
4.49M
  // vector.
232
4.49M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
4.49M
  assert(ResultPass &&
234
4.49M
         "getAnalysis*() called on an analysis that was not "
235
4.49M
         "'required' by pass!");
236
4.49M
237
4.49M
  // Because the AnalysisType may not be a subclass of pass (for
238
4.49M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
4.49M
  // adjust the return pointer (because the class may multiply inherit, once
240
4.49M
  // from pass, once from AnalysisType).
241
4.49M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
4.49M
}
llvm::WebAssemblyExceptionInfo& llvm::Pass::getAnalysisID<llvm::WebAssemblyExceptionInfo>(void const*) const
Line
Count
Source
226
4.52k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
4.52k
  assert(PI && "getAnalysis for unregistered pass!");
228
4.52k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
4.52k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
4.52k
  // should be a small number, we just do a linear search over a (dense)
231
4.52k
  // vector.
232
4.52k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
4.52k
  assert(ResultPass &&
234
4.52k
         "getAnalysis*() called on an analysis that was not "
235
4.52k
         "'required' by pass!");
236
4.52k
237
4.52k
  // Because the AnalysisType may not be a subclass of pass (for
238
4.52k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
4.52k
  // adjust the return pointer (because the class may multiply inherit, once
240
4.52k
  // from pass, once from AnalysisType).
241
4.52k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
4.52k
}
llvm::EdgeBundles& llvm::Pass::getAnalysisID<llvm::EdgeBundles>(void const*) const
Line
Count
Source
226
970k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
970k
  assert(PI && "getAnalysis for unregistered pass!");
228
970k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
970k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
970k
  // should be a small number, we just do a linear search over a (dense)
231
970k
  // vector.
232
970k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
970k
  assert(ResultPass &&
234
970k
         "getAnalysis*() called on an analysis that was not "
235
970k
         "'required' by pass!");
236
970k
237
970k
  // Because the AnalysisType may not be a subclass of pass (for
238
970k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
970k
  // adjust the return pointer (because the class may multiply inherit, once
240
970k
  // from pass, once from AnalysisType).
241
970k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
970k
}
llvm::MachineModuleInfo& llvm::Pass::getAnalysisID<llvm::MachineModuleInfo>(void const*) const
Line
Count
Source
226
52.8M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
52.8M
  assert(PI && "getAnalysis for unregistered pass!");
228
52.8M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
52.8M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
52.8M
  // should be a small number, we just do a linear search over a (dense)
231
52.8M
  // vector.
232
52.8M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
52.8M
  assert(ResultPass &&
234
52.8M
         "getAnalysis*() called on an analysis that was not "
235
52.8M
         "'required' by pass!");
236
52.8M
237
52.8M
  // Because the AnalysisType may not be a subclass of pass (for
238
52.8M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
52.8M
  // adjust the return pointer (because the class may multiply inherit, once
240
52.8M
  // from pass, once from AnalysisType).
241
52.8M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
52.8M
}
llvm::BasicAAWrapperPass& llvm::Pass::getAnalysisID<llvm::BasicAAWrapperPass>(void const*) const
Line
Count
Source
226
9.40M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
9.40M
  assert(PI && "getAnalysis for unregistered pass!");
228
9.40M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
9.40M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
9.40M
  // should be a small number, we just do a linear search over a (dense)
231
9.40M
  // vector.
232
9.40M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
9.40M
  assert(ResultPass &&
234
9.40M
         "getAnalysis*() called on an analysis that was not "
235
9.40M
         "'required' by pass!");
236
9.40M
237
9.40M
  // Because the AnalysisType may not be a subclass of pass (for
238
9.40M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
9.40M
  // adjust the return pointer (because the class may multiply inherit, once
240
9.40M
  // from pass, once from AnalysisType).
241
9.40M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
9.40M
}
llvm::BranchProbabilityInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::BranchProbabilityInfoWrapperPass>(void const*) const
Line
Count
Source
226
2.07M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
2.07M
  assert(PI && "getAnalysis for unregistered pass!");
228
2.07M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
2.07M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
2.07M
  // should be a small number, we just do a linear search over a (dense)
231
2.07M
  // vector.
232
2.07M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
2.07M
  assert(ResultPass &&
234
2.07M
         "getAnalysis*() called on an analysis that was not "
235
2.07M
         "'required' by pass!");
236
2.07M
237
2.07M
  // Because the AnalysisType may not be a subclass of pass (for
238
2.07M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
2.07M
  // adjust the return pointer (because the class may multiply inherit, once
240
2.07M
  // from pass, once from AnalysisType).
241
2.07M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
2.07M
}
llvm::CallGraphWrapperPass& llvm::Pass::getAnalysisID<llvm::CallGraphWrapperPass>(void const*) const
Line
Count
Source
226
2.19M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
2.19M
  assert(PI && "getAnalysis for unregistered pass!");
228
2.19M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
2.19M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
2.19M
  // should be a small number, we just do a linear search over a (dense)
231
2.19M
  // vector.
232
2.19M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
2.19M
  assert(ResultPass &&
234
2.19M
         "getAnalysis*() called on an analysis that was not "
235
2.19M
         "'required' by pass!");
236
2.19M
237
2.19M
  // Because the AnalysisType may not be a subclass of pass (for
238
2.19M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
2.19M
  // adjust the return pointer (because the class may multiply inherit, once
240
2.19M
  // from pass, once from AnalysisType).
241
2.19M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
2.19M
}
llvm::LazyBranchProbabilityInfoPass& llvm::Pass::getAnalysisID<llvm::LazyBranchProbabilityInfoPass>(void const*) const
Line
Count
Source
226
6.22M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
6.22M
  assert(PI && "getAnalysis for unregistered pass!");
228
6.22M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
6.22M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
6.22M
  // should be a small number, we just do a linear search over a (dense)
231
6.22M
  // vector.
232
6.22M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
6.22M
  assert(ResultPass &&
234
6.22M
         "getAnalysis*() called on an analysis that was not "
235
6.22M
         "'required' by pass!");
236
6.22M
237
6.22M
  // Because the AnalysisType may not be a subclass of pass (for
238
6.22M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
6.22M
  // adjust the return pointer (because the class may multiply inherit, once
240
6.22M
  // from pass, once from AnalysisType).
241
6.22M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
6.22M
}
llvm::LazyValueInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::LazyValueInfoWrapperPass>(void const*) const
Line
Count
Source
226
1.91M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
1.91M
  assert(PI && "getAnalysis for unregistered pass!");
228
1.91M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
1.91M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
1.91M
  // should be a small number, we just do a linear search over a (dense)
231
1.91M
  // vector.
232
1.91M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
1.91M
  assert(ResultPass &&
234
1.91M
         "getAnalysis*() called on an analysis that was not "
235
1.91M
         "'required' by pass!");
236
1.91M
237
1.91M
  // Because the AnalysisType may not be a subclass of pass (for
238
1.91M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
1.91M
  // adjust the return pointer (because the class may multiply inherit, once
240
1.91M
  // from pass, once from AnalysisType).
241
1.91M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
1.91M
}
llvm::PhiValuesWrapperPass& llvm::Pass::getAnalysisID<llvm::PhiValuesWrapperPass>(void const*) const
Line
Count
Source
226
1.42M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
1.42M
  assert(PI && "getAnalysis for unregistered pass!");
228
1.42M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
1.42M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
1.42M
  // should be a small number, we just do a linear search over a (dense)
231
1.42M
  // vector.
232
1.42M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
1.42M
  assert(ResultPass &&
234
1.42M
         "getAnalysis*() called on an analysis that was not "
235
1.42M
         "'required' by pass!");
236
1.42M
237
1.42M
  // Because the AnalysisType may not be a subclass of pass (for
238
1.42M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
1.42M
  // adjust the return pointer (because the class may multiply inherit, once
240
1.42M
  // from pass, once from AnalysisType).
241
1.42M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
1.42M
}
llvm::MemorySSAWrapperPass& llvm::Pass::getAnalysisID<llvm::MemorySSAWrapperPass>(void const*) const
Line
Count
Source
226
723k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
723k
  assert(PI && "getAnalysis for unregistered pass!");
228
723k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
723k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
723k
  // should be a small number, we just do a linear search over a (dense)
231
723k
  // vector.
232
723k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
723k
  assert(ResultPass &&
234
723k
         "getAnalysis*() called on an analysis that was not "
235
723k
         "'required' by pass!");
236
723k
237
723k
  // Because the AnalysisType may not be a subclass of pass (for
238
723k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
723k
  // adjust the return pointer (because the class may multiply inherit, once
240
723k
  // from pass, once from AnalysisType).
241
723k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
723k
}
llvm::ProfileSummaryInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::ProfileSummaryInfoWrapperPass>(void const*) const
Line
Count
Source
226
5.56M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
5.56M
  assert(PI && "getAnalysis for unregistered pass!");
228
5.56M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
5.56M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
5.56M
  // should be a small number, we just do a linear search over a (dense)
231
5.56M
  // vector.
232
5.56M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
5.56M
  assert(ResultPass &&
234
5.56M
         "getAnalysis*() called on an analysis that was not "
235
5.56M
         "'required' by pass!");
236
5.56M
237
5.56M
  // Because the AnalysisType may not be a subclass of pass (for
238
5.56M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
5.56M
  // adjust the return pointer (because the class may multiply inherit, once
240
5.56M
  // from pass, once from AnalysisType).
241
5.56M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
5.56M
}
llvm::LazyBlockFrequencyInfoPass& llvm::Pass::getAnalysisID<llvm::LazyBlockFrequencyInfoPass>(void const*) const
Line
Count
Source
226
653
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
653
  assert(PI && "getAnalysis for unregistered pass!");
228
653
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
653
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
653
  // should be a small number, we just do a linear search over a (dense)
231
653
  // vector.
232
653
  Pass *ResultPass = Resolver->findImplPass(PI);
233
653
  assert(ResultPass &&
234
653
         "getAnalysis*() called on an analysis that was not "
235
653
         "'required' by pass!");
236
653
237
653
  // Because the AnalysisType may not be a subclass of pass (for
238
653
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
653
  // adjust the return pointer (because the class may multiply inherit, once
240
653
  // from pass, once from AnalysisType).
241
653
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
653
}
llvm::DominanceFrontierWrapperPass& llvm::Pass::getAnalysisID<llvm::DominanceFrontierWrapperPass>(void const*) const
Line
Count
Source
226
29.0k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
29.0k
  assert(PI && "getAnalysis for unregistered pass!");
228
29.0k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
29.0k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
29.0k
  // should be a small number, we just do a linear search over a (dense)
231
29.0k
  // vector.
232
29.0k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
29.0k
  assert(ResultPass &&
234
29.0k
         "getAnalysis*() called on an analysis that was not "
235
29.0k
         "'required' by pass!");
236
29.0k
237
29.0k
  // Because the AnalysisType may not be a subclass of pass (for
238
29.0k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
29.0k
  // adjust the return pointer (because the class may multiply inherit, once
240
29.0k
  // from pass, once from AnalysisType).
241
29.0k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
29.0k
}
llvm::RegionInfoPass& llvm::Pass::getAnalysisID<llvm::RegionInfoPass>(void const*) const
Line
Count
Source
226
30.5k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
30.5k
  assert(PI && "getAnalysis for unregistered pass!");
228
30.5k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
30.5k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
30.5k
  // should be a small number, we just do a linear search over a (dense)
231
30.5k
  // vector.
232
30.5k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
30.5k
  assert(ResultPass &&
234
30.5k
         "getAnalysis*() called on an analysis that was not "
235
30.5k
         "'required' by pass!");
236
30.5k
237
30.5k
  // Because the AnalysisType may not be a subclass of pass (for
238
30.5k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
30.5k
  // adjust the return pointer (because the class may multiply inherit, once
240
30.5k
  // from pass, once from AnalysisType).
241
30.5k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
30.5k
}
llvm::ReachingDefAnalysis& llvm::Pass::getAnalysisID<llvm::ReachingDefAnalysis>(void const*) const
Line
Count
Source
226
288k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
288k
  assert(PI && "getAnalysis for unregistered pass!");
228
288k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
288k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
288k
  // should be a small number, we just do a linear search over a (dense)
231
288k
  // vector.
232
288k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
288k
  assert(ResultPass &&
234
288k
         "getAnalysis*() called on an analysis that was not "
235
288k
         "'required' by pass!");
236
288k
237
288k
  // Because the AnalysisType may not be a subclass of pass (for
238
288k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
288k
  // adjust the return pointer (because the class may multiply inherit, once
240
288k
  // from pass, once from AnalysisType).
241
288k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
288k
}
llvm::GCModuleInfo& llvm::Pass::getAnalysisID<llvm::GCModuleInfo>(void const*) const
Line
Count
Source
226
243
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
243
  assert(PI && "getAnalysis for unregistered pass!");
228
243
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
243
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
243
  // should be a small number, we just do a linear search over a (dense)
231
243
  // vector.
232
243
  Pass *ResultPass = Resolver->findImplPass(PI);
233
243
  assert(ResultPass &&
234
243
         "getAnalysis*() called on an analysis that was not "
235
243
         "'required' by pass!");
236
243
237
243
  // Because the AnalysisType may not be a subclass of pass (for
238
243
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
243
  // adjust the return pointer (because the class may multiply inherit, once
240
243
  // from pass, once from AnalysisType).
241
243
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
243
}
llvm::LiveStacks& llvm::Pass::getAnalysisID<llvm::LiveStacks>(void const*) const
Line
Count
Source
226
1.45M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
1.45M
  assert(PI && "getAnalysis for unregistered pass!");
228
1.45M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
1.45M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
1.45M
  // should be a small number, we just do a linear search over a (dense)
231
1.45M
  // vector.
232
1.45M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
1.45M
  assert(ResultPass &&
234
1.45M
         "getAnalysis*() called on an analysis that was not "
235
1.45M
         "'required' by pass!");
236
1.45M
237
1.45M
  // Because the AnalysisType may not be a subclass of pass (for
238
1.45M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
1.45M
  // adjust the return pointer (because the class may multiply inherit, once
240
1.45M
  // from pass, once from AnalysisType).
241
1.45M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
1.45M
}
llvm::SlotIndexes& llvm::Pass::getAnalysisID<llvm::SlotIndexes>(void const*) const
Line
Count
Source
226
2.02M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
2.02M
  assert(PI && "getAnalysis for unregistered pass!");
228
2.02M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
2.02M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
2.02M
  // should be a small number, we just do a linear search over a (dense)
231
2.02M
  // vector.
232
2.02M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
2.02M
  assert(ResultPass &&
234
2.02M
         "getAnalysis*() called on an analysis that was not "
235
2.02M
         "'required' by pass!");
236
2.02M
237
2.02M
  // Because the AnalysisType may not be a subclass of pass (for
238
2.02M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
2.02M
  // adjust the return pointer (because the class may multiply inherit, once
240
2.02M
  // from pass, once from AnalysisType).
241
2.02M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
2.02M
}
llvm::LazyMachineBlockFrequencyInfoPass& llvm::Pass::getAnalysisID<llvm::LazyMachineBlockFrequencyInfoPass>(void const*) const
Line
Count
Source
226
60
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
60
  assert(PI && "getAnalysis for unregistered pass!");
228
60
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
60
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
60
  // should be a small number, we just do a linear search over a (dense)
231
60
  // vector.
232
60
  Pass *ResultPass = Resolver->findImplPass(PI);
233
60
  assert(ResultPass &&
234
60
         "getAnalysis*() called on an analysis that was not "
235
60
         "'required' by pass!");
236
60
237
60
  // Because the AnalysisType may not be a subclass of pass (for
238
60
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
60
  // adjust the return pointer (because the class may multiply inherit, once
240
60
  // from pass, once from AnalysisType).
241
60
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
60
}
llvm::MachineOptimizationRemarkEmitterPass& llvm::Pass::getAnalysisID<llvm::MachineOptimizationRemarkEmitterPass>(void const*) const
Line
Count
Source
226
1.84M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
1.84M
  assert(PI && "getAnalysis for unregistered pass!");
228
1.84M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
1.84M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
1.84M
  // should be a small number, we just do a linear search over a (dense)
231
1.84M
  // vector.
232
1.84M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
1.84M
  assert(ResultPass &&
234
1.84M
         "getAnalysis*() called on an analysis that was not "
235
1.84M
         "'required' by pass!");
236
1.84M
237
1.84M
  // Because the AnalysisType may not be a subclass of pass (for
238
1.84M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
1.84M
  // adjust the return pointer (because the class may multiply inherit, once
240
1.84M
  // from pass, once from AnalysisType).
241
1.84M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
1.84M
}
llvm::SpillPlacement& llvm::Pass::getAnalysisID<llvm::SpillPlacement>(void const*) const
Line
Count
Source
226
484k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
484k
  assert(PI && "getAnalysis for unregistered pass!");
228
484k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
484k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
484k
  // should be a small number, we just do a linear search over a (dense)
231
484k
  // vector.
232
484k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
484k
  assert(ResultPass &&
234
484k
         "getAnalysis*() called on an analysis that was not "
235
484k
         "'required' by pass!");
236
484k
237
484k
  // Because the AnalysisType may not be a subclass of pass (for
238
484k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
484k
  // adjust the return pointer (because the class may multiply inherit, once
240
484k
  // from pass, once from AnalysisType).
241
484k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
484k
}
llvm::LiveDebugVariables& llvm::Pass::getAnalysisID<llvm::LiveDebugVariables>(void const*) const
Line
Count
Source
226
968k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
968k
  assert(PI && "getAnalysis for unregistered pass!");
228
968k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
968k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
968k
  // should be a small number, we just do a linear search over a (dense)
231
968k
  // vector.
232
968k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
968k
  assert(ResultPass &&
234
968k
         "getAnalysis*() called on an analysis that was not "
235
968k
         "'required' by pass!");
236
968k
237
968k
  // Because the AnalysisType may not be a subclass of pass (for
238
968k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
968k
  // adjust the return pointer (because the class may multiply inherit, once
240
968k
  // from pass, once from AnalysisType).
241
968k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
968k
}
llvm::PhysicalRegisterUsageInfo& llvm::Pass::getAnalysisID<llvm::PhysicalRegisterUsageInfo>(void const*) const
Line
Count
Source
226
25.2k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
25.2k
  assert(PI && "getAnalysis for unregistered pass!");
228
25.2k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
25.2k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
25.2k
  // should be a small number, we just do a linear search over a (dense)
231
25.2k
  // vector.
232
25.2k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
25.2k
  assert(ResultPass &&
234
25.2k
         "getAnalysis*() called on an analysis that was not "
235
25.2k
         "'required' by pass!");
236
25.2k
237
25.2k
  // Because the AnalysisType may not be a subclass of pass (for
238
25.2k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
25.2k
  // adjust the return pointer (because the class may multiply inherit, once
240
25.2k
  // from pass, once from AnalysisType).
241
25.2k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
25.2k
}
llvm::ModuleSummaryIndexWrapperPass& llvm::Pass::getAnalysisID<llvm::ModuleSummaryIndexWrapperPass>(void const*) const
Line
Count
Source
226
390
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
390
  assert(PI && "getAnalysis for unregistered pass!");
228
390
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
390
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
390
  // should be a small number, we just do a linear search over a (dense)
231
390
  // vector.
232
390
  Pass *ResultPass = Resolver->findImplPass(PI);
233
390
  assert(ResultPass &&
234
390
         "getAnalysis*() called on an analysis that was not "
235
390
         "'required' by pass!");
236
390
237
390
  // Because the AnalysisType may not be a subclass of pass (for
238
390
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
390
  // adjust the return pointer (because the class may multiply inherit, once
240
390
  // from pass, once from AnalysisType).
241
390
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
390
}
llvm::OptimizationRemarkEmitterWrapperPass& llvm::Pass::getAnalysisID<llvm::OptimizationRemarkEmitterWrapperPass>(void const*) const
Line
Count
Source
226
6.22M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
6.22M
  assert(PI && "getAnalysis for unregistered pass!");
228
6.22M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
6.22M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
6.22M
  // should be a small number, we just do a linear search over a (dense)
231
6.22M
  // vector.
232
6.22M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
6.22M
  assert(ResultPass &&
234
6.22M
         "getAnalysis*() called on an analysis that was not "
235
6.22M
         "'required' by pass!");
236
6.22M
237
6.22M
  // Because the AnalysisType may not be a subclass of pass (for
238
6.22M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
6.22M
  // adjust the return pointer (because the class may multiply inherit, once
240
6.22M
  // from pass, once from AnalysisType).
241
6.22M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
6.22M
}
AddressSanitizer.cpp:(anonymous namespace)::ASanGlobalsMetadataWrapperPass& llvm::Pass::getAnalysisID<(anonymous namespace)::ASanGlobalsMetadataWrapperPass>(void const*) const
Line
Count
Source
226
971
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
971
  assert(PI && "getAnalysis for unregistered pass!");
228
971
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
971
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
971
  // should be a small number, we just do a linear search over a (dense)
231
971
  // vector.
232
971
  Pass *ResultPass = Resolver->findImplPass(PI);
233
971
  assert(ResultPass &&
234
971
         "getAnalysis*() called on an analysis that was not "
235
971
         "'required' by pass!");
236
971
237
971
  // Because the AnalysisType may not be a subclass of pass (for
238
971
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
971
  // adjust the return pointer (because the class may multiply inherit, once
240
971
  // from pass, once from AnalysisType).
241
971
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
971
}
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::BlockFrequencyInfoWrapperPass>(void const*) const
Line
Count
Source
226
1.41M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
1.41M
  assert(PI && "getAnalysis for unregistered pass!");
228
1.41M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
1.41M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
1.41M
  // should be a small number, we just do a linear search over a (dense)
231
1.41M
  // vector.
232
1.41M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
1.41M
  assert(ResultPass &&
234
1.41M
         "getAnalysis*() called on an analysis that was not "
235
1.41M
         "'required' by pass!");
236
1.41M
237
1.41M
  // Because the AnalysisType may not be a subclass of pass (for
238
1.41M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
1.41M
  // adjust the return pointer (because the class may multiply inherit, once
240
1.41M
  // from pass, once from AnalysisType).
241
1.41M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
1.41M
}
llvm::DemandedBitsWrapperPass& llvm::Pass::getAnalysisID<llvm::DemandedBitsWrapperPass>(void const*) const
Line
Count
Source
226
1.02M
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
1.02M
  assert(PI && "getAnalysis for unregistered pass!");
228
1.02M
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
1.02M
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
1.02M
  // should be a small number, we just do a linear search over a (dense)
231
1.02M
  // vector.
232
1.02M
  Pass *ResultPass = Resolver->findImplPass(PI);
233
1.02M
  assert(ResultPass &&
234
1.02M
         "getAnalysis*() called on an analysis that was not "
235
1.02M
         "'required' by pass!");
236
1.02M
237
1.02M
  // Because the AnalysisType may not be a subclass of pass (for
238
1.02M
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
1.02M
  // adjust the return pointer (because the class may multiply inherit, once
240
1.02M
  // from pass, once from AnalysisType).
241
1.02M
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
1.02M
}
llvm::LoopAccessLegacyAnalysis& llvm::Pass::getAnalysisID<llvm::LoopAccessLegacyAnalysis>(void const*) const
Line
Count
Source
226
836k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
836k
  assert(PI && "getAnalysis for unregistered pass!");
228
836k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
836k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
836k
  // should be a small number, we just do a linear search over a (dense)
231
836k
  // vector.
232
836k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
836k
  assert(ResultPass &&
234
836k
         "getAnalysis*() called on an analysis that was not "
235
836k
         "'required' by pass!");
236
836k
237
836k
  // Because the AnalysisType may not be a subclass of pass (for
238
836k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
836k
  // adjust the return pointer (because the class may multiply inherit, once
240
836k
  // from pass, once from AnalysisType).
241
836k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
836k
}
llvm::DependenceAnalysisWrapperPass& llvm::Pass::getAnalysisID<llvm::DependenceAnalysisWrapperPass>(void const*) const
Line
Count
Source
226
168
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
168
  assert(PI && "getAnalysis for unregistered pass!");
228
168
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
168
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
168
  // should be a small number, we just do a linear search over a (dense)
231
168
  // vector.
232
168
  Pass *ResultPass = Resolver->findImplPass(PI);
233
168
  assert(ResultPass &&
234
168
         "getAnalysis*() called on an analysis that was not "
235
168
         "'required' by pass!");
236
168
237
168
  // Because the AnalysisType may not be a subclass of pass (for
238
168
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
168
  // adjust the return pointer (because the class may multiply inherit, once
240
168
  // from pass, once from AnalysisType).
241
168
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
168
}
llvm::IVUsersWrapperPass& llvm::Pass::getAnalysisID<llvm::IVUsersWrapperPass>(void const*) const
Line
Count
Source
226
208k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
208k
  assert(PI && "getAnalysis for unregistered pass!");
228
208k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
208k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
208k
  // should be a small number, we just do a linear search over a (dense)
231
208k
  // vector.
232
208k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
208k
  assert(ResultPass &&
234
208k
         "getAnalysis*() called on an analysis that was not "
235
208k
         "'required' by pass!");
236
208k
237
208k
  // Because the AnalysisType may not be a subclass of pass (for
238
208k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
208k
  // adjust the return pointer (because the class may multiply inherit, once
240
208k
  // from pass, once from AnalysisType).
241
208k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
208k
}
polly::ScopInfoWrapperPass& llvm::Pass::getAnalysisID<polly::ScopInfoWrapperPass>(void const*) const
Line
Count
Source
226
45
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
45
  assert(PI && "getAnalysis for unregistered pass!");
228
45
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
45
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
45
  // should be a small number, we just do a linear search over a (dense)
231
45
  // vector.
232
45
  Pass *ResultPass = Resolver->findImplPass(PI);
233
45
  assert(ResultPass &&
234
45
         "getAnalysis*() called on an analysis that was not "
235
45
         "'required' by pass!");
236
45
237
45
  // Because the AnalysisType may not be a subclass of pass (for
238
45
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
45
  // adjust the return pointer (because the class may multiply inherit, once
240
45
  // from pass, once from AnalysisType).
241
45
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
45
}
polly::DependenceInfoWrapperPass& llvm::Pass::getAnalysisID<polly::DependenceInfoWrapperPass>(void const*) const
Line
Count
Source
226
19
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
19
  assert(PI && "getAnalysis for unregistered pass!");
228
19
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
19
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
19
  // should be a small number, we just do a linear search over a (dense)
231
19
  // vector.
232
19
  Pass *ResultPass = Resolver->findImplPass(PI);
233
19
  assert(ResultPass &&
234
19
         "getAnalysis*() called on an analysis that was not "
235
19
         "'required' by pass!");
236
19
237
19
  // Because the AnalysisType may not be a subclass of pass (for
238
19
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
19
  // adjust the return pointer (because the class may multiply inherit, once
240
19
  // from pass, once from AnalysisType).
241
19
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
19
}
polly::ScopDetectionWrapperPass& llvm::Pass::getAnalysisID<polly::ScopDetectionWrapperPass>(void const*) const
Line
Count
Source
226
4.34k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
4.34k
  assert(PI && "getAnalysis for unregistered pass!");
228
4.34k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
4.34k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
4.34k
  // should be a small number, we just do a linear search over a (dense)
231
4.34k
  // vector.
232
4.34k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
4.34k
  assert(ResultPass &&
234
4.34k
         "getAnalysis*() called on an analysis that was not "
235
4.34k
         "'required' by pass!");
236
4.34k
237
4.34k
  // Because the AnalysisType may not be a subclass of pass (for
238
4.34k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
4.34k
  // adjust the return pointer (because the class may multiply inherit, once
240
4.34k
  // from pass, once from AnalysisType).
241
4.34k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
4.34k
}
polly::ScopInfoRegionPass& llvm::Pass::getAnalysisID<polly::ScopInfoRegionPass>(void const*) const
Line
Count
Source
226
6.82k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
6.82k
  assert(PI && "getAnalysis for unregistered pass!");
228
6.82k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
6.82k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
6.82k
  // should be a small number, we just do a linear search over a (dense)
231
6.82k
  // vector.
232
6.82k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
6.82k
  assert(ResultPass &&
234
6.82k
         "getAnalysis*() called on an analysis that was not "
235
6.82k
         "'required' by pass!");
236
6.82k
237
6.82k
  // Because the AnalysisType may not be a subclass of pass (for
238
6.82k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
6.82k
  // adjust the return pointer (because the class may multiply inherit, once
240
6.82k
  // from pass, once from AnalysisType).
241
6.82k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
6.82k
}
polly::DependenceInfo& llvm::Pass::getAnalysisID<polly::DependenceInfo>(void const*) const
Line
Count
Source
226
623
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
623
  assert(PI && "getAnalysis for unregistered pass!");
228
623
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
623
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
623
  // should be a small number, we just do a linear search over a (dense)
231
623
  // vector.
232
623
  Pass *ResultPass = Resolver->findImplPass(PI);
233
623
  assert(ResultPass &&
234
623
         "getAnalysis*() called on an analysis that was not "
235
623
         "'required' by pass!");
236
623
237
623
  // Because the AnalysisType may not be a subclass of pass (for
238
623
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
623
  // adjust the return pointer (because the class may multiply inherit, once
240
623
  // from pass, once from AnalysisType).
241
623
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
623
}
polly::IslAstInfoWrapperPass& llvm::Pass::getAnalysisID<polly::IslAstInfoWrapperPass>(void const*) const
Line
Count
Source
226
306
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
306
  assert(PI && "getAnalysis for unregistered pass!");
228
306
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
306
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
306
  // should be a small number, we just do a linear search over a (dense)
231
306
  // vector.
232
306
  Pass *ResultPass = Resolver->findImplPass(PI);
233
306
  assert(ResultPass &&
234
306
         "getAnalysis*() called on an analysis that was not "
235
306
         "'required' by pass!");
236
306
237
306
  // Because the AnalysisType may not be a subclass of pass (for
238
306
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
306
  // adjust the return pointer (because the class may multiply inherit, once
240
306
  // from pass, once from AnalysisType).
241
306
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
306
}
llvm::GISelCSEAnalysisWrapperPass& llvm::Pass::getAnalysisID<llvm::GISelCSEAnalysisWrapperPass>(void const*) const
Line
Count
Source
226
477k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
477k
  assert(PI && "getAnalysis for unregistered pass!");
228
477k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
477k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
477k
  // should be a small number, we just do a linear search over a (dense)
231
477k
  // vector.
232
477k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
477k
  assert(ResultPass &&
234
477k
         "getAnalysis*() called on an analysis that was not "
235
477k
         "'required' by pass!");
236
477k
237
477k
  // Because the AnalysisType may not be a subclass of pass (for
238
477k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
477k
  // adjust the return pointer (because the class may multiply inherit, once
240
477k
  // from pass, once from AnalysisType).
241
477k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
477k
}
llvm::StackProtector& llvm::Pass::getAnalysisID<llvm::StackProtector>(void const*) const
Line
Count
Source
226
515k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
515k
  assert(PI && "getAnalysis for unregistered pass!");
228
515k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
515k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
515k
  // should be a small number, we just do a linear search over a (dense)
231
515k
  // vector.
232
515k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
515k
  assert(ResultPass &&
234
515k
         "getAnalysis*() called on an analysis that was not "
235
515k
         "'required' by pass!");
236
515k
237
515k
  // Because the AnalysisType may not be a subclass of pass (for
238
515k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
515k
  // adjust the return pointer (because the class may multiply inherit, once
240
515k
  // from pass, once from AnalysisType).
241
515k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
515k
}
llvm::Pass& llvm::Pass::getAnalysisID<llvm::Pass>(void const*) const
Line
Count
Source
226
15.3k
AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
227
15.3k
  assert(PI && "getAnalysis for unregistered pass!");
228
15.3k
  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
229
15.3k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
230
15.3k
  // should be a small number, we just do a linear search over a (dense)
231
15.3k
  // vector.
232
15.3k
  Pass *ResultPass = Resolver->findImplPass(PI);
233
15.3k
  assert(ResultPass &&
234
15.3k
         "getAnalysis*() called on an analysis that was not "
235
15.3k
         "'required' by pass!");
236
15.3k
237
15.3k
  // Because the AnalysisType may not be a subclass of pass (for
238
15.3k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
239
15.3k
  // adjust the return pointer (because the class may multiply inherit, once
240
15.3k
  // from pass, once from AnalysisType).
241
15.3k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
242
15.3k
}
243
244
/// getAnalysis<AnalysisType>() - This function is used by subclasses to get
245
/// to the analysis information that they claim to use by overriding the
246
/// getAnalysisUsage function.
247
template<typename AnalysisType>
248
610k
AnalysisType &Pass::getAnalysis(Function &F) {
249
610k
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
250
610k
251
610k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
252
610k
}
llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysis<llvm::DominatorTreeWrapperPass>(llvm::Function&)
Line
Count
Source
248
596k
AnalysisType &Pass::getAnalysis(Function &F) {
249
596k
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
250
596k
251
596k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
252
596k
}
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysis<llvm::BlockFrequencyInfoWrapperPass>(llvm::Function&)
Line
Count
Source
248
13.2k
AnalysisType &Pass::getAnalysis(Function &F) {
249
13.2k
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
250
13.2k
251
13.2k
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
252
13.2k
}
llvm::StackSafetyInfoWrapperPass& llvm::Pass::getAnalysis<llvm::StackSafetyInfoWrapperPass>(llvm::Function&)
Line
Count
Source
248
78
AnalysisType &Pass::getAnalysis(Function &F) {
249
78
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
250
78
251
78
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
252
78
}
llvm::BranchProbabilityInfoWrapperPass& llvm::Pass::getAnalysis<llvm::BranchProbabilityInfoWrapperPass>(llvm::Function&)
Line
Count
Source
248
110
AnalysisType &Pass::getAnalysis(Function &F) {
249
110
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
250
110
251
110
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
252
110
}
llvm::PostDominatorTreeWrapperPass& llvm::Pass::getAnalysis<llvm::PostDominatorTreeWrapperPass>(llvm::Function&)
Line
Count
Source
248
69
AnalysisType &Pass::getAnalysis(Function &F) {
249
69
  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
250
69
251
69
  return getAnalysisID<AnalysisType>(&AnalysisType::ID, F);
252
69
}
253
254
template<typename AnalysisType>
255
610k
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
256
610k
  assert(PI && "getAnalysis for unregistered pass!");
257
610k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
258
610k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
259
610k
  // should be a small number, we just do a linear search over a (dense)
260
610k
  // vector.
261
610k
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
262
610k
  assert(ResultPass && "Unable to find requested analysis info");
263
610k
264
610k
  // Because the AnalysisType may not be a subclass of pass (for
265
610k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
266
610k
  // adjust the return pointer (because the class may multiply inherit, once
267
610k
  // from pass, once from AnalysisType).
268
610k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
269
610k
}
llvm::DominatorTreeWrapperPass& llvm::Pass::getAnalysisID<llvm::DominatorTreeWrapperPass>(void const*, llvm::Function&)
Line
Count
Source
255
596k
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
256
596k
  assert(PI && "getAnalysis for unregistered pass!");
257
596k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
258
596k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
259
596k
  // should be a small number, we just do a linear search over a (dense)
260
596k
  // vector.
261
596k
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
262
596k
  assert(ResultPass && "Unable to find requested analysis info");
263
596k
264
596k
  // Because the AnalysisType may not be a subclass of pass (for
265
596k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
266
596k
  // adjust the return pointer (because the class may multiply inherit, once
267
596k
  // from pass, once from AnalysisType).
268
596k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
269
596k
}
llvm::BlockFrequencyInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::BlockFrequencyInfoWrapperPass>(void const*, llvm::Function&)
Line
Count
Source
255
13.2k
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
256
13.2k
  assert(PI && "getAnalysis for unregistered pass!");
257
13.2k
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
258
13.2k
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
259
13.2k
  // should be a small number, we just do a linear search over a (dense)
260
13.2k
  // vector.
261
13.2k
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
262
13.2k
  assert(ResultPass && "Unable to find requested analysis info");
263
13.2k
264
13.2k
  // Because the AnalysisType may not be a subclass of pass (for
265
13.2k
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
266
13.2k
  // adjust the return pointer (because the class may multiply inherit, once
267
13.2k
  // from pass, once from AnalysisType).
268
13.2k
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
269
13.2k
}
llvm::StackSafetyInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::StackSafetyInfoWrapperPass>(void const*, llvm::Function&)
Line
Count
Source
255
78
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
256
78
  assert(PI && "getAnalysis for unregistered pass!");
257
78
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
258
78
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
259
78
  // should be a small number, we just do a linear search over a (dense)
260
78
  // vector.
261
78
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
262
78
  assert(ResultPass && "Unable to find requested analysis info");
263
78
264
78
  // Because the AnalysisType may not be a subclass of pass (for
265
78
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
266
78
  // adjust the return pointer (because the class may multiply inherit, once
267
78
  // from pass, once from AnalysisType).
268
78
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
269
78
}
llvm::BranchProbabilityInfoWrapperPass& llvm::Pass::getAnalysisID<llvm::BranchProbabilityInfoWrapperPass>(void const*, llvm::Function&)
Line
Count
Source
255
110
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
256
110
  assert(PI && "getAnalysis for unregistered pass!");
257
110
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
258
110
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
259
110
  // should be a small number, we just do a linear search over a (dense)
260
110
  // vector.
261
110
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
262
110
  assert(ResultPass && "Unable to find requested analysis info");
263
110
264
110
  // Because the AnalysisType may not be a subclass of pass (for
265
110
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
266
110
  // adjust the return pointer (because the class may multiply inherit, once
267
110
  // from pass, once from AnalysisType).
268
110
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
269
110
}
llvm::PostDominatorTreeWrapperPass& llvm::Pass::getAnalysisID<llvm::PostDominatorTreeWrapperPass>(void const*, llvm::Function&)
Line
Count
Source
255
69
AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
256
69
  assert(PI && "getAnalysis for unregistered pass!");
257
69
  assert(Resolver && "Pass has not been inserted into a PassManager object!");
258
69
  // PI *must* appear in AnalysisImpls.  Because the number of passes used
259
69
  // should be a small number, we just do a linear search over a (dense)
260
69
  // vector.
261
69
  Pass *ResultPass = Resolver->findImplPass(this, PI, F);
262
69
  assert(ResultPass && "Unable to find requested analysis info");
263
69
264
69
  // Because the AnalysisType may not be a subclass of pass (for
265
69
  // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
266
69
  // adjust the return pointer (because the class may multiply inherit, once
267
69
  // from pass, once from AnalysisType).
268
69
  return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
269
69
}
270
271
} // end namespace llvm
272
273
#endif // LLVM_PASSANALYSISSUPPORT_H