Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Analysis/OptimizationRemarkEmitter.h
Line
Count
Source (jump to first uncovered line)
1
//===- OptimizationRemarkEmitter.h - Optimization Diagnostic ----*- 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
// Optimization diagnostic interfaces.  It's packaged as an analysis pass so
10
// that by using this service passes become dependent on BFI as well.  BFI is
11
// used to compute the "hotness" of the diagnostic message.
12
//===----------------------------------------------------------------------===//
13
14
#ifndef LLVM_IR_OPTIMIZATIONDIAGNOSTICINFO_H
15
#define LLVM_IR_OPTIMIZATIONDIAGNOSTICINFO_H
16
17
#include "llvm/ADT/Optional.h"
18
#include "llvm/Analysis/BlockFrequencyInfo.h"
19
#include "llvm/IR/DiagnosticInfo.h"
20
#include "llvm/IR/Function.h"
21
#include "llvm/IR/PassManager.h"
22
#include "llvm/Pass.h"
23
24
namespace llvm {
25
class DebugLoc;
26
class Loop;
27
class Pass;
28
class Twine;
29
class Value;
30
31
/// The optimization diagnostic interface.
32
///
33
/// It allows reporting when optimizations are performed and when they are not
34
/// along with the reasons for it.  Hotness information of the corresponding
35
/// code region can be included in the remark if DiagnosticsHotnessRequested is
36
/// enabled in the LLVM context.
37
class OptimizationRemarkEmitter {
38
public:
39
  OptimizationRemarkEmitter(const Function *F, BlockFrequencyInfo *BFI)
40
6.23M
      : F(F), BFI(BFI) {}
41
42
  /// This variant can be used to generate ORE on demand (without the
43
  /// analysis pass).
44
  ///
45
  /// Note that this ctor has a very different cost depending on whether
46
  /// F->getContext().getDiagnosticsHotnessRequested() is on or not.  If it's off
47
  /// the operation is free.
48
  ///
49
  /// Whereas if DiagnosticsHotnessRequested is on, it is fairly expensive
50
  /// operation since BFI and all its required analyses are computed.  This is
51
  /// for example useful for CGSCC passes that can't use function analyses
52
  /// passes in the old PM.
53
  OptimizationRemarkEmitter(const Function *F);
54
55
  OptimizationRemarkEmitter(OptimizationRemarkEmitter &&Arg)
56
8.43k
      : F(Arg.F), BFI(Arg.BFI) {}
57
58
0
  OptimizationRemarkEmitter &operator=(OptimizationRemarkEmitter &&RHS) {
59
0
    F = RHS.F;
60
0
    BFI = RHS.BFI;
61
0
    return *this;
62
0
  }
63
64
  /// Handle invalidation events in the new pass manager.
65
  bool invalidate(Function &F, const PreservedAnalyses &PA,
66
                  FunctionAnalysisManager::Invalidator &Inv);
67
68
  /// Output the remark via the diagnostic handler and to the
69
  /// optimization record file.
70
  void emit(DiagnosticInfoOptimizationBase &OptDiag);
71
72
  /// Take a lambda that returns a remark which will be emitted.  Second
73
  /// argument is only used to restrict this to functions.
74
  template <typename T>
75
5.52M
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
5.52M
    // Avoid building the remark unless we know there are at least *some*
77
5.52M
    // remarks enabled. We can't currently check whether remarks are requested
78
5.52M
    // for the calling pass since that requires actually building the remark.
79
5.52M
80
5.52M
    if (F->getContext().getRemarkStreamer() ||
81
5.52M
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()5.52M
) {
82
703
      auto R = RemarkBuilder();
83
703
      emit((DiagnosticInfoOptimizationBase &)R);
84
703
    }
85
5.52M
  }
Unexecuted instantiation: InlineCost.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::CallAnalyzer::analyzeBlock(llvm::BasicBlock*, llvm::SmallPtrSetImpl<llvm::Value const*>&)::$_8>((anonymous namespace)::CallAnalyzer::analyzeBlock(llvm::BasicBlock*, llvm::SmallPtrSetImpl<llvm::Value const*>&)::$_8, decltype(fp())*)
Unexecuted instantiation: InlineCost.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::CallAnalyzer::analyzeBlock(llvm::BasicBlock*, llvm::SmallPtrSetImpl<llvm::Value const*>&)::$_9>((anonymous namespace)::CallAnalyzer::analyzeBlock(llvm::BasicBlock*, llvm::SmallPtrSetImpl<llvm::Value const*>&)::$_9, decltype(fp())*)
ValueTracking.cpp:void llvm::OptimizationRemarkEmitter::emit<computeKnownBitsFromAssume(llvm::Value const*, llvm::KnownBits&, unsigned int, (anonymous namespace)::Query const&)::$_3>(computeKnownBitsFromAssume(llvm::Value const*, llvm::KnownBits&, unsigned int, (anonymous namespace)::Query const&)::$_3, decltype(fp())*)
Line
Count
Source
75
4
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
4
    // Avoid building the remark unless we know there are at least *some*
77
4
    // remarks enabled. We can't currently check whether remarks are requested
78
4
    // for the calling pass since that requires actually building the remark.
79
4
80
4
    if (F->getContext().getRemarkStreamer() ||
81
4
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
4
      auto R = RemarkBuilder();
83
4
      emit((DiagnosticInfoOptimizationBase &)R);
84
4
    }
85
4
  }
InterleavedLoadCombinePass.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::InterleavedLoadCombineImpl::combine(std::__1::list<(anonymous namespace)::VectorInfo, std::__1::allocator<(anonymous namespace)::VectorInfo> >&, llvm::OptimizationRemarkEmitter&)::$_1>((anonymous namespace)::InterleavedLoadCombineImpl::combine(std::__1::list<(anonymous namespace)::VectorInfo, std::__1::allocator<(anonymous namespace)::VectorInfo> >&, llvm::OptimizationRemarkEmitter&)::$_1, decltype(fp())*)
Line
Count
Source
75
10
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
10
    // Avoid building the remark unless we know there are at least *some*
77
10
    // remarks enabled. We can't currently check whether remarks are requested
78
10
    // for the calling pass since that requires actually building the remark.
79
10
80
10
    if (F->getContext().getRemarkStreamer() ||
81
10
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
10
  }
StackProtector.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::StackProtector::RequiresStackProtector()::$_0>(llvm::StackProtector::RequiresStackProtector()::$_0, decltype(fp())*)
Line
Count
Source
75
235
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
235
    // Avoid building the remark unless we know there are at least *some*
77
235
    // remarks enabled. We can't currently check whether remarks are requested
78
235
    // for the calling pass since that requires actually building the remark.
79
235
80
235
    if (F->getContext().getRemarkStreamer() ||
81
235
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()233
) {
82
4
      auto R = RemarkBuilder();
83
4
      emit((DiagnosticInfoOptimizationBase &)R);
84
4
    }
85
235
  }
StackProtector.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::StackProtector::RequiresStackProtector()::$_1>(llvm::StackProtector::RequiresStackProtector()::$_1, decltype(fp())*)
Line
Count
Source
75
231
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
231
    // Avoid building the remark unless we know there are at least *some*
77
231
    // remarks enabled. We can't currently check whether remarks are requested
78
231
    // for the calling pass since that requires actually building the remark.
79
231
80
231
    if (F->getContext().getRemarkStreamer() ||
81
231
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()227
) {
82
8
      auto R = RemarkBuilder();
83
8
      emit((DiagnosticInfoOptimizationBase &)R);
84
8
    }
85
231
  }
StackProtector.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::StackProtector::RequiresStackProtector()::$_2>(llvm::StackProtector::RequiresStackProtector()::$_2, decltype(fp())*)
Line
Count
Source
75
3.27k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
3.27k
    // Avoid building the remark unless we know there are at least *some*
77
3.27k
    // remarks enabled. We can't currently check whether remarks are requested
78
3.27k
    // for the calling pass since that requires actually building the remark.
79
3.27k
80
3.27k
    if (F->getContext().getRemarkStreamer() ||
81
3.27k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()3.27k
) {
82
15
      auto R = RemarkBuilder();
83
15
      emit((DiagnosticInfoOptimizationBase &)R);
84
15
    }
85
3.27k
  }
StackProtector.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::StackProtector::RequiresStackProtector()::$_3>(llvm::StackProtector::RequiresStackProtector()::$_3, decltype(fp())*)
Line
Count
Source
75
307
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
307
    // Avoid building the remark unless we know there are at least *some*
77
307
    // remarks enabled. We can't currently check whether remarks are requested
78
307
    // for the calling pass since that requires actually building the remark.
79
307
80
307
    if (F->getContext().getRemarkStreamer() ||
81
307
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()305
) {
82
5
      auto R = RemarkBuilder();
83
5
      emit((DiagnosticInfoOptimizationBase &)R);
84
5
    }
85
307
  }
HotColdSplitting.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::HotColdSplitting::extractColdRegion(llvm::SmallVector<llvm::BasicBlock*, 0u> const&, llvm::DominatorTree&, llvm::BlockFrequencyInfo*, llvm::TargetTransformInfo&, llvm::OptimizationRemarkEmitter&, llvm::AssumptionCache*, unsigned int)::$_4>((anonymous namespace)::HotColdSplitting::extractColdRegion(llvm::SmallVector<llvm::BasicBlock*, 0u> const&, llvm::DominatorTree&, llvm::BlockFrequencyInfo*, llvm::TargetTransformInfo&, llvm::OptimizationRemarkEmitter&, llvm::AssumptionCache*, unsigned int)::$_4, decltype(fp())*)
Line
Count
Source
75
40
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
40
    // Avoid building the remark unless we know there are at least *some*
77
40
    // remarks enabled. We can't currently check whether remarks are requested
78
40
    // for the calling pass since that requires actually building the remark.
79
40
80
40
    if (F->getContext().getRemarkStreamer() ||
81
40
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
2
      auto R = RemarkBuilder();
83
2
      emit((DiagnosticInfoOptimizationBase &)R);
84
2
    }
85
40
  }
HotColdSplitting.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::HotColdSplitting::extractColdRegion(llvm::SmallVector<llvm::BasicBlock*, 0u> const&, llvm::DominatorTree&, llvm::BlockFrequencyInfo*, llvm::TargetTransformInfo&, llvm::OptimizationRemarkEmitter&, llvm::AssumptionCache*, unsigned int)::$_5>((anonymous namespace)::HotColdSplitting::extractColdRegion(llvm::SmallVector<llvm::BasicBlock*, 0u> const&, llvm::DominatorTree&, llvm::BlockFrequencyInfo*, llvm::TargetTransformInfo&, llvm::OptimizationRemarkEmitter&, llvm::AssumptionCache*, unsigned int)::$_5, decltype(fp())*)
Line
Count
Source
75
1
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
1
    // Avoid building the remark unless we know there are at least *some*
77
1
    // remarks enabled. We can't currently check whether remarks are requested
78
1
    // for the calling pass since that requires actually building the remark.
79
1
80
1
    if (F->getContext().getRemarkStreamer() ||
81
1
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
1
  }
