Coverage Report

Created: 2018-09-25 00: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
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
//
10
// Optimization diagnostic interfaces.  It's packaged as an analysis pass so
11
// that by using this service passes become dependent on BFI as well.  BFI is
12
// used to compute the "hotness" of the diagnostic message.
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_IR_OPTIMIZATIONDIAGNOSTICINFO_H
16
#define LLVM_IR_OPTIMIZATIONDIAGNOSTICINFO_H
17
18
#include "llvm/ADT/Optional.h"
19
#include "llvm/Analysis/BlockFrequencyInfo.h"
20
#include "llvm/IR/DiagnosticInfo.h"
21
#include "llvm/IR/Function.h"
22
#include "llvm/IR/PassManager.h"
23
#include "llvm/Pass.h"
24
25
namespace llvm {
26
class DebugLoc;
27
class Loop;
28
class Pass;
29
class Twine;
30
class Value;
31
32
/// The optimization diagnostic interface.
33
///
34
/// It allows reporting when optimizations are performed and when they are not
35
/// along with the reasons for it.  Hotness information of the corresponding
36
/// code region can be included in the remark if DiagnosticsHotnessRequested is
37
/// enabled in the LLVM context.
38
class OptimizationRemarkEmitter {
39
public:
40
  OptimizationRemarkEmitter(const Function *F, BlockFrequencyInfo *BFI)
41
5.86M
      : F(F), BFI(BFI) {}
42
43
  /// This variant can be used to generate ORE on demand (without the
44
  /// analysis pass).
45
  ///
46
  /// Note that this ctor has a very different cost depending on whether
47
  /// F->getContext().getDiagnosticsHotnessRequested() is on or not.  If it's off
48
  /// the operation is free.
49
  ///
50
  /// Whereas if DiagnosticsHotnessRequested is on, it is fairly expensive
51
  /// operation since BFI and all its required analyses are computed.  This is
52
  /// for example useful for CGSCC passes that can't use function analyses
53
  /// passes in the old PM.
54
  OptimizationRemarkEmitter(const Function *F);
55
56
  OptimizationRemarkEmitter(OptimizationRemarkEmitter &&Arg)
57
2.79k
      : F(Arg.F), BFI(Arg.BFI) {}
58
59
0
  OptimizationRemarkEmitter &operator=(OptimizationRemarkEmitter &&RHS) {
60
0
    F = RHS.F;
61
0
    BFI = RHS.BFI;
62
0
    return *this;
63
0
  }
64
65
  /// Handle invalidation events in the new pass manager.
66
  bool invalidate(Function &F, const PreservedAnalyses &PA,
67
                  FunctionAnalysisManager::Invalidator &Inv);
68
69
  /// Output the remark via the diagnostic handler and to the
70
  /// optimization record file.
71
  void emit(DiagnosticInfoOptimizationBase &OptDiag);
72
73
  /// Take a lambda that returns a remark which will be emitted.  Second
74
  /// argument is only used to restrict this to functions.
75
  template <typename T>
76
5.44M
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
5.44M
    // Avoid building the remark unless we know there are at least *some*
78
5.44M
    // remarks enabled. We can't currently check whether remarks are requested
79
5.44M
    // for the calling pass since that requires actually building the remark.
80
5.44M
81
5.44M
    if (F->getContext().getDiagnosticsOutputFile() ||
82
5.44M
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()5.44M
) {
83
582
      auto R = RemarkBuilder();
84
582
      emit((DiagnosticInfoOptimizationBase &)R);
85
582
    }
86
5.44M
  }
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())*)
Line
Count
Source
76
39
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
39
    // Avoid building the remark unless we know there are at least *some*
78
39
    // remarks enabled. We can't currently check whether remarks are requested
79
39
    // for the calling pass since that requires actually building the remark.
80
39
81
39
    if (F->getContext().getDiagnosticsOutputFile() ||
82
39
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
39
  }
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())*)
Line
Count
Source
76
3
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
3
    // Avoid building the remark unless we know there are at least *some*
78
3
    // remarks enabled. We can't currently check whether remarks are requested
79
3
    // for the calling pass since that requires actually building the remark.
80
3
81
3
    if (F->getContext().getDiagnosticsOutputFile() ||
82
3
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
3
  }
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
76
4
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
4
    // Avoid building the remark unless we know there are at least *some*
78
4
    // remarks enabled. We can't currently check whether remarks are requested
79
4
    // for the calling pass since that requires actually building the remark.
80
4
81
4
    if (F->getContext().getDiagnosticsOutputFile() ||
82
4
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
4
      auto R = RemarkBuilder();
84
4
      emit((DiagnosticInfoOptimizationBase &)R);
85
4
    }
86
4
  }
StackProtector.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::StackProtector::RequiresStackProtector()::$_0>(llvm::StackProtector::RequiresStackProtector()::$_0, decltype(fp())*)
Line
Count
Source
76
232
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
232
    // Avoid building the remark unless we know there are at least *some*
78
232
    // remarks enabled. We can't currently check whether remarks are requested
79
232
    // for the calling pass since that requires actually building the remark.
80
232
81
232
    if (F->getContext().getDiagnosticsOutputFile() ||
82
232
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()230
) {
83
4
      auto R = RemarkBuilder();
84
4
      emit((DiagnosticInfoOptimizationBase &)R);
85
4
    }
86
232
  }
StackProtector.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::StackProtector::RequiresStackProtector()::$_1>(llvm::StackProtector::RequiresStackProtector()::$_1, decltype(fp())*)
Line
Count
Source
76
221
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
221
    // Avoid building the remark unless we know there are at least *some*
78
221
    // remarks enabled. We can't currently check whether remarks are requested
79
221
    // for the calling pass since that requires actually building the remark.
80
221
81
221
    if (F->getContext().getDiagnosticsOutputFile() ||
82
221
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()217
) {
83
8
      auto R = RemarkBuilder();
84
8
      emit((DiagnosticInfoOptimizationBase &)R);
85
8
    }
86
221
  }
StackProtector.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::StackProtector::RequiresStackProtector()::$_2>(llvm::StackProtector::RequiresStackProtector()::$_2, decltype(fp())*)
Line
Count
Source
76
3.20k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
3.20k
    // Avoid building the remark unless we know there are at least *some*
78
3.20k
    // remarks enabled. We can't currently check whether remarks are requested
79
3.20k
    // for the calling pass since that requires actually building the remark.
80
3.20k
81
3.20k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
3.20k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()3.20k
) {
83
8
      auto R = RemarkBuilder();
84
8
      emit((DiagnosticInfoOptimizationBase &)R);
85
8
    }
