Coverage Report

Created: 2019-02-21 13:17

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