Inliner.cpp:void llvm::OptimizationRemarkEmitter::emit<inlineCallsImpl(llvm::CallGraphSCC&, llvm::CallGraph&, std::__1::function<llvm::AssumptionCache& (llvm::Function&)>, llvm::ProfileSummaryInfo*, llvm::TargetLibraryInfo&, bool, llvm::function_ref<llvm::InlineCost (llvm::CallSite)>, llvm::function_ref<llvm::AAResults& (llvm::Function&)>, llvm::ImportedFunctionsInliningStatistics&)::$_14>(inlineCallsImpl(llvm::CallGraphSCC&, llvm::CallGraph&, std::__1::function<llvm::AssumptionCache& (llvm::Function&)>, llvm::ProfileSummaryInfo*, llvm::TargetLibraryInfo&, bool, llvm::function_ref<llvm::InlineCost (llvm::CallSite)>, llvm::function_ref<llvm::AAResults& (llvm::Function&)>, llvm::ImportedFunctionsInliningStatistics&)::$_14, decltype(fp())*)
Line
Count
Source
75
524k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
524k
    // Avoid building the remark unless we know there are at least *some*
77
524k
    // remarks enabled. We can't currently check whether remarks are requested
78
524k
    // for the calling pass since that requires actually building the remark.
79
524k
80
524k
    if (F->getContext().getRemarkStreamer() ||
81
524k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()524k
) {
82
37
      auto R = RemarkBuilder();
83
37
      emit((DiagnosticInfoOptimizationBase &)R);
84
37
    }
85
524k
  }
Inliner.cpp:void llvm::OptimizationRemarkEmitter::emit<inlineCallsImpl(llvm::CallGraphSCC&, llvm::CallGraph&, std::__1::function<llvm::AssumptionCache& (llvm::Function&)>, llvm::ProfileSummaryInfo*, llvm::TargetLibraryInfo&, bool, llvm::function_ref<llvm::InlineCost (llvm::CallSite)>, llvm::function_ref<llvm::AAResults& (llvm::Function&)>, llvm::ImportedFunctionsInliningStatistics&)::$_15>(inlineCallsImpl(llvm::CallGraphSCC&, llvm::CallGraph&, std::__1::function<llvm::AssumptionCache& (llvm::Function&)>, llvm::ProfileSummaryInfo*, llvm::TargetLibraryInfo&, bool, llvm::function_ref<llvm::InlineCost (llvm::CallSite)>, llvm::function_ref<llvm::AAResults& (llvm::Function&)>, llvm::ImportedFunctionsInliningStatistics&)::$_15, decltype(fp())*)
Line
Count
Source
75
5
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
5
    // Avoid building the remark unless we know there are at least *some*
77
5
    // remarks enabled. We can't currently check whether remarks are requested
78
5
    // for the calling pass since that requires actually building the remark.
79
5
80
5
    if (F->getContext().getRemarkStreamer() ||
81
5
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
5
  }
Inliner.cpp:void llvm::OptimizationRemarkEmitter::emit<shouldInline(llvm::CallSite, llvm::function_ref<llvm::InlineCost (llvm::CallSite)>, llvm::OptimizationRemarkEmitter&)::$_10>(shouldInline(llvm::CallSite, llvm::function_ref<llvm::InlineCost (llvm::CallSite)>, llvm::OptimizationRemarkEmitter&)::$_10, decltype(fp())*)
Line
Count
Source
75
827k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
827k
    // Avoid building the remark unless we know there are at least *some*
77
827k
    // remarks enabled. We can't currently check whether remarks are requested
78
827k
    // for the calling pass since that requires actually building the remark.
79
827k
80
827k
    if (F->getContext().getRemarkStreamer() ||
81
827k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
40
      auto R = RemarkBuilder();
83
40
      emit((DiagnosticInfoOptimizationBase &)R);
84
40
    }
85
827k
  }
Inliner.cpp:void llvm::OptimizationRemarkEmitter::emit<shouldInline(llvm::CallSite, llvm::function_ref<llvm::InlineCost (llvm::CallSite)>, llvm::OptimizationRemarkEmitter&)::$_11>(shouldInline(llvm::CallSite, llvm::function_ref<llvm::InlineCost (llvm::CallSite)>, llvm::OptimizationRemarkEmitter&)::$_11, decltype(fp())*)
Line
Count
Source
75
142k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
142k
    // Avoid building the remark unless we know there are at least *some*
77
142k
    // remarks enabled. We can't currently check whether remarks are requested
78
142k
    // for the calling pass since that requires actually building the remark.
79
142k
80
142k
    if (F->getContext().getRemarkStreamer() ||
81
142k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
18
      auto R = RemarkBuilder();
83
18
      emit((DiagnosticInfoOptimizationBase &)R);
84
18
    }
85
142k
  }
Inliner.cpp:void llvm::OptimizationRemarkEmitter::emit<shouldInline(llvm::CallSite, llvm::function_ref<llvm::InlineCost (llvm::CallSite)>, llvm::OptimizationRemarkEmitter&)::$_12>(shouldInline(llvm::CallSite, llvm::function_ref<llvm::InlineCost (llvm::CallSite)>, llvm::OptimizationRemarkEmitter&)::$_12, decltype(fp())*)
Line
Count
Source
75
2.08k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
2.08k
    // Avoid building the remark unless we know there are at least *some*
77
2.08k
    // remarks enabled. We can't currently check whether remarks are requested
78
2.08k
    // for the calling pass since that requires actually building the remark.
79
2.08k
80
2.08k
    if (F->getContext().getRemarkStreamer() ||
81
2.08k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
2.08k
  }
Inliner.cpp:void llvm::OptimizationRemarkEmitter::emit<emit_inlined_into(llvm::OptimizationRemarkEmitter&, llvm::DebugLoc&, llvm::BasicBlock const*, llvm::Function const&, llvm::Function const&, llvm::InlineCost const&)::$_13>(emit_inlined_into(llvm::OptimizationRemarkEmitter&, llvm::DebugLoc&, llvm::BasicBlock const*, llvm::Function const&, llvm::Function const&, llvm::InlineCost const&)::$_13, decltype(fp())*)
Line
Count
Source
75
540k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
540k
    // Avoid building the remark unless we know there are at least *some*
77
540k
    // remarks enabled. We can't currently check whether remarks are requested
78
540k
    // for the calling pass since that requires actually building the remark.
79
540k
80
540k
    if (F->getContext().getRemarkStreamer() ||
81
540k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()540k
) {
82
83
      auto R = RemarkBuilder();
83
83
      emit((DiagnosticInfoOptimizationBase &)R);
84
83
    }
85
540k
  }
Inliner.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::InlinerPass::run(llvm::LazyCallGraph::SCC&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&)::$_3>(llvm::InlinerPass::run(llvm::LazyCallGraph::SCC&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&)::$_3, decltype(fp())*)
Line
Count
Source
75
2.80k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
2.80k
    // Avoid building the remark unless we know there are at least *some*
77
2.80k
    // remarks enabled. We can't currently check whether remarks are requested
78
2.80k
    // for the calling pass since that requires actually building the remark.
79
2.80k
80
2.80k
    if (F->getContext().getRemarkStreamer() ||
81
2.80k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()2.79k
) {
82
14
      auto R = RemarkBuilder();
83
14
      emit((DiagnosticInfoOptimizationBase &)R);
84
14
    }
85
2.80k
  }
Unexecuted instantiation: Inliner.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::InlinerPass::run(llvm::LazyCallGraph::SCC&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&)::$_7>(llvm::InlinerPass::run(llvm::LazyCallGraph::SCC&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&)::$_7, decltype(fp())*)
Unexecuted instantiation: PartialInlining.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::PartialInlinerImpl::computeOutliningColdRegionsInfo(llvm::Function*, llvm::OptimizationRemarkEmitter&)::$_4::operator()(llvm::SmallVectorImpl<llvm::BasicBlock*>&) const::'lambda'()>((anonymous namespace)::PartialInlinerImpl::computeOutliningColdRegionsInfo(llvm::Function*, llvm::OptimizationRemarkEmitter&)::$_4::operator()(llvm::SmallVectorImpl<llvm::BasicBlock*>&) const::'lambda'(), decltype(fp())*)
Unexecuted instantiation: PartialInlining.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::PartialInlinerImpl::computeOutliningColdRegionsInfo(llvm::Function*, llvm::OptimizationRemarkEmitter&)::$_5>((anonymous namespace)::PartialInlinerImpl::computeOutliningColdRegionsInfo(llvm::Function*, llvm::OptimizationRemarkEmitter&)::$_5, decltype(fp())*)
Unexecuted instantiation: PartialInlining.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::PartialInlinerImpl::FunctionCloner::doMultiRegionFunctionOutlining()::$_12>((anonymous namespace)::PartialInlinerImpl::FunctionCloner::doMultiRegionFunctionOutlining()::$_12, decltype(fp())*)
Unexecuted instantiation: PartialInlining.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::PartialInlinerImpl::tryPartialInline((anonymous namespace)::PartialInlinerImpl::FunctionCloner&)::$_14>((anonymous namespace)::PartialInlinerImpl::tryPartialInline((anonymous namespace)::PartialInlinerImpl::FunctionCloner&)::$_14, decltype(fp())*)
Unexecuted instantiation: PartialInlining.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::PartialInlinerImpl::shouldPartialInline(llvm::CallSite, (anonymous namespace)::PartialInlinerImpl::FunctionCloner&, llvm::BlockFrequency, llvm::OptimizationRemarkEmitter&)::$_6>((anonymous namespace)::PartialInlinerImpl::shouldPartialInline(llvm::CallSite, (anonymous namespace)::PartialInlinerImpl::FunctionCloner&, llvm::BlockFrequency, llvm::OptimizationRemarkEmitter&)::$_6, decltype(fp())*)
Unexecuted instantiation: PartialInlining.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::PartialInlinerImpl::shouldPartialInline(llvm::CallSite, (anonymous namespace)::PartialInlinerImpl::FunctionCloner&, llvm::BlockFrequency, llvm::OptimizationRemarkEmitter&)::$_7>((anonymous namespace)::PartialInlinerImpl::shouldPartialInline(llvm::CallSite, (anonymous namespace)::PartialInlinerImpl::FunctionCloner&, llvm::BlockFrequency, llvm::OptimizationRemarkEmitter&)::$_7, decltype(fp())*)
PartialInlining.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::PartialInlinerImpl::shouldPartialInline(llvm::CallSite, (anonymous namespace)::PartialInlinerImpl::FunctionCloner&, llvm::BlockFrequency, llvm::OptimizationRemarkEmitter&)::$_8>((anonymous namespace)::PartialInlinerImpl::shouldPartialInline(llvm::CallSite, (anonymous namespace)::PartialInlinerImpl::FunctionCloner&, llvm::BlockFrequency, llvm::OptimizationRemarkEmitter&)::$_8, decltype(fp())*)
Line
Count
Source
75
2
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
2
    // Avoid building the remark unless we know there are at least *some*
77
2
    // remarks enabled. We can't currently check whether remarks are requested
78
2
    // for the calling pass since that requires actually building the remark.
79
2
80
2
    if (F->getContext().getRemarkStreamer() ||
81
2
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
2
      auto R = RemarkBuilder();
83
2
      emit((DiagnosticInfoOptimizationBase &)R);
84
2
    }
85
2
  }