86
3.20k
  }
StackProtector.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::StackProtector::RequiresStackProtector()::$_3>(llvm::StackProtector::RequiresStackProtector()::$_3, decltype(fp())*)
Line
Count
Source
76
296
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
296
    // Avoid building the remark unless we know there are at least *some*
78
296
    // remarks enabled. We can't currently check whether remarks are requested
79
296
    // for the calling pass since that requires actually building the remark.
80
296
81
296
    if (F->getContext().getDiagnosticsOutputFile() ||
82
296
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()294
) {
83
4
      auto R = RemarkBuilder();
84
4
      emit((DiagnosticInfoOptimizationBase &)R);
85
4
    }
86
296
  }
Unexecuted instantiation: HotColdSplitting.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::HotColdSplitting::extractColdRegion(llvm::SmallVectorImpl<llvm::BasicBlock*> const&, llvm::DominatorTree*, llvm::BlockFrequencyInfo*, llvm::OptimizationRemarkEmitter&)::$_0>((anonymous namespace)::HotColdSplitting::extractColdRegion(llvm::SmallVectorImpl<llvm::BasicBlock*> const&, llvm::DominatorTree*, llvm::BlockFrequencyInfo*, llvm::OptimizationRemarkEmitter&)::$_0, decltype(fp())*)
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
76
522k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
522k
    // Avoid building the remark unless we know there are at least *some*
78
522k
    // remarks enabled. We can't currently check whether remarks are requested
79
522k
    // for the calling pass since that requires actually building the remark.
80
522k
81
522k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
522k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()522k
) {
83
28
      auto R = RemarkBuilder();
84
28
      emit((DiagnosticInfoOptimizationBase &)R);
85
28
    }
86
522k
  }
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
76
5
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
5
    // Avoid building the remark unless we know there are at least *some*
78
5
    // remarks enabled. We can't currently check whether remarks are requested
79
5
    // for the calling pass since that requires actually building the remark.
80
5
81
5
    if (F->getContext().getDiagnosticsOutputFile() ||
82
5
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
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
76
826k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
826k
    // Avoid building the remark unless we know there are at least *some*
78
826k
    // remarks enabled. We can't currently check whether remarks are requested
79
826k
    // for the calling pass since that requires actually building the remark.
80
826k
81
826k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
826k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
31
      auto R = RemarkBuilder();
84
31
      emit((DiagnosticInfoOptimizationBase &)R);
85
31
    }
86
826k
  }
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
76
137k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
137k
    // Avoid building the remark unless we know there are at least *some*
78
137k
    // remarks enabled. We can't currently check whether remarks are requested
79
137k
    // for the calling pass since that requires actually building the remark.
80
137k
81
137k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
137k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
12
      auto R = RemarkBuilder();
84
12
      emit((DiagnosticInfoOptimizationBase &)R);
85
12
    }
86
137k
  }
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
76
1.66k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1.66k
    // Avoid building the remark unless we know there are at least *some*
78
1.66k
    // remarks enabled. We can't currently check whether remarks are requested
79
1.66k
    // for the calling pass since that requires actually building the remark.
80
1.66k
81
1.66k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1.66k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
1.66k
  }
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
76
517k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
517k
    // Avoid building the remark unless we know there are at least *some*
78
517k
    // remarks enabled. We can't currently check whether remarks are requested
79
517k
    // for the calling pass since that requires actually building the remark.
80
517k
81
517k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
517k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()517k
) {
83
60
      auto R = RemarkBuilder();
84
60
      emit((DiagnosticInfoOptimizationBase &)R);
85
60
    }
86
517k
  }
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
76
2.37k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
2.37k
    // Avoid building the remark unless we know there are at least *some*
78
2.37k
    // remarks enabled. We can't currently check whether remarks are requested
79
2.37k
    // for the calling pass since that requires actually building the remark.
80
2.37k
81
2.37k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
2.37k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()2.37k
) {
83
11
      auto R = RemarkBuilder();
84
11
      emit((DiagnosticInfoOptimizationBase &)R);
85
11
    }
86
2.37k
  }
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&)::$_3::operator()(llvm::SmallVectorImpl<llvm::BasicBlock*>&) const::'lambda'()>((anonymous namespace)::PartialInlinerImpl::computeOutliningColdRegionsInfo(llvm::Function*, llvm::OptimizationRemarkEmitter&)::$_3::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&)::$_4>((anonymous namespace)::PartialInlinerImpl::computeOutliningColdRegionsInfo(llvm::Function*, llvm::OptimizationRemarkEmitter&)::$_4, decltype(fp())*)
Unexecuted instantiation: PartialInlining.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::PartialInlinerImpl::FunctionCloner::doMultiRegionFunctionOutlining()::$_11>((anonymous namespace)::PartialInlinerImpl::FunctionCloner::doMultiRegionFunctionOutlining()::$_11, decltype(fp())*)
Unexecuted instantiation: PartialInlining.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::PartialInlinerImpl::tryPartialInline((anonymous namespace)::PartialInlinerImpl::FunctionCloner&)::$_13>((anonymous namespace)::PartialInlinerImpl::tryPartialInline((anonymous namespace)::PartialInlinerImpl::FunctionCloner&)::$_13, decltype(fp())*)
Unexecuted instantiation: PartialInlining.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::PartialInlinerImpl::shouldPartialInline(llvm::CallSite, (anonymous namespace)::PartialInlinerImpl::FunctionCloner&, llvm::BlockFrequency, llvm::OptimizationRemarkEmitter&)::$_5>((anonymous namespace)::PartialInlinerImpl::shouldPartialInline(llvm::CallSite, (anonymous namespace)::PartialInlinerImpl::FunctionCloner&, llvm::BlockFrequency, llvm::OptimizationRemarkEmitter&)::$_5, 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())*)
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())*)
Line
Count
Source
76
2
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
2
    // Avoid building the remark unless we know there are at least *some*
78
2
    // remarks enabled. We can't currently check whether remarks are requested
79
2
    // for the calling pass since that requires actually building the remark.
80
2
81
2
    if (F->getContext().getDiagnosticsOutputFile() ||
82
2
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
2
      auto R = RemarkBuilder();
84
2
      emit((DiagnosticInfoOptimizationBase &)R);
85
2
    }
86
2
  }
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
76
4
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
4
    // Avoid building the remark unless we know there are at least *some*
78
4
    // remarks enabled. We can't currently check whether remarks are requested
79
4
    // for the calling pass since that requires actually building the remark.