PartialInlining.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::PartialInlinerImpl::shouldPartialInline(llvm::CallSite, (anonymous namespace)::PartialInlinerImpl::FunctionCloner&, llvm::BlockFrequency, llvm::OptimizationRemarkEmitter&)::$_9>((anonymous namespace)::PartialInlinerImpl::shouldPartialInline(llvm::CallSite, (anonymous namespace)::PartialInlinerImpl::FunctionCloner&, llvm::BlockFrequency, llvm::OptimizationRemarkEmitter&)::$_9, decltype(fp())*)
Line
Count
Source
75
4
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
4
    // Avoid building the remark unless we know there are at least *some*
77
4
    // remarks enabled. We can't currently check whether remarks are requested
78
4
    // for the calling pass since that requires actually building the remark.
79
4
80
4
    if (F->getContext().getRemarkStreamer() ||
81
4
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
4
  }
PartialInlining.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::PartialInlinerImpl::shouldPartialInline(llvm::CallSite, (anonymous namespace)::PartialInlinerImpl::FunctionCloner&, llvm::BlockFrequency, llvm::OptimizationRemarkEmitter&)::$_10>((anonymous namespace)::PartialInlinerImpl::shouldPartialInline(llvm::CallSite, (anonymous namespace)::PartialInlinerImpl::FunctionCloner&, llvm::BlockFrequency, llvm::OptimizationRemarkEmitter&)::$_10, decltype(fp())*)
Line
Count
Source
75
20
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
20
    // Avoid building the remark unless we know there are at least *some*
77
20
    // remarks enabled. We can't currently check whether remarks are requested
78
20
    // for the calling pass since that requires actually building the remark.
79
20
80
20
    if (F->getContext().getRemarkStreamer() ||
81
20
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
4
      auto R = RemarkBuilder();
83
4
      emit((DiagnosticInfoOptimizationBase &)R);
84
4
    }
85
20
  }
PartialInlining.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::PartialInlinerImpl::tryPartialInline((anonymous namespace)::PartialInlinerImpl::FunctionCloner&)::$_15>((anonymous namespace)::PartialInlinerImpl::tryPartialInline((anonymous namespace)::PartialInlinerImpl::FunctionCloner&)::$_15, decltype(fp())*)
Line
Count
Source
75
83
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
83
    // Avoid building the remark unless we know there are at least *some*
77
83
    // remarks enabled. We can't currently check whether remarks are requested
78
83
    // for the calling pass since that requires actually building the remark.
79
83
80
83
    if (F->getContext().getRemarkStreamer() ||
81
83
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
4
      auto R = RemarkBuilder();
83
4
      emit((DiagnosticInfoOptimizationBase &)R);
84
4
    }
85
83
  }
PartialInlining.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::PartialInlinerImpl::FunctionCloner::doSingleRegionFunctionOutlining()::$_13>((anonymous namespace)::PartialInlinerImpl::FunctionCloner::doSingleRegionFunctionOutlining()::$_13, decltype(fp())*)
Line
Count
Source
75
4
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
4
    // Avoid building the remark unless we know there are at least *some*
77
4
    // remarks enabled. We can't currently check whether remarks are requested
78
4
    // for the calling pass since that requires actually building the remark.
79
4
80
4
    if (F->getContext().getRemarkStreamer() ||
81
4
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
2
      auto R = RemarkBuilder();
83
2
      emit((DiagnosticInfoOptimizationBase &)R);
84
2
    }
85
4
  }
SampleProfile.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::SampleProfileLoader::getInstWeight(llvm::Instruction const&)::$_2>((anonymous namespace)::SampleProfileLoader::getInstWeight(llvm::Instruction const&)::$_2, decltype(fp())*)
Line
Count
Source
75
249
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
249
    // Avoid building the remark unless we know there are at least *some*
77
249
    // remarks enabled. We can't currently check whether remarks are requested
78
249
    // for the calling pass since that requires actually building the remark.
79
249
80
249
    if (F->getContext().getRemarkStreamer() ||
81
249
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()239
) {
82
38
      auto R = RemarkBuilder();
83
38
      emit((DiagnosticInfoOptimizationBase &)R);
84
38
    }
85
249
  }
SampleProfile.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::SampleProfileLoader::propagateWeights(llvm::Function&)::$_5>((anonymous namespace)::SampleProfileLoader::propagateWeights(llvm::Function&)::$_5, decltype(fp())*)
Line
Count
Source
75
79
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
79
    // Avoid building the remark unless we know there are at least *some*
77
79
    // remarks enabled. We can't currently check whether remarks are requested
78
79
    // for the calling pass since that requires actually building the remark.
79
79
80
79
    if (F->getContext().getRemarkStreamer() ||
81
79
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()75
) {
82
14
      auto R = RemarkBuilder();
83
14
      emit((DiagnosticInfoOptimizationBase &)R);
84
14
    }
85
79
  }
ControlHeightReduction.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::CHR::findScope(llvm::Region*)::$_0>((anonymous namespace)::CHR::findScope(llvm::Region*)::$_0, decltype(fp())*)
Line
Count
Source
75
10
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
10
    // Avoid building the remark unless we know there are at least *some*
77
10
    // remarks enabled. We can't currently check whether remarks are requested
78
10
    // for the calling pass since that requires actually building the remark.
79
10
80
10
    if (F->getContext().getRemarkStreamer() ||
81
10
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
10
  }
Unexecuted instantiation: ControlHeightReduction.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::CHR::findScope(llvm::Region*)::$_1::operator()((anonymous namespace)::RegInfo&) const::'lambda'()>((anonymous namespace)::CHR::findScope(llvm::Region*)::$_1::operator()((anonymous namespace)::RegInfo&) const::'lambda'(), decltype(fp())*)
ControlHeightReduction.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::CHR::checkScopeHoistable((anonymous namespace)::CHRScope*)::$_2>((anonymous namespace)::CHR::checkScopeHoistable((anonymous namespace)::CHRScope*)::$_2, decltype(fp())*)
Line
Count
Source
75
2
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
2
    // Avoid building the remark unless we know there are at least *some*
77
2
    // remarks enabled. We can't currently check whether remarks are requested
78
2
    // for the calling pass since that requires actually building the remark.
79
2
80
2
    if (F->getContext().getRemarkStreamer() ||
81
2
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
2
  }
ControlHeightReduction.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::CHR::checkScopeHoistable((anonymous namespace)::CHRScope*)::$_3>((anonymous namespace)::CHR::checkScopeHoistable((anonymous namespace)::CHRScope*)::$_3, decltype(fp())*)
Line
Count
Source
75
12
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
12
    // Avoid building the remark unless we know there are at least *some*
77
12
    // remarks enabled. We can't currently check whether remarks are requested
78
12
    // for the calling pass since that requires actually building the remark.
79
12
80
12
    if (F->getContext().getRemarkStreamer() ||
81
12
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
12
  }
ControlHeightReduction.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::CHR::splitScope((anonymous namespace)::CHRScope*, (anonymous namespace)::CHRScope*, llvm::DenseSet<llvm::Value*, llvm::DenseMapInfo<llvm::Value*> >*, llvm::Instruction*, llvm::SmallVectorImpl<(anonymous namespace)::CHRScope*>&, llvm::DenseSet<llvm::Instruction*, llvm::DenseMapInfo<llvm::Instruction*> >&)::$_5>((anonymous namespace)::CHR::splitScope((anonymous namespace)::CHRScope*, (anonymous namespace)::CHRScope*, llvm::DenseSet<llvm::Value*, llvm::DenseMapInfo<llvm::Value*> >*, llvm::Instruction*, llvm::SmallVectorImpl<(anonymous namespace)::CHRScope*>&, llvm::DenseSet<llvm::Instruction*, llvm::DenseMapInfo<llvm::Instruction*> >&)::$_5, decltype(fp())*)
Line
Count
Source
75
4
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
4
    // Avoid building the remark unless we know there are at least *some*
77
4
    // remarks enabled. We can't currently check whether remarks are requested
78
4
    // for the calling pass since that requires actually building the remark.
79
4
80
4
    if (F->getContext().getRemarkStreamer() ||
81
4
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
4
  }
ControlHeightReduction.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::CHR::splitScope((anonymous namespace)::CHRScope*, (anonymous namespace)::CHRScope*, llvm::DenseSet<llvm::Value*, llvm::DenseMapInfo<llvm::Value*> >*, llvm::Instruction*, llvm::SmallVectorImpl<(anonymous namespace)::CHRScope*>&, llvm::DenseSet<llvm::Instruction*, llvm::DenseMapInfo<llvm::Instruction*> >&)::$_6>((anonymous namespace)::CHR::splitScope((anonymous namespace)::CHRScope*, (anonymous namespace)::CHRScope*, llvm::DenseSet<llvm::Value*, llvm::DenseMapInfo<llvm::Value*> >*, llvm::Instruction*, llvm::SmallVectorImpl<(anonymous namespace)::CHRScope*>&, llvm::DenseSet<llvm::Instruction*, llvm::DenseMapInfo<llvm::Instruction*> >&)::$_6, decltype(fp())*)
Line
Count
Source
75
6
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
6
    // Avoid building the remark unless we know there are at least *some*
77
6
    // remarks enabled. We can't currently check whether remarks are requested
78
6
    // for the calling pass since that requires actually building the remark.
79
6
80
6
    if (F->getContext().getRemarkStreamer() ||
81
6
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
6
  }
ControlHeightReduction.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::CHR::filterScopes(llvm::SmallVectorImpl<(anonymous namespace)::CHRScope*>&, llvm::SmallVectorImpl<(anonymous namespace)::CHRScope*>&)::$_7>((anonymous namespace)::CHR::filterScopes(llvm::SmallVectorImpl<(anonymous namespace)::CHRScope*>&, llvm::SmallVectorImpl<(anonymous namespace)::CHRScope*>&)::$_7, decltype(fp())*)
Line
Count
Source
75
14
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
14
    // Avoid building the remark unless we know there are at least *some*
77
14
    // remarks enabled. We can't currently check whether remarks are requested
78
14
    // for the calling pass since that requires actually building the remark.
79
14
80
14
    if (F->getContext().getRemarkStreamer() ||
81
14
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
14
  }
ControlHeightReduction.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::CHR::fixupBranchesAndSelects((anonymous namespace)::CHRScope*, llvm::BasicBlock*, llvm::BranchInst*, unsigned long long)::$_8>((anonymous namespace)::CHR::fixupBranchesAndSelects((anonymous namespace)::CHRScope*, llvm::BasicBlock*, llvm::BranchInst*, unsigned long long)::$_8, decltype(fp())*)
Line
Count
Source
75
46
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
46
    // Avoid building the remark unless we know there are at least *some*
77
46
    // remarks enabled. We can't currently check whether remarks are requested
78
46
    // for the calling pass since that requires actually building the remark.
79
46
80
46
    if (F->getContext().getRemarkStreamer() ||
81
46
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
46
  }
ControlHeightReduction.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::CHR::run()::$_9>((anonymous namespace)::CHR::run()::$_9, decltype(fp())*)
Line
Count
Source
75
40
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
40
    // Avoid building the remark unless we know there are at least *some*
77
40
    // remarks enabled. We can't currently check whether remarks are requested
78
40
    // for the calling pass since that requires actually building the remark.
79
40
80
40
    if (F->getContext().getRemarkStreamer() ||
81
40
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
40
  }
Unexecuted instantiation: IndirectCallPromotion.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::ICallPromotionFunc::getPromotionCandidatesForCallSite(llvm::Instruction*, llvm::ArrayRef<InstrProfValueData> const&, unsigned long long, unsigned int)::$_1>((anonymous namespace)::ICallPromotionFunc::getPromotionCandidatesForCallSite(llvm::Instruction*, llvm::ArrayRef<InstrProfValueData> const&, unsigned long long, unsigned int)::$_1, decltype(fp())*)
Unexecuted instantiation: IndirectCallPromotion.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::ICallPromotionFunc::getPromotionCandidatesForCallSite(llvm::Instruction*, llvm::ArrayRef<InstrProfValueData> const&, unsigned long long, unsigned int)::$_2>((anonymous namespace)::ICallPromotionFunc::getPromotionCandidatesForCallSite(llvm::Instruction*, llvm::ArrayRef<InstrProfValueData> const&, unsigned long long, unsigned int)::$_2, decltype(fp())*)
Unexecuted instantiation: IndirectCallPromotion.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::ICallPromotionFunc::getPromotionCandidatesForCallSite(llvm::Instruction*, llvm::ArrayRef<InstrProfValueData> const&, unsigned long long, unsigned int)::$_3>((anonymous namespace)::ICallPromotionFunc::getPromotionCandidatesForCallSite(llvm::Instruction*, llvm::ArrayRef<InstrProfValueData> const&, unsigned long long, unsigned int)::$_3, decltype(fp())*)
IndirectCallPromotion.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::ICallPromotionFunc::getPromotionCandidatesForCallSite(llvm::Instruction*, llvm::ArrayRef<InstrProfValueData> const&, unsigned long long, unsigned int)::$_4>((anonymous namespace)::ICallPromotionFunc::getPromotionCandidatesForCallSite(llvm::Instruction*, llvm::ArrayRef<InstrProfValueData> const&, unsigned long long, unsigned int)::$_4, decltype(fp())*)
Line
Count
Source
75
3
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
3
    // Avoid building the remark unless we know there are at least *some*
77
3
    // remarks enabled. We can't currently check whether remarks are requested
78
3
    // for the calling pass since that requires actually building the remark.
79
3
80
3
    if (F->getContext().getRemarkStreamer() ||
81
3
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
2
      auto R = RemarkBuilder();
83
2
      emit((DiagnosticInfoOptimizationBase &)R);
84
2
    }
85
3
  }
IndirectCallPromotion.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::ICallPromotionFunc::getPromotionCandidatesForCallSite(llvm::Instruction*, llvm::ArrayRef<InstrProfValueData> const&, unsigned long long, unsigned int)::$_5>((anonymous namespace)::ICallPromotionFunc::getPromotionCandidatesForCallSite(llvm::Instruction*, llvm::ArrayRef<InstrProfValueData> const&, unsigned long long, unsigned int)::$_5, decltype(fp())*)
Line
Count
Source
75
4
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
4
    // Avoid building the remark unless we know there are at least *some*
77
4
    // remarks enabled. We can't currently check whether remarks are requested
78
4
    // for the calling pass since that requires actually building the remark.
79
4
80
4
    if (F->getContext().getRemarkStreamer() ||
81
4
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
4
      auto R = RemarkBuilder();
83
4
      emit((DiagnosticInfoOptimizationBase &)R);
84
4
    }
85
4
  }
IndirectCallPromotion.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::pgo::promoteIndirectCall(llvm::Instruction*, llvm::Function*, unsigned long long, unsigned long long, bool, llvm::OptimizationRemarkEmitter*)::$_0>(llvm::pgo::promoteIndirectCall(llvm::Instruction*, llvm::Function*, unsigned long long, unsigned long long, bool, llvm::OptimizationRemarkEmitter*)::$_0, decltype(fp())*)
Line
Count
Source
75
62
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
62
    // Avoid building the remark unless we know there are at least *some*
77
62
    // remarks enabled. We can't currently check whether remarks are requested
78
62
    // for the calling pass since that requires actually building the remark.
79
62
80
62
    if (F->getContext().getRemarkStreamer() ||
81
62
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
12
      auto R = RemarkBuilder();
83
12
      emit((DiagnosticInfoOptimizationBase &)R);
84
12
    }
85
62
  }
PGOInstrumentation.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::setProfMetadata(llvm::Module*, llvm::Instruction*, llvm::ArrayRef<unsigned long long>, unsigned long long)::$_6>(llvm::setProfMetadata(llvm::Module*, llvm::Instruction*, llvm::ArrayRef<unsigned long long>, unsigned long long)::$_6, decltype(fp())*)
Line
Count
Source
75
4
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
4
    // Avoid building the remark unless we know there are at least *some*
77
4
    // remarks enabled. We can't currently check whether remarks are requested
78
4
    // for the calling pass since that requires actually building the remark.
79
4
80
4
    if (F->getContext().getRemarkStreamer() ||
81
4
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
4
      auto R = RemarkBuilder();
83
4
      emit((DiagnosticInfoOptimizationBase &)R);
84
4
    }
85
4
  }
PGOMemOPSizeOpt.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::MemOPSizeOpt::perform(llvm::MemIntrinsic*)::$_0>((anonymous namespace)::MemOPSizeOpt::perform(llvm::MemIntrinsic*)::$_0, decltype(fp())*)
Line
Count
Source
75
10
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
10
    // Avoid building the remark unless we know there are at least *some*
77
10
    // remarks enabled. We can't currently check whether remarks are requested
78
10
    // for the calling pass since that requires actually building the remark.
79
10
80
10
    if (F->getContext().getRemarkStreamer() ||
81
10
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()6
) {
82
4
      auto R = RemarkBuilder();
83
4
      emit((DiagnosticInfoOptimizationBase &)R);
84
4
    }
85
10
  }
GVN.cpp:void llvm::OptimizationRemarkEmitter::emit<reportLoadElim(llvm::LoadInst*, llvm::Value*, llvm::OptimizationRemarkEmitter*)::$_2>(reportLoadElim(llvm::LoadInst*, llvm::Value*, llvm::OptimizationRemarkEmitter*)::$_2, decltype(fp())*)
Line
Count
Source
75
41.2k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
41.2k
    // Avoid building the remark unless we know there are at least *some*
77
41.2k
    // remarks enabled. We can't currently check whether remarks are requested
78
41.2k
    // for the calling pass since that requires actually building the remark.
79
41.2k
80
41.2k
    if (F->getContext().getRemarkStreamer() ||
81
41.2k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()41.2k
) {
82
12
      auto R = RemarkBuilder();
83
12
      emit((DiagnosticInfoOptimizationBase &)R);
84
12
    }
85
41.2k
  }
GVN.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::GVN::PerformLoadPRE(llvm::LoadInst*, llvm::SmallVector<llvm::gvn::AvailableValueInBlock, 64u>&, llvm::SmallVector<llvm::BasicBlock*, 64u>&)::$_0>(llvm::GVN::PerformLoadPRE(llvm::LoadInst*, llvm::SmallVector<llvm::gvn::AvailableValueInBlock, 64u>&, llvm::SmallVector<llvm::BasicBlock*, 64u>&)::$_0, decltype(fp())*)
Line
Count
Source
75
25.2k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
25.2k
    // Avoid building the remark unless we know there are at least *some*
77
25.2k
    // remarks enabled. We can't currently check whether remarks are requested
78
25.2k
    // for the calling pass since that requires actually building the remark.
79
25.2k
80
25.2k
    if (F->getContext().getRemarkStreamer() ||
81
25.2k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
25.2k
  }
LICM.cpp:void llvm::OptimizationRemarkEmitter::emit<sink(llvm::Instruction&, llvm::LoopInfo*, llvm::DominatorTree*, llvm::Loop const*, llvm::ICFLoopSafetyInfo*, llvm::MemorySSAUpdater*, llvm::OptimizationRemarkEmitter*)::$_7>(sink(llvm::Instruction&, llvm::LoopInfo*, llvm::DominatorTree*, llvm::Loop const*, llvm::ICFLoopSafetyInfo*, llvm::MemorySSAUpdater*, llvm::OptimizationRemarkEmitter*)::$_7, decltype(fp())*)
Line
Count
Source
75
2.03M
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
2.03M
    // Avoid building the remark unless we know there are at least *some*
77
2.03M
    // remarks enabled. We can't currently check whether remarks are requested
78
2.03M
    // for the calling pass since that requires actually building the remark.
79
2.03M
80
2.03M
    if (F->getContext().getRemarkStreamer() ||
81
2.03M
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()2.03M
) {
82
93
      auto R = RemarkBuilder();
83
93
      emit((DiagnosticInfoOptimizationBase &)R);
84
93
    }
85
2.03M
  }
LICM.cpp:void llvm::OptimizationRemarkEmitter::emit<hoist(llvm::Instruction&, llvm::DominatorTree const*, llvm::Loop const*, llvm::BasicBlock*, llvm::ICFLoopSafetyInfo*, llvm::MemorySSAUpdater*, llvm::OptimizationRemarkEmitter*)::$_8>(hoist(llvm::Instruction&, llvm::DominatorTree const*, llvm::Loop const*, llvm::BasicBlock*, llvm::ICFLoopSafetyInfo*, llvm::MemorySSAUpdater*, llvm::OptimizationRemarkEmitter*)::$_8, decltype(fp())*)
Line
Count
Source
75
188k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
188k
    // Avoid building the remark unless we know there are at least *some*
77
188k
    // remarks enabled. We can't currently check whether remarks are requested
78
188k
    // for the calling pass since that requires actually building the remark.
79
188k
80
188k
    if (F->getContext().getRemarkStreamer() ||
81
188k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
18
      auto R = RemarkBuilder();
83
18
      emit((DiagnosticInfoOptimizationBase &)R);
84
18
    }
85
188k
  }
LICM.cpp:void llvm::OptimizationRemarkEmitter::emit<isSafeToExecuteUnconditionally(llvm::Instruction&, llvm::DominatorTree const*, llvm::Loop const*, llvm::LoopSafetyInfo const*, llvm::OptimizationRemarkEmitter*, llvm::Instruction const*)::$_9>(isSafeToExecuteUnconditionally(llvm::Instruction&, llvm::DominatorTree const*, llvm::Loop const*, llvm::LoopSafetyInfo const*, llvm::OptimizationRemarkEmitter*, llvm::Instruction const*)::$_9, decltype(fp())*)
Line
Count
Source
75
10.7k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
10.7k
    // Avoid building the remark unless we know there are at least *some*
77
10.7k
    // remarks enabled. We can't currently check whether remarks are requested
78
10.7k
    // for the calling pass since that requires actually building the remark.
79
10.7k
80
10.7k
    if (F->getContext().getRemarkStreamer() ||
81
10.7k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
2
      auto R = RemarkBuilder();
83
2
      emit((DiagnosticInfoOptimizationBase &)R);
84
2
    }
85
10.7k
  }
LICM.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::canSinkOrHoistInst(llvm::Instruction&, llvm::AAResults*, llvm::DominatorTree*, llvm::Loop*, llvm::AliasSetTracker*, llvm::MemorySSAUpdater*, bool, llvm::SinkAndHoistLICMFlags*, llvm::OptimizationRemarkEmitter*)::$_3>(llvm::canSinkOrHoistInst(llvm::Instruction&, llvm::AAResults*, llvm::DominatorTree*, llvm::Loop*, llvm::AliasSetTracker*, llvm::MemorySSAUpdater*, bool, llvm::SinkAndHoistLICMFlags*, llvm::OptimizationRemarkEmitter*)::$_3, decltype(fp())*)
Line
Count
Source
75
545k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
545k
    // Avoid building the remark unless we know there are at least *some*