80
4
81
4
    if (F->getContext().getDiagnosticsOutputFile() ||
82
4
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
4
  }
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
76
18
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
18
    // Avoid building the remark unless we know there are at least *some*
78
18
    // remarks enabled. We can't currently check whether remarks are requested
79
18
    // for the calling pass since that requires actually building the remark.
80
18
81
18
    if (F->getContext().getDiagnosticsOutputFile() ||
82
18
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
4
      auto R = RemarkBuilder();
84
4
      emit((DiagnosticInfoOptimizationBase &)R);
85
4
    }
86
18
  }
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())*)
Line
Count
Source
76
81
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
81
    // Avoid building the remark unless we know there are at least *some*
78
81
    // remarks enabled. We can't currently check whether remarks are requested
79
81
    // for the calling pass since that requires actually building the remark.
80
81
81
81
    if (F->getContext().getDiagnosticsOutputFile() ||
82
81
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
4
      auto R = RemarkBuilder();
84
4
      emit((DiagnosticInfoOptimizationBase &)R);
85
4
    }
86
81
  }
PartialInlining.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::PartialInlinerImpl::FunctionCloner::doSingleRegionFunctionOutlining()::$_12>((anonymous namespace)::PartialInlinerImpl::FunctionCloner::doSingleRegionFunctionOutlining()::$_12, decltype(fp())*)
Line
Count
Source
76
4
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
4
    // Avoid building the remark unless we know there are at least *some*
78
4
    // remarks enabled. We can't currently check whether remarks are requested
79
4
    // for the calling pass since that requires actually building the remark.
80
4
81
4
    if (F->getContext().getDiagnosticsOutputFile() ||
82
4
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
2
      auto R = RemarkBuilder();
84
2
      emit((DiagnosticInfoOptimizationBase &)R);
85
2
    }
86
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
76
210
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
210
    // Avoid building the remark unless we know there are at least *some*
78
210
    // remarks enabled. We can't currently check whether remarks are requested
79
210
    // for the calling pass since that requires actually building the remark.
80
210
81
210
    if (F->getContext().getDiagnosticsOutputFile() ||
82
210
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()200
) {
83
35
      auto R = RemarkBuilder();
84
35
      emit((DiagnosticInfoOptimizationBase &)R);
85
35
    }
86
210
  }
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
76
73
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
73
    // Avoid building the remark unless we know there are at least *some*
78
73
    // remarks enabled. We can't currently check whether remarks are requested
79
73
    // for the calling pass since that requires actually building the remark.
80
73
81
73
    if (F->getContext().getDiagnosticsOutputFile() ||
82
73
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()69
) {
83
13
      auto R = RemarkBuilder();
84
13
      emit((DiagnosticInfoOptimizationBase &)R);
85
13
    }
86
73
  }
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
76
10
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
10
    // Avoid building the remark unless we know there are at least *some*
78
10
    // remarks enabled. We can't currently check whether remarks are requested
79
10
    // for the calling pass since that requires actually building the remark.
80
10
81
10
    if (F->getContext().getDiagnosticsOutputFile() ||
82
10
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
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
76
2
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
2
    // Avoid building the remark unless we know there are at least *some*
78
2
    // remarks enabled. We can't currently check whether remarks are requested
79
2
    // for the calling pass since that requires actually building the remark.
80
2
81
2
    if (F->getContext().getDiagnosticsOutputFile() ||
82
2
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
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
76
12
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
12
    // Avoid building the remark unless we know there are at least *some*
78
12
    // remarks enabled. We can't currently check whether remarks are requested
79
12
    // for the calling pass since that requires actually building the remark.
80
12
81
12
    if (F->getContext().getDiagnosticsOutputFile() ||
82
12
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
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
76
2
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
2
    // Avoid building the remark unless we know there are at least *some*
78
2
    // remarks enabled. We can't currently check whether remarks are requested
79
2
    // for the calling pass since that requires actually building the remark.
80
2
81
2
    if (F->getContext().getDiagnosticsOutputFile() ||
82
2
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
2
  }
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
76
6
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
6
    // Avoid building the remark unless we know there are at least *some*
78
6
    // remarks enabled. We can't currently check whether remarks are requested
79
6
    // for the calling pass since that requires actually building the remark.
80
6
81
6
    if (F->getContext().getDiagnosticsOutputFile() ||
82
6
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
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
76
14
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
14
    // Avoid building the remark unless we know there are at least *some*
78
14
    // remarks enabled. We can't currently check whether remarks are requested
79
14
    // for the calling pass since that requires actually building the remark.
80
14
81
14
    if (F->getContext().getDiagnosticsOutputFile() ||
82
14
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
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
76
40
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
40
    // Avoid building the remark unless we know there are at least *some*
78
40
    // remarks enabled. We can't currently check whether remarks are requested
79
40
    // for the calling pass since that requires actually building the remark.
80
40
81
40
    if (F->getContext().getDiagnosticsOutputFile() ||
82
40
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
40
  }
ControlHeightReduction.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::CHR::run()::$_9>((anonymous namespace)::CHR::run()::$_9, decltype(fp())*)
Line
Count
Source
76
36
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
36
    // Avoid building the remark unless we know there are at least *some*
78
36
    // remarks enabled. We can't currently check whether remarks are requested
79
36
    // for the calling pass since that requires actually building the remark.
80
36
81
36
    if (F->getContext().getDiagnosticsOutputFile() ||
82
36
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
36
  }
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
76
3
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
3
    // Avoid building the remark unless we know there are at least *some*
78
3
    // remarks enabled. We can't currently check whether remarks are requested
79
3
    // for the calling pass since that requires actually building the remark.
80
3
81
3
    if (F->getContext().getDiagnosticsOutputFile() ||
82
3
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
2
      auto R = RemarkBuilder();
84
2
      emit((DiagnosticInfoOptimizationBase &)R);
85
2
    }
86
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
76
4
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
4
    // Avoid building the remark unless we know there are at least *some*
78
4
    // remarks enabled. We can't currently check whether remarks are requested
79
4
    // for the calling pass since that requires actually building the remark.
80
4
81
4
    if (F->getContext().getDiagnosticsOutputFile() ||
82
4
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
4
      auto R = RemarkBuilder();
84
4
      emit((DiagnosticInfoOptimizationBase &)R);
85
4
    }
86
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
76
50
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
50
    // Avoid building the remark unless we know there are at least *some*
78
50
    // remarks enabled. We can't currently check whether remarks are requested
79
50
    // for the calling pass since that requires actually building the remark.
80
50
81
50
    if (F->getContext().getDiagnosticsOutputFile() ||
82
50
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
12
      auto R = RemarkBuilder();
84
12
      emit((DiagnosticInfoOptimizationBase &)R);
85
12
    }
86
50
  }
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
76
4
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
4
    // Avoid building the remark unless we know there are at least *some*
78
4
    // remarks enabled. We can't currently check whether remarks are requested
79
4
    // for the calling pass since that requires actually building the remark.
80
4
81
4
    if (F->getContext().getDiagnosticsOutputFile() ||
82
4
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
4
      auto R = RemarkBuilder();
84
4
      emit((DiagnosticInfoOptimizationBase &)R);
85
4
    }
86
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
76
10
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
10
    // Avoid building the remark unless we know there are at least *some*
78
10
    // remarks enabled. We can't currently check whether remarks are requested
79
10
    // for the calling pass since that requires actually building the remark.
80
10
81
10
    if (F->getContext().getDiagnosticsOutputFile() ||
82
10
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()6
) {
83
4
      auto R = RemarkBuilder();
84
4
      emit((DiagnosticInfoOptimizationBase &)R);
85
4
    }
86
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
76
40.0k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
40.0k
    // Avoid building the remark unless we know there are at least *some*
78
40.0k
    // remarks enabled. We can't currently check whether remarks are requested
79
40.0k
    // for the calling pass since that requires actually building the remark.
80
40.0k
81
40.0k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
40.0k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()40.0k
) {
83
12
      auto R = RemarkBuilder();
84
12
      emit((DiagnosticInfoOptimizationBase &)R);
85
12
    }
86
40.0k
  }
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
76
24.5k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
24.5k
    // Avoid building the remark unless we know there are at least *some*
78
24.5k
    // remarks enabled. We can't currently check whether remarks are requested
79
24.5k
    // for the calling pass since that requires actually building the remark.
80
24.5k
81
24.5k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
24.5k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
24.5k
  }
LICM.cpp:void llvm::OptimizationRemarkEmitter::emit<sink(llvm::Instruction&, llvm::LoopInfo*, llvm::DominatorTree*, llvm::Loop const*, llvm::LoopSafetyInfo*, llvm::OptimizationRemarkEmitter*, bool)::$_4>(sink(llvm::Instruction&, llvm::LoopInfo*, llvm::DominatorTree*, llvm::Loop const*, llvm::LoopSafetyInfo*, llvm::OptimizationRemarkEmitter*, bool)::$_4, decltype(fp())*)
Line
Count
Source
76
2.01M
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
2.01M
    // Avoid building the remark unless we know there are at least *some*
78
2.01M
    // remarks enabled. We can't currently check whether remarks are requested
79
2.01M
    // for the calling pass since that requires actually building the remark.
80
2.01M
81
2.01M
    if (F->getContext().getDiagnosticsOutputFile() ||
82
2.01M
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()2.01M
) {
83
67
      auto R = RemarkBuilder();
84
67
      emit((DiagnosticInfoOptimizationBase &)R);
85
67
    }
86
2.01M
  }