77
545k
    // remarks enabled. We can't currently check whether remarks are requested
78
545k
    // for the calling pass since that requires actually building the remark.
79
545k
80
545k
    if (F->getContext().getRemarkStreamer() ||
81
545k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()545k
) {
82
22
      auto R = RemarkBuilder();
83
22
      emit((DiagnosticInfoOptimizationBase &)R);
84
22
    }
85
545k
  }
LICM.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::promoteLoopAccessesToScalars(llvm::SmallSetVector<llvm::Value*, 8u> const&, llvm::SmallVectorImpl<llvm::BasicBlock*>&, llvm::SmallVectorImpl<llvm::Instruction*>&, llvm::SmallVectorImpl<llvm::MemoryAccess*>&, llvm::PredIteratorCache&, llvm::LoopInfo*, llvm::DominatorTree*, llvm::TargetLibraryInfo const*, llvm::Loop*, llvm::AliasSetTracker*, llvm::MemorySSAUpdater*, llvm::ICFLoopSafetyInfo*, llvm::OptimizationRemarkEmitter*)::$_5>(llvm::promoteLoopAccessesToScalars(llvm::SmallSetVector<llvm::Value*, 8u> const&, llvm::SmallVectorImpl<llvm::BasicBlock*>&, llvm::SmallVectorImpl<llvm::Instruction*>&, llvm::SmallVectorImpl<llvm::MemoryAccess*>&, llvm::PredIteratorCache&, llvm::LoopInfo*, llvm::DominatorTree*, llvm::TargetLibraryInfo const*, llvm::Loop*, llvm::AliasSetTracker*, llvm::MemorySSAUpdater*, llvm::ICFLoopSafetyInfo*, llvm::OptimizationRemarkEmitter*)::$_5, decltype(fp())*)
Line
Count
Source
75
2.46k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
2.46k
    // Avoid building the remark unless we know there are at least *some*
77
2.46k
    // remarks enabled. We can't currently check whether remarks are requested
78
2.46k
    // for the calling pass since that requires actually building the remark.
79
2.46k
80
2.46k
    if (F->getContext().getRemarkStreamer() ||
81
2.46k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
8
      auto R = RemarkBuilder();
83
8
      emit((DiagnosticInfoOptimizationBase &)R);
84
8
    }
85
2.46k
  }
LoopDataPrefetch.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopDataPrefetch::runOnLoop(llvm::Loop*)::$_0>((anonymous namespace)::LoopDataPrefetch::runOnLoop(llvm::Loop*)::$_0, decltype(fp())*)
Line
Count
Source
75
46
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
46
    // Avoid building the remark unless we know there are at least *some*
77
46
    // remarks enabled. We can't currently check whether remarks are requested
78
46
    // for the calling pass since that requires actually building the remark.
79
46
80
46
    if (F->getContext().getRemarkStreamer() ||
81
46
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
4
      auto R = RemarkBuilder();
83
4
      emit((DiagnosticInfoOptimizationBase &)R);
84
4
    }
85
46
  }
LoopDistribute.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopDistributeForLoop::fail(llvm::StringRef, llvm::StringRef)::'lambda'()>((anonymous namespace)::LoopDistributeForLoop::fail(llvm::StringRef, llvm::StringRef)::'lambda'(), decltype(fp())*)
Line
Count
Source
75
32
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
32
    // Avoid building the remark unless we know there are at least *some*
77
32
    // remarks enabled. We can't currently check whether remarks are requested
78
32
    // for the calling pass since that requires actually building the remark.
79
32
80
32
    if (F->getContext().getRemarkStreamer() ||
81
32
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
13
      auto R = RemarkBuilder();
83
13
      emit((DiagnosticInfoOptimizationBase &)R);
84
13
    }
85
32
  }
LoopDistribute.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopDistributeForLoop::processLoop(std::__1::function<llvm::LoopAccessInfo const& (llvm::Loop&)>&)::'lambda'()>((anonymous namespace)::LoopDistributeForLoop::processLoop(std::__1::function<llvm::LoopAccessInfo const& (llvm::Loop&)>&)::'lambda'(), decltype(fp())*)
Line
Count
Source
75
27
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
27
    // Avoid building the remark unless we know there are at least *some*
77
27
    // remarks enabled. We can't currently check whether remarks are requested
78
27
    // for the calling pass since that requires actually building the remark.
79
27
80
27
    if (F->getContext().getRemarkStreamer() ||
81
27
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
3
      auto R = RemarkBuilder();
83
3
      emit((DiagnosticInfoOptimizationBase &)R);
84
3
    }
85
27
  }
LoopIdiomRecognize.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopIdiomRecognize::processLoopStridedStore(llvm::Value*, unsigned int, unsigned int, llvm::Value*, llvm::Instruction*, llvm::SmallPtrSetImpl<llvm::Instruction*>&, llvm::SCEVAddRecExpr const*, llvm::SCEV const*, bool, bool)::$_0>((anonymous namespace)::LoopIdiomRecognize::processLoopStridedStore(llvm::Value*, unsigned int, unsigned int, llvm::Value*, llvm::Instruction*, llvm::SmallPtrSetImpl<llvm::Instruction*>&, llvm::SCEVAddRecExpr const*, llvm::SCEV const*, bool, bool)::$_0, decltype(fp())*)
Line
Count
Source
75
11.9k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
11.9k
    // Avoid building the remark unless we know there are at least *some*
77
11.9k
    // remarks enabled. We can't currently check whether remarks are requested
78
11.9k
    // for the calling pass since that requires actually building the remark.
79
11.9k
80
11.9k
    if (F->getContext().getRemarkStreamer() ||
81
11.9k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
1
      auto R = RemarkBuilder();
83
1
      emit((DiagnosticInfoOptimizationBase &)R);
84
1
    }
85
11.9k
  }
LoopIdiomRecognize.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopIdiomRecognize::processLoopStoreOfLoopLoad(llvm::StoreInst*, llvm::SCEV const*)::$_1>((anonymous namespace)::LoopIdiomRecognize::processLoopStoreOfLoopLoad(llvm::StoreInst*, llvm::SCEV const*)::$_1, decltype(fp())*)
Line
Count
Source
75
185
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
185
    // Avoid building the remark unless we know there are at least *some*
77
185
    // remarks enabled. We can't currently check whether remarks are requested
78
185
    // for the calling pass since that requires actually building the remark.
79
185
80
185
    if (F->getContext().getRemarkStreamer() ||
81
185
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
1
      auto R = RemarkBuilder();
83
1
      emit((DiagnosticInfoOptimizationBase &)R);
84
1
    }
85
185
  }
LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeLegality::canInterchangeLoops(unsigned int, unsigned int, std::__1::vector<std::__1::vector<char, std::__1::allocator<char> >, std::__1::allocator<std::__1::vector<char, std::__1::allocator<char> > > >&)::$_12>((anonymous namespace)::LoopInterchangeLegality::canInterchangeLoops(unsigned int, unsigned int, std::__1::vector<std::__1::vector<char, std::__1::allocator<char> >, std::__1::allocator<std::__1::vector<char, std::__1::allocator<char> > > >&)::$_12, decltype(fp())*)
Line
Count
Source
75
7
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
7
    // Avoid building the remark unless we know there are at least *some*
77
7
    // remarks enabled. We can't currently check whether remarks are requested
78
7
    // for the calling pass since that requires actually building the remark.
79
7
80
7
    if (F->getContext().getRemarkStreamer() ||
81
7
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()1
) {
82
6
      auto R = RemarkBuilder();
83
6
      emit((DiagnosticInfoOptimizationBase &)R);
84
6
    }
85
7
  }
Unexecuted instantiation: LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeLegality::canInterchangeLoops(unsigned int, unsigned int, std::__1::vector<std::__1::vector<char, std::__1::allocator<char> >, std::__1::allocator<std::__1::vector<char, std::__1::allocator<char> > > >&)::$_13>((anonymous namespace)::LoopInterchangeLegality::canInterchangeLoops(unsigned int, unsigned int, std::__1::vector<std::__1::vector<char, std::__1::allocator<char> >, std::__1::allocator<std::__1::vector<char, std::__1::allocator<char> > > >&)::$_13, decltype(fp())*)
LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_2>((anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_2, decltype(fp())*)
Line
Count
Source
75
1
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
1
    // Avoid building the remark unless we know there are at least *some*
77
1
    // remarks enabled. We can't currently check whether remarks are requested
78
1
    // for the calling pass since that requires actually building the remark.
79
1
80
1
    if (F->getContext().getRemarkStreamer() ||
81
1
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()0
) {
82
1
      auto R = RemarkBuilder();
83
1
      emit((DiagnosticInfoOptimizationBase &)R);
84
1
    }
85
1
  }
LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_3>((anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_3, decltype(fp())*)
Line
Count
Source
75
5
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
5
    // Avoid building the remark unless we know there are at least *some*
77
5
    // remarks enabled. We can't currently check whether remarks are requested
78
5
    // for the calling pass since that requires actually building the remark.
79
5
80
5
    if (F->getContext().getRemarkStreamer() ||
81
5
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()0
) {
82
5
      auto R = RemarkBuilder();
83
5
      emit((DiagnosticInfoOptimizationBase &)R);
84
5
    }
85
5
  }