LICM.cpp:void llvm::OptimizationRemarkEmitter::emit<hoist(llvm::Instruction&, llvm::DominatorTree const*, llvm::Loop const*, llvm::LoopSafetyInfo*, llvm::OptimizationRemarkEmitter*)::$_5>(hoist(llvm::Instruction&, llvm::DominatorTree const*, llvm::Loop const*, llvm::LoopSafetyInfo*, llvm::OptimizationRemarkEmitter*)::$_5, decltype(fp())*)
Line
Count
Source
76
186k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
186k
    // Avoid building the remark unless we know there are at least *some*
78
186k
    // remarks enabled. We can't currently check whether remarks are requested
79
186k
    // for the calling pass since that requires actually building the remark.
80
186k
81
186k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
186k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
6
      auto R = RemarkBuilder();
84
6
      emit((DiagnosticInfoOptimizationBase &)R);
85
6
    }
86
186k
  }
LICM.cpp:void llvm::OptimizationRemarkEmitter::emit<isSafeToExecuteUnconditionally(llvm::Instruction&, llvm::DominatorTree const*, llvm::Loop const*, llvm::LoopSafetyInfo const*, llvm::OptimizationRemarkEmitter*, llvm::Instruction const*)::$_6>(isSafeToExecuteUnconditionally(llvm::Instruction&, llvm::DominatorTree const*, llvm::Loop const*, llvm::LoopSafetyInfo const*, llvm::OptimizationRemarkEmitter*, llvm::Instruction const*)::$_6, decltype(fp())*)
Line
Count
Source
76
10.1k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
10.1k
    // Avoid building the remark unless we know there are at least *some*
78
10.1k
    // remarks enabled. We can't currently check whether remarks are requested
79
10.1k
    // for the calling pass since that requires actually building the remark.
80
10.1k
81
10.1k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
10.1k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
2
      auto R = RemarkBuilder();
84
2
      emit((DiagnosticInfoOptimizationBase &)R);
85
2
    }
86
10.1k
  }
LICM.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::canSinkOrHoistInst(llvm::Instruction&, llvm::AAResults*, llvm::DominatorTree*, llvm::Loop*, llvm::AliasSetTracker*, bool, llvm::OptimizationRemarkEmitter*)::$_0>(llvm::canSinkOrHoistInst(llvm::Instruction&, llvm::AAResults*, llvm::DominatorTree*, llvm::Loop*, llvm::AliasSetTracker*, bool, llvm::OptimizationRemarkEmitter*)::$_0, decltype(fp())*)
Line
Count
Source
76
541k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
541k
    // Avoid building the remark unless we know there are at least *some*
78
541k
    // remarks enabled. We can't currently check whether remarks are requested
79
541k
    // for the calling pass since that requires actually building the remark.
80
541k
81
541k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
541k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()541k
) {
83
10
      auto R = RemarkBuilder();
84
10
      emit((DiagnosticInfoOptimizationBase &)R);
85
10
    }
86
541k
  }
LICM.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::promoteLoopAccessesToScalars(llvm::SmallSetVector<llvm::Value*, 8u> const&, llvm::SmallVectorImpl<llvm::BasicBlock*>&, llvm::SmallVectorImpl<llvm::Instruction*>&, llvm::PredIteratorCache&, llvm::LoopInfo*, llvm::DominatorTree*, llvm::TargetLibraryInfo const*, llvm::Loop*, llvm::AliasSetTracker*, llvm::LoopSafetyInfo*, llvm::OptimizationRemarkEmitter*)::$_2>(llvm::promoteLoopAccessesToScalars(llvm::SmallSetVector<llvm::Value*, 8u> const&, llvm::SmallVectorImpl<llvm::BasicBlock*>&, llvm::SmallVectorImpl<llvm::Instruction*>&, llvm::PredIteratorCache&, llvm::LoopInfo*, llvm::DominatorTree*, llvm::TargetLibraryInfo const*, llvm::Loop*, llvm::AliasSetTracker*, llvm::LoopSafetyInfo*, llvm::OptimizationRemarkEmitter*)::$_2, decltype(fp())*)
Line
Count
Source
76
2.30k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
2.30k
    // Avoid building the remark unless we know there are at least *some*
78
2.30k
    // remarks enabled. We can't currently check whether remarks are requested
79
2.30k
    // for the calling pass since that requires actually building the remark.
80
2.30k
81
2.30k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
2.30k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
2
      auto R = RemarkBuilder();
84
2
      emit((DiagnosticInfoOptimizationBase &)R);
85
2
    }
86
2.30k
  }
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
76
45
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
45
    // Avoid building the remark unless we know there are at least *some*
78
45
    // remarks enabled. We can't currently check whether remarks are requested
79
45
    // for the calling pass since that requires actually building the remark.
80
45
81
45
    if (F->getContext().getDiagnosticsOutputFile() ||
82
45
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
4
      auto R = RemarkBuilder();
84
4
      emit((DiagnosticInfoOptimizationBase &)R);
85
4
    }
86
45
  }
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
76
17
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
17
    // Avoid building the remark unless we know there are at least *some*
78
17
    // remarks enabled. We can't currently check whether remarks are requested
79
17
    // for the calling pass since that requires actually building the remark.
80
17
81
17
    if (F->getContext().getDiagnosticsOutputFile() ||
82
17
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
10
      auto R = RemarkBuilder();
84
10
      emit((DiagnosticInfoOptimizationBase &)R);
85
10
    }
86
17
  }
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
76
19
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
19
    // Avoid building the remark unless we know there are at least *some*
78
19
    // remarks enabled. We can't currently check whether remarks are requested
79
19
    // for the calling pass since that requires actually building the remark.
80
19
81
19
    if (F->getContext().getDiagnosticsOutputFile() ||
82
19
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
3
      auto R = RemarkBuilder();
84
3
      emit((DiagnosticInfoOptimizationBase &)R);
85
3
    }
86
19
  }
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
76
7
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
7
    // Avoid building the remark unless we know there are at least *some*
78
7
    // remarks enabled. We can't currently check whether remarks are requested
79
7
    // for the calling pass since that requires actually building the remark.
80
7
81
7
    if (F->getContext().getDiagnosticsOutputFile() ||
82
7
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()1
) {
83
6
      auto R = RemarkBuilder();
84
6
      emit((DiagnosticInfoOptimizationBase &)R);
85
6
    }
86
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()::$_1>((anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_1, decltype(fp())*)
Line
Count
Source
76
1
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1
    // Avoid building the remark unless we know there are at least *some*
78
1
    // remarks enabled. We can't currently check whether remarks are requested
79
1
    // for the calling pass since that requires actually building the remark.
80
1
81
1
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()0
) {
83
1
      auto R = RemarkBuilder();
84
1
      emit((DiagnosticInfoOptimizationBase &)R);
85
1
    }
86
1
  }
Unexecuted instantiation: LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_2>((anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_2, decltype(fp())*)
Unexecuted instantiation: LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_3>((anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_3, decltype(fp())*)
LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_4>((anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_4, decltype(fp())*)
Line
Count
Source
76
1
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1
    // Avoid building the remark unless we know there are at least *some*
78
1
    // remarks enabled. We can't currently check whether remarks are requested
79
1
    // for the calling pass since that requires actually building the remark.
80
1
81
1
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()0
) {
83
1
      auto R = RemarkBuilder();
84
1
      emit((DiagnosticInfoOptimizationBase &)R);
85
1
    }
86
1
  }
Unexecuted instantiation: LoopInterchange.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_5>((anonymous namespace)::LoopInterchangeLegality::currentLimitations()::$_5, decltype(fp())*)
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
76
2
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
2
    // Avoid building the remark unless we know there are at least *some*
78
2
    // remarks enabled. We can't currently check whether remarks are requested
79
2
    // for the calling pass since that requires actually building the remark.
80
2
81
2
    if (F->getContext().getDiagnosticsOutputFile() ||
82
2
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()0
) {
83
2
      auto R = RemarkBuilder();
84
2
      emit((DiagnosticInfoOptimizationBase &)R);
85
2
    }
86
2
  }
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
76
2
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
2
    // Avoid building the remark unless we know there are at least *some*
78
2
    // remarks enabled. We can't currently check whether remarks are requested
79
2
    // for the calling pass since that requires actually building the remark.
80
2
81
2
    if (F->getContext().getDiagnosticsOutputFile() ||
82
2
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()0
) {
83
2
      auto R = RemarkBuilder();
84
2
      emit((DiagnosticInfoOptimizationBase &)R);
85
2
    }
86
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
76
8
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
8
    // Avoid building the remark unless we know there are at least *some*
78
8
    // remarks enabled. We can't currently check whether remarks are requested
79
8
    // for the calling pass since that requires actually building the remark.
80
8
81
8
    if (F->getContext().getDiagnosticsOutputFile() ||
82
8
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()5
) {
83
4
      auto R = RemarkBuilder();
84
4
      emit((DiagnosticInfoOptimizationBase &)R);
85
4
    }
86
8
  }
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
76
3
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
3
    // Avoid building the remark unless we know there are at least *some*
78
3
    // remarks enabled. We can't currently check whether remarks are requested
79
3
    // for the calling pass since that requires actually building the remark.