Unexecuted instantiation: LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_4>((anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_4, decltype(fp())*)
LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_5>((anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_5, decltype(fp())*)
Line
Count
Source
75
1
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
1
    // Avoid building the remark unless we know there are at least *some*
77
1
    // remarks enabled. We can't currently check whether remarks are requested
78
1
    // for the calling pass since that requires actually building the remark.
79
1
80
1
    if (F->getContext().getRemarkStreamer() ||
81
1
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()0
) {
82
1
      auto R = RemarkBuilder();
83
1
      emit((DiagnosticInfoOptimizationBase &)R);
84
1
    }
85
1
  }
Unexecuted instantiation: LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_6>((anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_6, decltype(fp())*)
Unexecuted instantiation: LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_7>((anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_7, decltype(fp())*)
Unexecuted instantiation: LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_8>((anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_8, decltype(fp())*)
Unexecuted instantiation: LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_9>((anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_9, decltype(fp())*)
Unexecuted instantiation: LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_10>((anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_10, decltype(fp())*)
Unexecuted instantiation: LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_11>((anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_11, decltype(fp())*)
Unexecuted instantiation: LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeLegality::canInterchangeLoops(unsigned int, unsigned int, std::__1::vector<std::__1::vector<char, std::__1::allocator<char> >, std::__1::allocator<std::__1::vector<char, std::__1::allocator<char> > > >&)::$_14>((anonymous namespace)::LoopInterchangeLegality::canInterchangeLoops(unsigned int, unsigned int, std::__1::vector<std::__1::vector<char, std::__1::allocator<char> >, std::__1::allocator<std::__1::vector<char, std::__1::allocator<char> > > >&)::$_14, decltype(fp())*)
LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeLegality::canInterchangeLoops(unsigned int, unsigned int, std::__1::vector<std::__1::vector<char, std::__1::allocator<char> >, std::__1::allocator<std::__1::vector<char, std::__1::allocator<char> > > >&)::$_15>((anonymous namespace)::LoopInterchangeLegality::canInterchangeLoops(unsigned int, unsigned int, std::__1::vector<std::__1::vector<char, std::__1::allocator<char> >, std::__1::allocator<std::__1::vector<char, std::__1::allocator<char> > > >&)::$_15, decltype(fp())*)
Line
Count
Source
75
3
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
3
    // Avoid building the remark unless we know there are at least *some*
77
3
    // remarks enabled. We can't currently check whether remarks are requested
78
3
    // for the calling pass since that requires actually building the remark.
79
3
80
3
    if (F->getContext().getRemarkStreamer() ||
81
3
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()0
) {
82
3
      auto R = RemarkBuilder();
83
3
      emit((DiagnosticInfoOptimizationBase &)R);
84
3
    }
85
3
  }
LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeProfitability::isProfitable(unsigned int, unsigned int, std::__1::vector<std::__1::vector<char, std::__1::allocator<char> >, std::__1::allocator<std::__1::vector<char, std::__1::allocator<char> > > >&)::$_16>((anonymous namespace)::LoopInterchangeProfitability::isProfitable(unsigned int, unsigned int, std::__1::vector<std::__1::vector<char, std::__1::allocator<char> >, std::__1::allocator<std::__1::vector<char, std::__1::allocator<char> > > >&)::$_16, decltype(fp())*)
Line
Count
Source
75
2
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
2
    // Avoid building the remark unless we know there are at least *some*
77
2
    // remarks enabled. We can't currently check whether remarks are requested
78
2
    // for the calling pass since that requires actually building the remark.
79
2
80
2
    if (F->getContext().getRemarkStreamer() ||
81
2
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()0
) {
82
2
      auto R = RemarkBuilder();
83
2
      emit((DiagnosticInfoOptimizationBase &)R);
84
2
    }
85
2
  }
LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchange::processLoop(llvm::SmallVector<llvm::Loop*, 8u>, unsigned int, unsigned int, llvm::BasicBlock*, std::__1::vector<std::__1::vector<char, std::__1::allocator<char> >, std::__1::allocator<std::__1::vector<char, std::__1::allocator<char> > > >&)::'lambda'()>((anonymous namespace)::LoopInterchange::processLoop(llvm::SmallVector<llvm::Loop*, 8u>, unsigned int, unsigned int, llvm::BasicBlock*, std::__1::vector<std::__1::vector<char, std::__1::allocator<char> >, std::__1::allocator<std::__1::vector<char, std::__1::allocator<char> > > >&)::'lambda'(), decltype(fp())*)
Line
Count
Source
75
15
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
15
    // Avoid building the remark unless we know there are at least *some*
77
15
    // remarks enabled. We can't currently check whether remarks are requested
78
15
    // for the calling pass since that requires actually building the remark.
79
15
80
15
    if (F->getContext().getRemarkStreamer() ||
81
15
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()9
) {
82
7
      auto R = RemarkBuilder();
83
7
      emit((DiagnosticInfoOptimizationBase &)R);
84
7
    }
85
15
  }
Unexecuted instantiation: LoopUnrollPass.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::computeUnrollCount(llvm::Loop*, llvm::TargetTransformInfo const&, llvm::DominatorTree&, llvm::LoopInfo*, llvm::ScalarEvolution&, llvm::SmallPtrSetImpl<llvm::Value const*> const&, llvm::OptimizationRemarkEmitter*, unsigned int&, unsigned int, unsigned int&, unsigned int, llvm::TargetTransformInfo::UnrollingPreferences&, bool&)::$_0>(llvm::computeUnrollCount(llvm::Loop*, llvm::TargetTransformInfo const&, llvm::DominatorTree&, llvm::LoopInfo*, llvm::ScalarEvolution&, llvm::SmallPtrSetImpl<llvm::Value const*> const&, llvm::OptimizationRemarkEmitter*, unsigned int&, unsigned int, unsigned int&, unsigned int, llvm::TargetTransformInfo::UnrollingPreferences&, bool&)::$_0, decltype(fp())*)
LoopUnrollPass.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::computeUnrollCount(llvm::Loop*, llvm::TargetTransformInfo const&, llvm::DominatorTree&, llvm::LoopInfo*, llvm::ScalarEvolution&, llvm::SmallPtrSetImpl<llvm::Value const*> const&, llvm::OptimizationRemarkEmitter*, unsigned int&, unsigned int, unsigned int&, unsigned int, llvm::TargetTransformInfo::UnrollingPreferences&, bool&)::$_1>(llvm::computeUnrollCount(llvm::Loop*, llvm::TargetTransformInfo const&, llvm::DominatorTree&, llvm::LoopInfo*, llvm::ScalarEvolution&, llvm::SmallPtrSetImpl<llvm::Value const*> const&, llvm::OptimizationRemarkEmitter*, unsigned int&, unsigned int, unsigned int&, unsigned int, llvm::TargetTransformInfo::UnrollingPreferences&, bool&)::$_1, decltype(fp())*)
Line
Count
Source
75
3
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
3
    // Avoid building the remark unless we know there are at least *some*
77
3
    // remarks enabled. We can't currently check whether remarks are requested
78
3
    // for the calling pass since that requires actually building the remark.
79
3
80
3
    if (F->getContext().getRemarkStreamer() ||
81
3
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
3
  }
LoopUnrollPass.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::computeUnrollCount(llvm::Loop*, llvm::TargetTransformInfo const&, llvm::DominatorTree&, llvm::LoopInfo*, llvm::ScalarEvolution&, llvm::SmallPtrSetImpl<llvm::Value const*> const&, llvm::OptimizationRemarkEmitter*, unsigned int&, unsigned int, unsigned int&, unsigned int, llvm::TargetTransformInfo::UnrollingPreferences&, bool&)::$_2>(llvm::computeUnrollCount(llvm::Loop*, llvm::TargetTransformInfo const&, llvm::DominatorTree&, llvm::LoopInfo*, llvm::ScalarEvolution&, llvm::SmallPtrSetImpl<llvm::Value const*> const&, llvm::OptimizationRemarkEmitter*, unsigned int&, unsigned int, unsigned int&, unsigned int, llvm::TargetTransformInfo::UnrollingPreferences&, bool&)::$_2, decltype(fp())*)
Line
Count
Source
75
5
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
5
    // Avoid building the remark unless we know there are at least *some*
77
5
    // remarks enabled. We can't currently check whether remarks are requested
78
5
    // for the calling pass since that requires actually building the remark.
79
5
80
5
    if (F->getContext().getRemarkStreamer() ||
81
5
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
5
  }
LoopUnrollPass.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::computeUnrollCount(llvm::Loop*, llvm::TargetTransformInfo const&, llvm::DominatorTree&, llvm::LoopInfo*, llvm::ScalarEvolution&, llvm::SmallPtrSetImpl<llvm::Value const*> const&, llvm::OptimizationRemarkEmitter*, unsigned int&, unsigned int, unsigned int&, unsigned int, llvm::TargetTransformInfo::UnrollingPreferences&, bool&)::$_3>(llvm::computeUnrollCount(llvm::Loop*, llvm::TargetTransformInfo const&, llvm::DominatorTree&, llvm::LoopInfo*, llvm::ScalarEvolution&, llvm::SmallPtrSetImpl<llvm::Value const*> const&, llvm::OptimizationRemarkEmitter*, unsigned int&, unsigned int, unsigned int&, unsigned int, llvm::TargetTransformInfo::UnrollingPreferences&, bool&)::$_3, decltype(fp())*)
Line
Count
Source
75
3
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
3
    // Avoid building the remark unless we know there are at least *some*
77
3
    // remarks enabled. We can't currently check whether remarks are requested
78
3
    // for the calling pass since that requires actually building the remark.
79
3
80
3
    if (F->getContext().getRemarkStreamer() ||
81
3
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
3
  }
LoopVersioningLICM.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopVersioningLICM::isLegalForVersioning()::$_3>((anonymous namespace)::LoopVersioningLICM::isLegalForVersioning()::$_3, decltype(fp())*)
Line
Count
Source
75
4
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
4
    // Avoid building the remark unless we know there are at least *some*
77
4
    // remarks enabled. We can't currently check whether remarks are requested
78
4
    // for the calling pass since that requires actually building the remark.
79
4
80
4
    if (F->getContext().getRemarkStreamer() ||
81
4
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
4
  }
LoopVersioningLICM.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopVersioningLICM::legalLoopInstructions()::$_0>((anonymous namespace)::LoopVersioningLICM::legalLoopInstructions()::$_0, decltype(fp())*)
Line
Count
Source
75
2
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
2
    // Avoid building the remark unless we know there are at least *some*
77
2
    // remarks enabled. We can't currently check whether remarks are requested
78
2
    // for the calling pass since that requires actually building the remark.
79
2
80
2
    if (F->getContext().getRemarkStreamer() ||
81
2
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
2
  }
Unexecuted instantiation: LoopVersioningLICM.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopVersioningLICM::legalLoopInstructions()::$_1>((anonymous namespace)::LoopVersioningLICM::legalLoopInstructions()::$_1, decltype(fp())*)
Unexecuted instantiation: LoopVersioningLICM.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopVersioningLICM::legalLoopInstructions()::$_2>((anonymous namespace)::LoopVersioningLICM::legalLoopInstructions()::$_2, decltype(fp())*)
Unexecuted instantiation: LoopVersioningLICM.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopVersioningLICM::isLegalForVersioning()::$_4>((anonymous namespace)::LoopVersioningLICM::isLegalForVersioning()::$_4, decltype(fp())*)
LoopVersioningLICM.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopVersioningLICM::isLegalForVersioning()::$_5>((anonymous namespace)::LoopVersioningLICM::isLegalForVersioning()::$_5, decltype(fp())*)
Line
Count
Source
75
1
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
1
    // Avoid building the remark unless we know there are at least *some*
77
1
    // remarks enabled. We can't currently check whether remarks are requested
78
1
    // for the calling pass since that requires actually building the remark.
79
1
80
1
    if (F->getContext().getRemarkStreamer() ||
81
1
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
1
  }
TailRecursionElimination.cpp:void llvm::OptimizationRemarkEmitter::emit<markTails(llvm::Function&, bool&, llvm::OptimizationRemarkEmitter*)::$_1>(markTails(llvm::Function&, bool&, llvm::OptimizationRemarkEmitter*)::$_1, decltype(fp())*)
Line
Count
Source
75
65
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
65
    // Avoid building the remark unless we know there are at least *some*
77
65
    // remarks enabled. We can't currently check whether remarks are requested
78
65
    // for the calling pass since that requires actually building the remark.
79
65
80
65
    if (F->getContext().getRemarkStreamer() ||
81
65
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
65
  }
TailRecursionElimination.cpp:void llvm::OptimizationRemarkEmitter::emit<eliminateRecursiveTailCall(llvm::CallInst*, llvm::ReturnInst*, llvm::BasicBlock*&, bool&, llvm::SmallVectorImpl<llvm::PHINode*>&, llvm::AAResults*, llvm::OptimizationRemarkEmitter*, llvm::DomTreeUpdater&)::$_2>(eliminateRecursiveTailCall(llvm::CallInst*, llvm::ReturnInst*, llvm::BasicBlock*&, bool&, llvm::SmallVectorImpl<llvm::PHINode*>&, llvm::AAResults*, llvm::OptimizationRemarkEmitter*, llvm::DomTreeUpdater&)::$_2, decltype(fp())*)
Line
Count
Source
75
283
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
283
    // Avoid building the remark unless we know there are at least *some*
77
283
    // remarks enabled. We can't currently check whether remarks are requested
78
283
    // for the calling pass since that requires actually building the remark.
79
283
80
283
    if (F->getContext().getRemarkStreamer() ||
81
283
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
2
      auto R = RemarkBuilder();
83
2
      emit((DiagnosticInfoOptimizationBase &)R);
84
2
    }
85
283
  }
LoopUnroll.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::UnrollLoop(llvm::Loop*, llvm::UnrollLoopOptions, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool, llvm::Loop**)::$_4>(llvm::UnrollLoop(llvm::Loop*, llvm::UnrollLoopOptions, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool, llvm::Loop**)::$_4, decltype(fp())*)
Line
Count
Source
75
9.35k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
9.35k
    // Avoid building the remark unless we know there are at least *some*
77
9.35k
    // remarks enabled. We can't currently check whether remarks are requested
78
9.35k
    // for the calling pass since that requires actually building the remark.
79
9.35k
80
9.35k
    if (F->getContext().getRemarkStreamer() ||
81
9.35k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()9.35k
) {
82
3
      auto R = RemarkBuilder();
83
3
      emit((DiagnosticInfoOptimizationBase &)R);
84
3
    }
85
9.35k
  }
LoopUnroll.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::UnrollLoop(llvm::Loop*, llvm::UnrollLoopOptions, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool, llvm::Loop**)::$_5>(llvm::UnrollLoop(llvm::Loop*, llvm::UnrollLoopOptions, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool, llvm::Loop**)::$_5, decltype(fp())*)
Line
Count
Source
75
118
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
118
    // Avoid building the remark unless we know there are at least *some*
77
118
    // remarks enabled. We can't currently check whether remarks are requested
78
118
    // for the calling pass since that requires actually building the remark.
79
118
80
118
    if (F->getContext().getRemarkStreamer() ||
81
118
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
118
  }
LoopUnroll.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::UnrollLoop(llvm::Loop*, llvm::UnrollLoopOptions, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool, llvm::Loop**)::$_7>(llvm::UnrollLoop(llvm::Loop*, llvm::UnrollLoopOptions, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool, llvm::Loop**)::$_7, decltype(fp())*)
Line
Count
Source
75
185
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
185
    // Avoid building the remark unless we know there are at least *some*
77
185
    // remarks enabled. We can't currently check whether remarks are requested
78
185
    // for the calling pass since that requires actually building the remark.
79
185
80
185
    if (F->getContext().getRemarkStreamer() ||
81
185
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
3
      auto R = RemarkBuilder();
83
3
      emit((DiagnosticInfoOptimizationBase &)R);
84
3
    }
85
185
  }
LoopUnroll.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::UnrollLoop(llvm::Loop*, llvm::UnrollLoopOptions, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool, llvm::Loop**)::$_8>(llvm::UnrollLoop(llvm::Loop*, llvm::UnrollLoopOptions, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool, llvm::Loop**)::$_8, decltype(fp())*)
Line
Count
Source
75
5
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
5
    // Avoid building the remark unless we know there are at least *some*
77
5
    // remarks enabled. We can't currently check whether remarks are requested
78
5
    // for the calling pass since that requires actually building the remark.
79
5
80
5
    if (F->getContext().getRemarkStreamer() ||
81
5
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
5
  }
LoopUnroll.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::UnrollLoop(llvm::Loop*, llvm::UnrollLoopOptions, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool, llvm::Loop**)::$_9>(llvm::UnrollLoop(llvm::Loop*, llvm::UnrollLoopOptions, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool, llvm::Loop**)::$_9, decltype(fp())*)
Line
Count
Source
75
1.44k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
1.44k
    // Avoid building the remark unless we know there are at least *some*
77
1.44k
    // remarks enabled. We can't currently check whether remarks are requested
78
1.44k
    // for the calling pass since that requires actually building the remark.
79
1.44k
80
1.44k
    if (F->getContext().getRemarkStreamer() ||
81
1.44k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
2
      auto R = RemarkBuilder();
83
2
      emit((DiagnosticInfoOptimizationBase &)R);
84
2
    }
85
1.44k
  }