80
3
81
3
    if (F->getContext().getDiagnosticsOutputFile() ||
82
3
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
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
76
5
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
5
    // Avoid building the remark unless we know there are at least *some*
78
5
    // remarks enabled. We can't currently check whether remarks are requested
79
5
    // for the calling pass since that requires actually building the remark.
80
5
81
5
    if (F->getContext().getDiagnosticsOutputFile() ||
82
5
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
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
76
3
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
3
    // Avoid building the remark unless we know there are at least *some*
78
3
    // remarks enabled. We can't currently check whether remarks are requested
79
3
    // for the calling pass since that requires actually building the remark.
80
3
81
3
    if (F->getContext().getDiagnosticsOutputFile() ||
82
3
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
3
  }
LoopVersioningLICM.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopVersioningLICM::isLegalForVersioning()::$_3>((anonymous namespace)::LoopVersioningLICM::isLegalForVersioning()::$_3, decltype(fp())*)
Line
Count
Source
76
2
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
2
    // Avoid building the remark unless we know there are at least *some*
78
2
    // remarks enabled. We can't currently check whether remarks are requested
79
2
    // for the calling pass since that requires actually building the remark.
80
2
81
2
    if (F->getContext().getDiagnosticsOutputFile() ||
82
2
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
2
  }
Unexecuted instantiation: LoopVersioningLICM.cpp:void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::LoopVersioningLICM::legalLoopInstructions()::$_0>((anonymous namespace)::LoopVersioningLICM::legalLoopInstructions()::$_0, decltype(fp())*)
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
76
1
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1
    // Avoid building the remark unless we know there are at least *some*
78
1
    // remarks enabled. We can't currently check whether remarks are requested
79
1
    // for the calling pass since that requires actually building the remark.
80
1
81
1
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
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
76
72
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
72
    // Avoid building the remark unless we know there are at least *some*
78
72
    // remarks enabled. We can't currently check whether remarks are requested
79
72
    // for the calling pass since that requires actually building the remark.
80
72
81
72
    if (F->getContext().getDiagnosticsOutputFile() ||
82
72
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
72
  }
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
76
285
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
285
    // Avoid building the remark unless we know there are at least *some*
78
285
    // remarks enabled. We can't currently check whether remarks are requested
79
285
    // for the calling pass since that requires actually building the remark.
80
285
81
285
    if (F->getContext().getDiagnosticsOutputFile() ||
82
285
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
2
      auto R = RemarkBuilder();
84
2
      emit((DiagnosticInfoOptimizationBase &)R);
85
2
    }
86
285
  }
LoopUnroll.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::UnrollLoop(llvm::Loop*, unsigned int, unsigned int, bool, bool, bool, bool, bool, unsigned int, unsigned int, bool, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool)::$_3>(llvm::UnrollLoop(llvm::Loop*, unsigned int, unsigned int, bool, bool, bool, bool, bool, unsigned int, unsigned int, bool, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool)::$_3, decltype(fp())*)
Line
Count
Source
76
9.33k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
9.33k
    // Avoid building the remark unless we know there are at least *some*
78
9.33k
    // remarks enabled. We can't currently check whether remarks are requested
79
9.33k
    // for the calling pass since that requires actually building the remark.
80
9.33k
81
9.33k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
9.33k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()9.32k
) {
83
3
      auto R = RemarkBuilder();
84
3
      emit((DiagnosticInfoOptimizationBase &)R);
85
3
    }
86
9.33k
  }
LoopUnroll.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::UnrollLoop(llvm::Loop*, unsigned int, unsigned int, bool, bool, bool, bool, bool, unsigned int, unsigned int, bool, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool)::$_4>(llvm::UnrollLoop(llvm::Loop*, unsigned int, unsigned int, bool, bool, bool, bool, bool, unsigned int, unsigned int, bool, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool)::$_4, decltype(fp())*)
Line
Count
Source
76
113
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
113
    // Avoid building the remark unless we know there are at least *some*
78
113
    // remarks enabled. We can't currently check whether remarks are requested
79
113
    // for the calling pass since that requires actually building the remark.
80
113
81
113
    if (F->getContext().getDiagnosticsOutputFile() ||
82
113
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
113
  }
LoopUnroll.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::UnrollLoop(llvm::Loop*, unsigned int, unsigned int, bool, bool, bool, bool, bool, unsigned int, unsigned int, bool, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool)::$_6>(llvm::UnrollLoop(llvm::Loop*, unsigned int, unsigned int, bool, bool, bool, bool, bool, unsigned int, unsigned int, bool, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool)::$_6, decltype(fp())*)
Line
Count
Source
76
215
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
215
    // Avoid building the remark unless we know there are at least *some*
78
215
    // remarks enabled. We can't currently check whether remarks are requested
79
215
    // for the calling pass since that requires actually building the remark.
80
215
81
215
    if (F->getContext().getDiagnosticsOutputFile() ||
82
215
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
3
      auto R = RemarkBuilder();
84
3
      emit((DiagnosticInfoOptimizationBase &)R);
85
3
    }
86
215
  }
LoopUnroll.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::UnrollLoop(llvm::Loop*, unsigned int, unsigned int, bool, bool, bool, bool, bool, unsigned int, unsigned int, bool, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool)::$_7>(llvm::UnrollLoop(llvm::Loop*, unsigned int, unsigned int, bool, bool, bool, bool, bool, unsigned int, unsigned int, bool, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool)::$_7, decltype(fp())*)
Line
Count
Source
76
13
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
13
    // Avoid building the remark unless we know there are at least *some*
78
13
    // remarks enabled. We can't currently check whether remarks are requested
79
13
    // for the calling pass since that requires actually building the remark.
80
13
81
13
    if (F->getContext().getDiagnosticsOutputFile() ||
82
13
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
13
  }
LoopUnroll.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::UnrollLoop(llvm::Loop*, unsigned int, unsigned int, bool, bool, bool, bool, bool, unsigned int, unsigned int, bool, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool)::$_8>(llvm::UnrollLoop(llvm::Loop*, unsigned int, unsigned int, bool, bool, bool, bool, bool, unsigned int, unsigned int, bool, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*, bool)::$_8, decltype(fp())*)
Line
Count
Source
76
1.26k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1.26k
    // Avoid building the remark unless we know there are at least *some*
78
1.26k
    // remarks enabled. We can't currently check whether remarks are requested
79
1.26k
    // for the calling pass since that requires actually building the remark.
80
1.26k
81
1.26k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1.26k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
2
      auto R = RemarkBuilder();
84
2
      emit((DiagnosticInfoOptimizationBase &)R);
85
2
    }
86
1.26k
  }
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*)::$_1>(llvm::UnrollAndJamLoop(llvm::Loop*, unsigned int, unsigned int, unsigned int, bool, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*)::$_1, decltype(fp())*)
Line
Count
Source
76
2
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
2
    // Avoid building the remark unless we know there are at least *some*
78
2
    // remarks enabled. We can't currently check whether remarks are requested
79
2
    // for the calling pass since that requires actually building the remark.
80
2
81
2
    if (F->getContext().getDiagnosticsOutputFile() ||
82
2
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
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*)::$_2>(llvm::UnrollAndJamLoop(llvm::Loop*, unsigned int, unsigned int, unsigned int, bool, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::OptimizationRemarkEmitter*)::$_2, decltype(fp())*)
Line
Count
Source
76
22
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
22
    // Avoid building the remark unless we know there are at least *some*
78
22
    // remarks enabled. We can't currently check whether remarks are requested
79
22
    // for the calling pass since that requires actually building the remark.
80
22
81
22
    if (F->getContext().getDiagnosticsOutputFile() ||
82
22
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
22
  }
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
76
22
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
22
    // Avoid building the remark unless we know there are at least *some*
78
22
    // remarks enabled. We can't currently check whether remarks are requested
79
22
    // for the calling pass since that requires actually building the remark.
80
22
81
22
    if (F->getContext().getDiagnosticsOutputFile() ||
82
22
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()20
) {
83
2
      auto R = RemarkBuilder();
84
2
      emit((DiagnosticInfoOptimizationBase &)R);
85
2
    }
86
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
76
5.56k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
5.56k
    // Avoid building the remark unless we know there are at least *some*
78
5.56k
    // remarks enabled. We can't currently check whether remarks are requested
79
5.56k
    // for the calling pass since that requires actually building the remark.
80
5.56k
81
5.56k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
5.56k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()5.56k
) {
83
6
      auto R = RemarkBuilder();
84
6
      emit((DiagnosticInfoOptimizationBase &)R);
85
6
    }
86
5.56k
  }
LoopVectorizationLegality.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizeHints::emitRemarkWithHints() const::$_1>(llvm::LoopVectorizeHints::emitRemarkWithHints() const::$_1, decltype(fp())*)
Line
Count
Source
76
122k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
122k
    // Avoid building the remark unless we know there are at least *some*
78
122k
    // remarks enabled. We can't currently check whether remarks are requested
79
122k
    // for the calling pass since that requires actually building the remark.
80
122k
81
122k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
122k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()122k
) {
83
48
      auto R = RemarkBuilder();
84
48
      emit((DiagnosticInfoOptimizationBase &)R);
85
48
    }
86
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
76
1.35k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1.35k
    // Avoid building the remark unless we know there are at least *some*
78
1.35k
    // remarks enabled. We can't currently check whether remarks are requested
79
1.35k
    // for the calling pass since that requires actually building the remark.
80
1.35k
81
1.35k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1.35k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
4
      auto R = RemarkBuilder();
84
4
      emit((DiagnosticInfoOptimizationBase &)R);
85
4
    }
86
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
76
139
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
139
    // Avoid building the remark unless we know there are at least *some*
78
139
    // remarks enabled. We can't currently check whether remarks are requested
79
139
    // for the calling pass since that requires actually building the remark.
80
139
81
139
    if (F->getContext().getDiagnosticsOutputFile() ||
82
139
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()138
) {
83
5
      auto R = RemarkBuilder();
84
5
      emit((DiagnosticInfoOptimizationBase &)R);
85
5
    }
86
139
  }
LoopVectorizationLegality.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizationLegality::canVectorizeMemory()::$_5>(llvm::LoopVectorizationLegality::canVectorizeMemory()::$_5, decltype(fp())*)
Line
Count
Source
76
7.53k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
7.53k
    // Avoid building the remark unless we know there are at least *some*
78
7.53k
    // remarks enabled. We can't currently check whether remarks are requested
79
7.53k
    // for the calling pass since that requires actually building the remark.
80
7.53k
81
7.53k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
7.53k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()7.53k
) {
83
33
      auto R = RemarkBuilder();
84
33
      emit((DiagnosticInfoOptimizationBase &)R);
85
33
    }
86
7.53k
  }
LoopVectorize.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_30>(llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_30, decltype(fp())*)
Line
Count
Source
76
1.12k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1.12k
    // Avoid building the remark unless we know there are at least *some*
78
1.12k
    // remarks enabled. We can't currently check whether remarks are requested
79
1.12k
    // for the calling pass since that requires actually building the remark.
80
1.12k
81
1.12k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1.12k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
5
      auto R = RemarkBuilder();
84
5
      emit((DiagnosticInfoOptimizationBase &)R);
85
5
    }
86
1.12k
  }
LoopVectorize.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_31>(llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_31, decltype(fp())*)
Line
Count
Source
76
1.12k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1.12k
    // Avoid building the remark unless we know there are at least *some*
78
1.12k
    // remarks enabled. We can't currently check whether remarks are requested
79
1.12k
    // for the calling pass since that requires actually building the remark.
80
1.12k
81
1.12k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1.12k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
5
      auto R = RemarkBuilder();
84
5
      emit((DiagnosticInfoOptimizationBase &)R);
85
5
    }
86
1.12k
  }
LoopVectorize.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_32>(llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_32, decltype(fp())*)
Line
Count
Source
76
1.54k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1.54k
    // Avoid building the remark unless we know there are at least *some*
78
1.54k
    // remarks enabled. We can't currently check whether remarks are requested
79
1.54k
    // for the calling pass since that requires actually building the remark.
80
1.54k
81
1.54k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1.54k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
2
      auto R = RemarkBuilder();
84
2
      emit((DiagnosticInfoOptimizationBase &)R);
85
2
    }
86
1.54k
  }
LoopVectorize.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_33>(llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_33, decltype(fp())*)
Line
Count
Source
76
1.40k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1.40k
    // Avoid building the remark unless we know there are at least *some*
78
1.40k
    // remarks enabled. We can't currently check whether remarks are requested
79
1.40k
    // for the calling pass since that requires actually building the remark.
80
1.40k
81
1.40k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1.40k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
5
      auto R = RemarkBuilder();
84
5
      emit((DiagnosticInfoOptimizationBase &)R);
85
5
    }
86
1.40k
  }
LoopVectorize.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_34>(llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_34, decltype(fp())*)
Line
Count
Source
76
1.54k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1.54k
    // Avoid building the remark unless we know there are at least *some*
78
1.54k
    // remarks enabled. We can't currently check whether remarks are requested
79
1.54k
    // for the calling pass since that requires actually building the remark.
80
1.54k
81
1.54k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1.54k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
2
      auto R = RemarkBuilder();
84
2
      emit((DiagnosticInfoOptimizationBase &)R);
85
2
    }
86
1.54k
  }
LoopVectorize.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_35>(llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_35, decltype(fp())*)
Line
Count
Source
76
15.3k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
15.3k
    // Avoid building the remark unless we know there are at least *some*
78
15.3k
    // remarks enabled. We can't currently check whether remarks are requested
79
15.3k
    // for the calling pass since that requires actually building the remark.