LoopUnrollAndJam.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::UnrollAndJamLoop(llvm::Loop*, unsigned int, unsigned int, unsigned int, bool, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, llvm::Loop**)::$_1>(llvm::UnrollAndJamLoop(llvm::Loop*, unsigned int, unsigned int, unsigned int, bool, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, llvm::Loop**)::$_1, decltype(fp())*)
Line
Count
Source
75
2
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
2
    // Avoid building the remark unless we know there are at least *some*
77
2
    // remarks enabled. We can't currently check whether remarks are requested
78
2
    // for the calling pass since that requires actually building the remark.
79
2
80
2
    if (F->getContext().getRemarkStreamer() ||
81
2
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
2
  }
LoopUnrollAndJam.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::UnrollAndJamLoop(llvm::Loop*, unsigned int, unsigned int, unsigned int, bool, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, llvm::Loop**)::$_2>(llvm::UnrollAndJamLoop(llvm::Loop*, unsigned int, unsigned int, unsigned int, bool, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, llvm::Loop**)::$_2, decltype(fp())*)
Line
Count
Source
75
25
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
25
    // Avoid building the remark unless we know there are at least *some*
77
25
    // remarks enabled. We can't currently check whether remarks are requested
78
25
    // for the calling pass since that requires actually building the remark.
79
25
80
25
    if (F->getContext().getRemarkStreamer() ||
81
25
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
25
  }
SimplifyLibCalls.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LibCallSimplifier::optimizeStringLength(llvm::CallInst*, llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>&, unsigned int)::$_0>(llvm::LibCallSimplifier::optimizeStringLength(llvm::CallInst*, llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>&, unsigned int)::$_0, decltype(fp())*)
Line
Count
Source
75
22
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
22
    // Avoid building the remark unless we know there are at least *some*
77
22
    // remarks enabled. We can't currently check whether remarks are requested
78
22
    // for the calling pass since that requires actually building the remark.
79
22
80
22
    if (F->getContext().getRemarkStreamer() ||
81
22
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()20
) {
82
2
      auto R = RemarkBuilder();
83
2
      emit((DiagnosticInfoOptimizationBase &)R);
84
2
    }
85
22
  }
LoopVectorizationLegality.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizeHints::allowVectorization(llvm::Function*, llvm::Loop*, bool) const::$_0>(llvm::LoopVectorizeHints::allowVectorization(llvm::Function*, llvm::Loop*, bool) const::$_0, decltype(fp())*)
Line
Count
Source
75
5.56k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
5.56k
    // Avoid building the remark unless we know there are at least *some*
77
5.56k
    // remarks enabled. We can't currently check whether remarks are requested
78
5.56k
    // for the calling pass since that requires actually building the remark.
79
5.56k
80
5.56k
    if (F->getContext().getRemarkStreamer() ||
81
5.56k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()5.56k
) {
82
6
      auto R = RemarkBuilder();
83
6
      emit((DiagnosticInfoOptimizationBase &)R);
84
6
    }
85
5.56k
  }
LoopVectorizationLegality.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizeHints::emitRemarkWithHints() const::$_1>(llvm::LoopVectorizeHints::emitRemarkWithHints() const::$_1, decltype(fp())*)
Line
Count
Source
75
122k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
122k
    // Avoid building the remark unless we know there are at least *some*
77
122k
    // remarks enabled. We can't currently check whether remarks are requested
78
122k
    // for the calling pass since that requires actually building the remark.
79
122k
80
122k
    if (F->getContext().getRemarkStreamer() ||
81
122k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()122k
) {
82
53
      auto R = RemarkBuilder();
83
53
      emit((DiagnosticInfoOptimizationBase &)R);
84
53
    }
85
122k
  }
LoopVectorizationLegality.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizationRequirements::doesNotMeet(llvm::Function*, llvm::Loop*, llvm::LoopVectorizeHints const&)::$_2>(llvm::LoopVectorizationRequirements::doesNotMeet(llvm::Function*, llvm::Loop*, llvm::LoopVectorizeHints const&)::$_2, decltype(fp())*)
Line
Count
Source
75
1.35k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
1.35k
    // Avoid building the remark unless we know there are at least *some*
77
1.35k
    // remarks enabled. We can't currently check whether remarks are requested
78
1.35k
    // for the calling pass since that requires actually building the remark.
79
1.35k
80
1.35k
    if (F->getContext().getRemarkStreamer() ||
81
1.35k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
4
      auto R = RemarkBuilder();
83
4
      emit((DiagnosticInfoOptimizationBase &)R);
84
4
    }
85
1.35k
  }
LoopVectorizationLegality.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizationRequirements::doesNotMeet(llvm::Function*, llvm::Loop*, llvm::LoopVectorizeHints const&)::$_3>(llvm::LoopVectorizationRequirements::doesNotMeet(llvm::Function*, llvm::Loop*, llvm::LoopVectorizeHints const&)::$_3, decltype(fp())*)
Line
Count
Source
75
142
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
142
    // Avoid building the remark unless we know there are at least *some*
77
142
    // remarks enabled. We can't currently check whether remarks are requested
78
142
    // for the calling pass since that requires actually building the remark.
79
142
80
142
    if (F->getContext().getRemarkStreamer() ||
81
142
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()141
) {
82
5
      auto R = RemarkBuilder();
83
5
      emit((DiagnosticInfoOptimizationBase &)R);
84
5
    }
85
142
  }
LoopVectorizationLegality.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizationLegality::canVectorizeMemory()::$_5>(llvm::LoopVectorizationLegality::canVectorizeMemory()::$_5, decltype(fp())*)
Line
Count
Source
75
7.43k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
7.43k
    // Avoid building the remark unless we know there are at least *some*
77
7.43k
    // remarks enabled. We can't currently check whether remarks are requested
78
7.43k
    // for the calling pass since that requires actually building the remark.
79
7.43k
80
7.43k
    if (F->getContext().getRemarkStreamer() ||
81
7.43k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()7.42k
) {
82
35
      auto R = RemarkBuilder();
83
35
      emit((DiagnosticInfoOptimizationBase &)R);
84
35
    }
85
7.43k
  }
LoopVectorize.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_31>(llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_31, decltype(fp())*)
Line
Count
Source
75
1.40k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
1.40k
    // Avoid building the remark unless we know there are at least *some*
77
1.40k
    // remarks enabled. We can't currently check whether remarks are requested
78
1.40k
    // for the calling pass since that requires actually building the remark.
79
1.40k
80
1.40k
    if (F->getContext().getRemarkStreamer() ||
81
1.40k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
5
      auto R = RemarkBuilder();
83
5
      emit((DiagnosticInfoOptimizationBase &)R);
84
5
    }
85
1.40k
  }
LoopVectorize.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_32>(llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_32, decltype(fp())*)
Line
Count
Source
75
1.40k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
1.40k
    // Avoid building the remark unless we know there are at least *some*