80
15.3k
81
15.3k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
15.3k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()15.3k
) {
83
10
      auto R = RemarkBuilder();
84
10
      emit((DiagnosticInfoOptimizationBase &)R);
85
10
    }
86
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
76
3.63k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
3.63k
    // Avoid building the remark unless we know there are at least *some*
78
3.63k
    // remarks enabled. We can't currently check whether remarks are requested
79
3.63k
    // for the calling pass since that requires actually building the remark.
80
3.63k
81
3.63k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
3.63k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()3.63k
) {
83
1
      auto R = RemarkBuilder();
84
1
      emit((DiagnosticInfoOptimizationBase &)R);
85
1
    }
86
3.63k
  }
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
76
144
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
144
    // Avoid building the remark unless we know there are at least *some*
78
144
    // remarks enabled. We can't currently check whether remarks are requested
79
144
    // for the calling pass since that requires actually building the remark.
80
144
81
144
    if (F->getContext().getDiagnosticsOutputFile() ||
82
144
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()136
) {
83
8
      auto R = RemarkBuilder();
84
8
      emit((DiagnosticInfoOptimizationBase &)R);
85
8
    }
86
144
  }
Unexecuted instantiation: SLPVectorizer.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::SLPVectorizerPass::tryToVectorizeList(llvm::ArrayRef<llvm::Value*>, llvm::slpvectorizer::BoUpSLP&, int, bool)::$_9>(llvm::SLPVectorizerPass::tryToVectorizeList(llvm::ArrayRef<llvm::Value*>, llvm::slpvectorizer::BoUpSLP&, int, bool)::$_9, decltype(fp())*)
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())*)
Line
Count
Source
76
3.98k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
3.98k
    // Avoid building the remark unless we know there are at least *some*
78
3.98k
    // remarks enabled. We can't currently check whether remarks are requested
79
3.98k
    // for the calling pass since that requires actually building the remark.
80
3.98k
81
3.98k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
3.98k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()3.96k
) {
83
22
      auto R = RemarkBuilder();
84
22
      emit((DiagnosticInfoOptimizationBase &)R);
85
22
    }
86
3.98k
  }
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
76
177k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
177k
    // Avoid building the remark unless we know there are at least *some*
78
177k
    // remarks enabled. We can't currently check whether remarks are requested
79
177k
    // for the calling pass since that requires actually building the remark.
80
177k
81
177k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
177k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()177k
) {
83
17
      auto R = RemarkBuilder();
84
17
      emit((DiagnosticInfoOptimizationBase &)R);
85
17
    }
86
177k
  }
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
76
253k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
253k
    // Avoid building the remark unless we know there are at least *some*
78
253k
    // remarks enabled. We can't currently check whether remarks are requested
79
253k
    // for the calling pass since that requires actually building the remark.
80
253k
81
253k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
253k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()253k
) {
83
9
      auto R = RemarkBuilder();
84
9
      emit((DiagnosticInfoOptimizationBase &)R);
85
9
    }
86
253k
  }
87
88
  /// Whether we allow for extra compile-time budget to perform more
89
  /// analysis to produce fewer false positives.
90
  ///
91
  /// This is useful when reporting missed optimizations.  In this case we can
92
  /// use the extra analysis (1) to filter trivial false positives or (2) to
93
  /// provide more context so that non-trivial false positives can be quickly
94
  /// detected by the user.
95
4.17M
  bool allowExtraAnalysis(StringRef PassName) const {
96
4.17M
    return (F->getContext().getDiagnosticsOutputFile() ||
97
4.17M
            
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled(PassName)4.17M
);
98
4.17M
  }
99
100
private:
101
  const Function *F;
102
103
  BlockFrequencyInfo *BFI;
104
105
  /// If we generate BFI on demand, we need to free it when ORE is freed.
106
  std::unique_ptr<BlockFrequencyInfo> OwnedBFI;
107
108
  /// Compute hotness from IR value (currently assumed to be a block) if PGO is
109
  /// available.
110
  Optional<uint64_t> computeHotness(const Value *V);
111
112
  /// Similar but use value from \p OptDiag and update hotness there.
113
  void computeHotness(DiagnosticInfoIROptimization &OptDiag);
114
115
  /// Only allow verbose messages if we know we're filtering by hotness
116
  /// (BFI is only set in this case).
117
0
  bool shouldEmitVerbose() { return BFI != nullptr; }
118
119
  OptimizationRemarkEmitter(const OptimizationRemarkEmitter &) = delete;
120
  void operator=(const OptimizationRemarkEmitter &) = delete;
121
};
122
123
/// Add a small namespace to avoid name clashes with the classes used in
124
/// the streaming interface.  We want these to be short for better
125
/// write/readability.
126
namespace ore {
127
using NV = DiagnosticInfoOptimizationBase::Argument;
128
using setIsVerbose = DiagnosticInfoOptimizationBase::setIsVerbose;
129
using setExtraArgs = DiagnosticInfoOptimizationBase::setExtraArgs;
130
}
131
132
/// OptimizationRemarkEmitter legacy analysis pass
133
///
134
/// Note that this pass shouldn't generally be marked as preserved by other
135
/// passes.  It's holding onto BFI, so if the pass does not preserve BFI, BFI
136
/// could be freed.
137
class OptimizationRemarkEmitterWrapperPass : public FunctionPass {
138
  std::unique_ptr<OptimizationRemarkEmitter> ORE;
139
140
public:
141
  OptimizationRemarkEmitterWrapperPass();
142
143
  bool runOnFunction(Function &F) override;
144
145
  void getAnalysisUsage(AnalysisUsage &AU) const override;
146
147
5.86M
  OptimizationRemarkEmitter &getORE() {
148
5.86M
    assert(ORE && "pass not run yet");
149
5.86M
    return *ORE;
150
5.86M
  }
151
152
  static char ID;
153
};
154
155
class OptimizationRemarkEmitterAnalysis
156
    : public AnalysisInfoMixin<OptimizationRemarkEmitterAnalysis> {
157
  friend AnalysisInfoMixin<OptimizationRemarkEmitterAnalysis>;
158
  static AnalysisKey Key;
159
160
public:
161
  /// Provide the result typedef for this analysis pass.
162
  typedef OptimizationRemarkEmitter Result;
163
164
  /// Run the analysis pass over a function and produce BFI.
165
  Result run(Function &F, FunctionAnalysisManager &AM);
166
};
167
}
168
#endif // LLVM_IR_OPTIMIZATIONDIAGNOSTICINFO_H