77
1.40k
    // remarks enabled. We can't currently check whether remarks are requested
78
1.40k
    // for the calling pass since that requires actually building the remark.
79
1.40k
80
1.40k
    if (F->getContext().getRemarkStreamer() ||
81
1.40k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
5
      auto R = RemarkBuilder();
83
5
      emit((DiagnosticInfoOptimizationBase &)R);
84
5
    }
85
1.40k
  }
LoopVectorize.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_33>(llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_33, decltype(fp())*)
Line
Count
Source
75
1.74k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
1.74k
    // Avoid building the remark unless we know there are at least *some*
77
1.74k
    // remarks enabled. We can't currently check whether remarks are requested
78
1.74k
    // for the calling pass since that requires actually building the remark.
79
1.74k
80
1.74k
    if (F->getContext().getRemarkStreamer() ||
81
1.74k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
2
      auto R = RemarkBuilder();
83
2
      emit((DiagnosticInfoOptimizationBase &)R);
84
2
    }
85
1.74k
  }
LoopVectorize.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_34>(llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_34, decltype(fp())*)
Line
Count
Source
75
1.52k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
1.52k
    // Avoid building the remark unless we know there are at least *some*
77
1.52k
    // remarks enabled. We can't currently check whether remarks are requested
78
1.52k
    // for the calling pass since that requires actually building the remark.
79
1.52k
80
1.52k
    if (F->getContext().getRemarkStreamer() ||
81
1.52k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
5
      auto R = RemarkBuilder();
83
5
      emit((DiagnosticInfoOptimizationBase &)R);
84
5
    }
85
1.52k
  }
LoopVectorize.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_35>(llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_35, decltype(fp())*)
Line
Count
Source
75
1.74k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
1.74k
    // Avoid building the remark unless we know there are at least *some*
77
1.74k
    // remarks enabled. We can't currently check whether remarks are requested
78
1.74k
    // for the calling pass since that requires actually building the remark.
79
1.74k
80
1.74k
    if (F->getContext().getRemarkStreamer() ||
81
1.74k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
2
      auto R = RemarkBuilder();
83
2
      emit((DiagnosticInfoOptimizationBase &)R);
84
2
    }
85
1.74k
  }
LoopVectorize.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_36>(llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_36, decltype(fp())*)
Line
Count
Source
75
15.3k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
15.3k
    // Avoid building the remark unless we know there are at least *some*
77
15.3k
    // remarks enabled. We can't currently check whether remarks are requested
78
15.3k
    // for the calling pass since that requires actually building the remark.
79
15.3k
80
15.3k
    if (F->getContext().getRemarkStreamer() ||
81
15.3k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()15.3k
) {
82
12
      auto R = RemarkBuilder();
83
12
      emit((DiagnosticInfoOptimizationBase &)R);
84
12
    }
85
15.3k
  }
SLPVectorizer.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::HorizontalReduction::tryToReduce(llvm::slpvectorizer::BoUpSLP&, llvm::TargetTransformInfo*)::'lambda'()>((anonymous namespace)::HorizontalReduction::tryToReduce(llvm::slpvectorizer::BoUpSLP&, llvm::TargetTransformInfo*)::'lambda'(), decltype(fp())*)
Line
Count
Source
75
3.69k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
3.69k
    // Avoid building the remark unless we know there are at least *some*
77
3.69k
    // remarks enabled. We can't currently check whether remarks are requested
78
3.69k
    // for the calling pass since that requires actually building the remark.
79
3.69k
80
3.69k
    if (F->getContext().getRemarkStreamer() ||
81
3.69k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
82
0
      auto R = RemarkBuilder();
83
0
      emit((DiagnosticInfoOptimizationBase &)R);
84
0
    }
85
3.69k
  }
SLPVectorizer.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::HorizontalReduction::tryToReduce(llvm::slpvectorizer::BoUpSLP&, llvm::TargetTransformInfo*)::'lambda0'()>((anonymous namespace)::HorizontalReduction::tryToReduce(llvm::slpvectorizer::BoUpSLP&, llvm::TargetTransformInfo*)::'lambda0'(), decltype(fp())*)
Line
Count
Source
75
163
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
163
    // Avoid building the remark unless we know there are at least *some*
77
163
    // remarks enabled. We can't currently check whether remarks are requested
78
163
    // for the calling pass since that requires actually building the remark.
79
163
80
163
    if (F->getContext().getRemarkStreamer() ||
81
163
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()157
) {
82
6
      auto R = RemarkBuilder();
83
6
      emit((DiagnosticInfoOptimizationBase &)R);
84
6
    }
85
163
  }
Unexecuted instantiation: SLPVectorizer.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::SLPVectorizerPass::tryToVectorizeList(llvm::ArrayRef<llvm::Value*>, llvm::slpvectorizer::BoUpSLP&, int, bool)::$_10>(llvm::SLPVectorizerPass::tryToVectorizeList(llvm::ArrayRef<llvm::Value*>, llvm::slpvectorizer::BoUpSLP&, int, bool)::$_10, decltype(fp())*)
SLPVectorizer.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::SLPVectorizerPass::tryToVectorizeList(llvm::ArrayRef<llvm::Value*>, llvm::slpvectorizer::BoUpSLP&, int, bool)::$_11>(llvm::SLPVectorizerPass::tryToVectorizeList(llvm::ArrayRef<llvm::Value*>, llvm::slpvectorizer::BoUpSLP&, int, bool)::$_11, decltype(fp())*)
Line
Count
Source
75
4.20k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
4.20k
    // Avoid building the remark unless we know there are at least *some*
77
4.20k
    // remarks enabled. We can't currently check whether remarks are requested
78
4.20k
    // for the calling pass since that requires actually building the remark.
79
4.20k
80
4.20k
    if (F->getContext().getRemarkStreamer() ||
81
4.20k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()4.18k
) {
82
15
      auto R = RemarkBuilder();
83
15
      emit((DiagnosticInfoOptimizationBase &)R);
84
15
    }
85
4.20k
  }
SLPVectorizer.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::SLPVectorizerPass::tryToVectorizeList(llvm::ArrayRef<llvm::Value*>, llvm::slpvectorizer::BoUpSLP&, int, bool)::$_12>(llvm::SLPVectorizerPass::tryToVectorizeList(llvm::ArrayRef<llvm::Value*>, llvm::slpvectorizer::BoUpSLP&, int, bool)::$_12, decltype(fp())*)
Line
Count
Source
75
193k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
193k
    // Avoid building the remark unless we know there are at least *some*
77
193k
    // remarks enabled. We can't currently check whether remarks are requested
78
193k
    // for the calling pass since that requires actually building the remark.
79
193k
80
193k
    if (F->getContext().getRemarkStreamer() ||
81
193k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()193k
) {
82
9
      auto R = RemarkBuilder();
83
9
      emit((DiagnosticInfoOptimizationBase &)R);
84
9
    }
85
193k
  }
SLPVectorizer.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::SLPVectorizerPass::tryToVectorizeList(llvm::ArrayRef<llvm::Value*>, llvm::slpvectorizer::BoUpSLP&, int, bool)::$_13>(llvm::SLPVectorizerPass::tryToVectorizeList(llvm::ArrayRef<llvm::Value*>, llvm::slpvectorizer::BoUpSLP&, int, bool)::$_13, decltype(fp())*)
Line
Count
Source
75
246k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
76
246k
    // Avoid building the remark unless we know there are at least *some*
77
246k
    // remarks enabled. We can't currently check whether remarks are requested
78
246k
    // for the calling pass since that requires actually building the remark.
79
246k
80
246k
    if (F->getContext().getRemarkStreamer() ||
81
246k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()246k
) {
82
5
      auto R = RemarkBuilder();
83
5
      emit((DiagnosticInfoOptimizationBase &)R);
84
5
    }
85
246k
  }
86
87
  /// Whether we allow for extra compile-time budget to perform more
88
  /// analysis to produce fewer false positives.
89
  ///
90
  /// This is useful when reporting missed optimizations.  In this case we can
91
  /// use the extra analysis (1) to filter trivial false positives or (2) to
92
  /// provide more context so that non-trivial false positives can be quickly
93
  /// detected by the user.
94
4.19M
  bool allowExtraAnalysis(StringRef PassName) const {
95
4.19M
    return (F->getContext().getRemarkStreamer() ||
96
4.19M
            
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled(PassName)4.19M
);
97
4.19M
  }
98
99
private:
100
  const Function *F;
101
102
  BlockFrequencyInfo *BFI;
103
104
  /// If we generate BFI on demand, we need to free it when ORE is freed.
105
  std::unique_ptr<BlockFrequencyInfo> OwnedBFI;
106
107
  /// Compute hotness from IR value (currently assumed to be a block) if PGO is
108
  /// available.
109
  Optional<uint64_t> computeHotness(const Value *V);
110
111
  /// Similar but use value from \p OptDiag and update hotness there.
112
  void computeHotness(DiagnosticInfoIROptimization &OptDiag);
113
114
  /// Only allow verbose messages if we know we're filtering by hotness
115
  /// (BFI is only set in this case).
116
0
  bool shouldEmitVerbose() { return BFI != nullptr; }
117
118
  OptimizationRemarkEmitter(const OptimizationRemarkEmitter &) = delete;
119
  void operator=(const OptimizationRemarkEmitter &) = delete;
120
};
121
122
/// Add a small namespace to avoid name clashes with the classes used in
123
/// the streaming interface.  We want these to be short for better
124
/// write/readability.
125
namespace ore {
126
using NV = DiagnosticInfoOptimizationBase::Argument;
127
using setIsVerbose = DiagnosticInfoOptimizationBase::setIsVerbose;
128
using setExtraArgs = DiagnosticInfoOptimizationBase::setExtraArgs;
129
}
130
131
/// OptimizationRemarkEmitter legacy analysis pass
132
///
133
/// Note that this pass shouldn't generally be marked as preserved by other
134
/// passes.  It's holding onto BFI, so if the pass does not preserve BFI, BFI
135
/// could be freed.
136
class OptimizationRemarkEmitterWrapperPass : public FunctionPass {
137
  std::unique_ptr<OptimizationRemarkEmitter> ORE;
138
139
public:
140
  OptimizationRemarkEmitterWrapperPass();
141
142
  bool runOnFunction(Function &F) override;
143
144
  void getAnalysisUsage(AnalysisUsage &AU) const override;
145
146
6.22M
  OptimizationRemarkEmitter &getORE() {
147
6.22M
    assert(ORE && "pass not run yet");
148
6.22M
    return *ORE;
149
6.22M
  }
150
151
  static char ID;
152
};
153
154
class OptimizationRemarkEmitterAnalysis
155
    : public AnalysisInfoMixin<OptimizationRemarkEmitterAnalysis> {
156
  friend AnalysisInfoMixin<OptimizationRemarkEmitterAnalysis>;
157
  static AnalysisKey Key;
158
159
public:
160
  /// Provide the result typedef for this analysis pass.
161
  typedef OptimizationRemarkEmitter Result;
162
163
  /// Run the analysis pass over a function and produce BFI.
164
  Result run(Function &F, FunctionAnalysisManager &AM);
165
};
166
}
167
#endif // LLVM_IR_OPTIMIZATIONDIAGNOSTICINFO_H