Coverage Report

Created: 2018-07-19 03:59

/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.66M
      : 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.55k
      : 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.21M
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
5.21M
    // Avoid building the remark unless we know there are at least *some*
78
5.21M
    // remarks enabled. We can't currently check whether remarks are requested
79
5.21M
    // for the calling pass since that requires actually building the remark.
80
5.21M
81
5.21M
    if (F->getContext().getDiagnosticsOutputFile() ||
82
5.21M
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()5.21M
) {
83
565
      auto R = RemarkBuilder();
84
565
      emit((DiagnosticInfoOptimizationBase &)R);
85
565
    }
86
5.21M
  }
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&)::$_2>(computeKnownBitsFromAssume(llvm::Value const*, llvm::KnownBits&, unsigned int, (anonymous namespace)::Query const&)::$_2, 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.14k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
3.14k
    // Avoid building the remark unless we know there are at least *some*
78
3.14k
    // remarks enabled. We can't currently check whether remarks are requested
79
3.14k
    // for the calling pass since that requires actually building the remark.
80
3.14k
81
3.14k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
3.14k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()3.14k
) {
83
8
      auto R = RemarkBuilder();
84
8
      emit((DiagnosticInfoOptimizationBase &)R);
85
8
    }
86
3.14k
  }
StackProtector.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::StackProtector::RequiresStackProtector()::$_3>(llvm::StackProtector::RequiresStackProtector()::$_3, decltype(fp())*)
Line
Count
Source
76
295
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
295
    // Avoid building the remark unless we know there are at least *some*
78
295
    // remarks enabled. We can't currently check whether remarks are requested
79
295
    // for the calling pass since that requires actually building the remark.
80
295
81
295
    if (F->getContext().getDiagnosticsOutputFile() ||
82
295
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()293
) {
83
4
      auto R = RemarkBuilder();
84
4
      emit((DiagnosticInfoOptimizationBase &)R);
85
4
    }
86
295
  }
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
514k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
514k
    // Avoid building the remark unless we know there are at least *some*
78
514k
    // remarks enabled. We can't currently check whether remarks are requested
79
514k
    // for the calling pass since that requires actually building the remark.
80
514k
81
514k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
514k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()514k
) {
83
27
      auto R = RemarkBuilder();
84
27
      emit((DiagnosticInfoOptimizationBase &)R);
85
27
    }
86
514k
  }
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
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
  }
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&)::$_16>(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&)::$_16, decltype(fp())*)
Line
Count
Source
76
456k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
456k
    // Avoid building the remark unless we know there are at least *some*
78
456k
    // remarks enabled. We can't currently check whether remarks are requested
79
456k
    // for the calling pass since that requires actually building the remark.
80
456k
81
456k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
456k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()456k
) {
83
54
      auto R = RemarkBuilder();
84
54
      emit((DiagnosticInfoOptimizationBase &)R);
85
54
    }
86
456k
  }
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
823k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
823k
    // Avoid building the remark unless we know there are at least *some*
78
823k
    // remarks enabled. We can't currently check whether remarks are requested
79
823k
    // for the calling pass since that requires actually building the remark.
80
823k
81
823k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
823k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
31
      auto R = RemarkBuilder();
84
31
      emit((DiagnosticInfoOptimizationBase &)R);
85
31
    }
86
823k
  }
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
115k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
115k
    // Avoid building the remark unless we know there are at least *some*
78
115k
    // remarks enabled. We can't currently check whether remarks are requested
79
115k
    // for the calling pass since that requires actually building the remark.
80
115k
81
115k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
115k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
12
      auto R = RemarkBuilder();
84
12
      emit((DiagnosticInfoOptimizationBase &)R);
85
12
    }
86
115k
  }
Inliner.cpp:void llvm::OptimizationRemarkEmitter::emit<shouldInline(llvm::CallSite, llvm::function_ref<llvm::InlineCost (llvm::CallSite)>, llvm::OptimizationRemarkEmitter&)::$_13>(shouldInline(llvm::CallSite, llvm::function_ref<llvm::InlineCost (llvm::CallSite)>, llvm::OptimizationRemarkEmitter&)::$_13, decltype(fp())*)
Line
Count
Source
76
1.49k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1.49k
    // Avoid building the remark unless we know there are at least *some*
78
1.49k
    // remarks enabled. We can't currently check whether remarks are requested
79
1.49k
    // for the calling pass since that requires actually building the remark.
80
1.49k
81
1.49k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1.49k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
1.49k
  }
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.36k
) {
83
10
      auto R = RemarkBuilder();
84
10
      emit((DiagnosticInfoOptimizationBase &)R);
85
10
    }
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())*)
Inliner.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::InlinerPass::run(llvm::LazyCallGraph::SCC&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&)::$_8>(llvm::InlinerPass::run(llvm::LazyCallGraph::SCC&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&)::$_8, decltype(fp())*)
Line
Count
Source
76
356
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
356
    // Avoid building the remark unless we know there are at least *some*
78
356
    // remarks enabled. We can't currently check whether remarks are requested
79
356
    // for the calling pass since that requires actually building the remark.
80
356
81
356
    if (F->getContext().getDiagnosticsOutputFile() ||
82
356
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()354
) {
83
5
      auto R = RemarkBuilder();
84
5
      emit((DiagnosticInfoOptimizationBase &)R);
85
5
    }
86
356
  }
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
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
4
      auto R = RemarkBuilder();
84
4
      emit((DiagnosticInfoOptimizationBase &)R);
85
4
    }
86
17
  }
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
80
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
80
    // Avoid building the remark unless we know there are at least *some*
78
80
    // remarks enabled. We can't currently check whether remarks are requested
79
80
    // for the calling pass since that requires actually building the remark.
80
80
81
80
    if (F->getContext().getDiagnosticsOutputFile() ||
82
80
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
4
      auto R = RemarkBuilder();
84
4
      emit((DiagnosticInfoOptimizationBase &)R);
85
4
    }
86
80
  }
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
208
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
208
    // Avoid building the remark unless we know there are at least *some*
78
208
    // remarks enabled. We can't currently check whether remarks are requested
79
208
    // for the calling pass since that requires actually building the remark.
80
208
81
208
    if (F->getContext().getDiagnosticsOutputFile() ||
82
208
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()198
) {
83
35
      auto R = RemarkBuilder();
84
35
      emit((DiagnosticInfoOptimizationBase &)R);
85
35
    }
86
208
  }
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
  }
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
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
12
      auto R = RemarkBuilder();
84
12
      emit((DiagnosticInfoOptimizationBase &)R);
85
12
    }
86
45
  }
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*)::$_3>(reportLoadElim(llvm::LoadInst*, llvm::Value*, llvm::OptimizationRemarkEmitter*)::$_3, decltype(fp())*)
Line
Count
Source
76
37.3k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
37.3k
    // Avoid building the remark unless we know there are at least *some*
78
37.3k
    // remarks enabled. We can't currently check whether remarks are requested
79
37.3k
    // for the calling pass since that requires actually building the remark.
80
37.3k
81
37.3k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
37.3k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()37.3k
) {
83
12
      auto R = RemarkBuilder();
84
12
      emit((DiagnosticInfoOptimizationBase &)R);
85
12
    }
86
37.3k
  }
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
22.8k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
22.8k
    // Avoid building the remark unless we know there are at least *some*
78
22.8k
    // remarks enabled. We can't currently check whether remarks are requested
79
22.8k
    // for the calling pass since that requires actually building the remark.
80
22.8k
81
22.8k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
22.8k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
22.8k
  }
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
1.95M
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1.95M
    // Avoid building the remark unless we know there are at least *some*
78
1.95M
    // remarks enabled. We can't currently check whether remarks are requested
79
1.95M
    // for the calling pass since that requires actually building the remark.
80
1.95M
81
1.95M
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1.95M
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()1.95M
) {
83
67
      auto R = RemarkBuilder();
84
67
      emit((DiagnosticInfoOptimizationBase &)R);
85
67
    }
86
1.95M
  }
LICM.cpp:void llvm::OptimizationRemarkEmitter::emit<hoist(llvm::Instruction&, llvm::DominatorTree const*, llvm::Loop const*, llvm::LoopSafetyInfo const*, llvm::OptimizationRemarkEmitter*)::$_5>(hoist(llvm::Instruction&, llvm::DominatorTree const*, llvm::Loop const*, llvm::LoopSafetyInfo const*, llvm::OptimizationRemarkEmitter*)::$_5, decltype(fp())*)
Line
Count
Source
76
169k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
169k
    // Avoid building the remark unless we know there are at least *some*
78
169k
    // remarks enabled. We can't currently check whether remarks are requested
79
169k
    // for the calling pass since that requires actually building the remark.
80
169k
81
169k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
169k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
6
      auto R = RemarkBuilder();
84
6
      emit((DiagnosticInfoOptimizationBase &)R);
85
6
    }
86
169k
  }
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
9.04k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
9.04k
    // Avoid building the remark unless we know there are at least *some*
78
9.04k
    // remarks enabled. We can't currently check whether remarks are requested
79
9.04k
    // for the calling pass since that requires actually building the remark.
80
9.04k
81
9.04k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
9.04k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
2
      auto R = RemarkBuilder();
84
2
      emit((DiagnosticInfoOptimizationBase &)R);
85
2
    }
86
9.04k
  }
LICM.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::canSinkOrHoistInst(llvm::Instruction&, llvm::AAResults*, llvm::DominatorTree*, llvm::Loop*, llvm::AliasSetTracker*, llvm::LoopSafetyInfo*, llvm::OptimizationRemarkEmitter*)::$_0>(llvm::canSinkOrHoistInst(llvm::Instruction&, llvm::AAResults*, llvm::DominatorTree*, llvm::Loop*, llvm::AliasSetTracker*, llvm::LoopSafetyInfo*, llvm::OptimizationRemarkEmitter*)::$_0, decltype(fp())*)
Line
Count
Source
76
515k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
515k
    // Avoid building the remark unless we know there are at least *some*
78
515k
    // remarks enabled. We can't currently check whether remarks are requested
79
515k
    // for the calling pass since that requires actually building the remark.
80
515k
81
515k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
515k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()515k
) {
83
10
      auto R = RemarkBuilder();
84
10
      emit((DiagnosticInfoOptimizationBase &)R);
85
10
    }
86
515k
  }
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.23k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
2.23k
    // Avoid building the remark unless we know there are at least *some*
78
2.23k
    // remarks enabled. We can't currently check whether remarks are requested
79
2.23k
    // for the calling pass since that requires actually building the remark.
80
2.23k
81
2.23k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
2.23k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
2
      auto R = RemarkBuilder();
84
2
      emit((DiagnosticInfoOptimizationBase &)R);
85
2
    }
86
2.23k
  }
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
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
4
      auto R = RemarkBuilder();
84
4
      emit((DiagnosticInfoOptimizationBase &)R);
85
4
    }
86
39
  }
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
83
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
83
    // Avoid building the remark unless we know there are at least *some*
78
83
    // remarks enabled. We can't currently check whether remarks are requested
79
83
    // for the calling pass since that requires actually building the remark.
80
83
81
83
    if (F->getContext().getDiagnosticsOutputFile() ||
82
83
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
83
  }
TailRecursionElimination.cpp:void llvm::OptimizationRemarkEmitter::emit<eliminateRecursiveTailCall(llvm::CallInst*, llvm::ReturnInst*, llvm::BasicBlock*&, bool&, llvm::SmallVectorImpl<llvm::PHINode*>&, llvm::AAResults*, llvm::OptimizationRemarkEmitter*)::$_2>(eliminateRecursiveTailCall(llvm::CallInst*, llvm::ReturnInst*, llvm::BasicBlock*&, bool&, llvm::SmallVectorImpl<llvm::PHINode*>&, llvm::AAResults*, llvm::OptimizationRemarkEmitter*)::$_2, decltype(fp())*)
Line
Count
Source
76
278
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
278
    // Avoid building the remark unless we know there are at least *some*
78
278
    // remarks enabled. We can't currently check whether remarks are requested
79
278
    // for the calling pass since that requires actually building the remark.
80
278
81
278
    if (F->getContext().getDiagnosticsOutputFile() ||
82
278
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
2
      auto R = RemarkBuilder();
84
2
      emit((DiagnosticInfoOptimizationBase &)R);
85
2
    }
86
278
  }
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.13k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
9.13k
    // Avoid building the remark unless we know there are at least *some*
78
9.13k
    // remarks enabled. We can't currently check whether remarks are requested
79
9.13k
    // for the calling pass since that requires actually building the remark.
80
9.13k
81
9.13k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
9.13k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()9.13k
) {
83
3
      auto R = RemarkBuilder();
84
3
      emit((DiagnosticInfoOptimizationBase &)R);
85
3
    }
86
9.13k
  }
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
214
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
214
    // Avoid building the remark unless we know there are at least *some*
78
214
    // remarks enabled. We can't currently check whether remarks are requested
79
214
    // for the calling pass since that requires actually building the remark.
80
214
81
214
    if (F->getContext().getDiagnosticsOutputFile() ||
82
214
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
3
      auto R = RemarkBuilder();
84
3
      emit((DiagnosticInfoOptimizationBase &)R);
85
3
    }
86
214
  }
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.22k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1.22k
    // Avoid building the remark unless we know there are at least *some*
78
1.22k
    // remarks enabled. We can't currently check whether remarks are requested
79
1.22k
    // for the calling pass since that requires actually building the remark.
80
1.22k
81
1.22k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1.22k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
2
      auto R = RemarkBuilder();
84
2
      emit((DiagnosticInfoOptimizationBase &)R);
85
2
    }
86
1.22k
  }
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
20
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
20
    // Avoid building the remark unless we know there are at least *some*
78
20
    // remarks enabled. We can't currently check whether remarks are requested
79
20
    // for the calling pass since that requires actually building the remark.
80
20
81
20
    if (F->getContext().getDiagnosticsOutputFile() ||
82
20
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
0
      auto R = RemarkBuilder();
84
0
      emit((DiagnosticInfoOptimizationBase &)R);
85
0
    }
86
20
  }
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
120k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
120k
    // Avoid building the remark unless we know there are at least *some*
78
120k
    // remarks enabled. We can't currently check whether remarks are requested
79
120k
    // for the calling pass since that requires actually building the remark.
80
120k
81
120k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
120k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()120k
) {
83
46
      auto R = RemarkBuilder();
84
46
      emit((DiagnosticInfoOptimizationBase &)R);
85
46
    }
86
120k
  }
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.32k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1.32k
    // Avoid building the remark unless we know there are at least *some*
78
1.32k
    // remarks enabled. We can't currently check whether remarks are requested
79
1.32k
    // for the calling pass since that requires actually building the remark.
80
1.32k
81
1.32k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1.32k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
4
      auto R = RemarkBuilder();
84
4
      emit((DiagnosticInfoOptimizationBase &)R);
85
4
    }
86
1.32k
  }
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
140
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
140
    // Avoid building the remark unless we know there are at least *some*
78
140
    // remarks enabled. We can't currently check whether remarks are requested
79
140
    // for the calling pass since that requires actually building the remark.
80
140
81
140
    if (F->getContext().getDiagnosticsOutputFile() ||
82
140
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()139
) {
83
5
      auto R = RemarkBuilder();
84
5
      emit((DiagnosticInfoOptimizationBase &)R);
85
5
    }
86
140
  }
LoopVectorizationLegality.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizationLegality::canVectorizeMemory()::$_4>(llvm::LoopVectorizationLegality::canVectorizeMemory()::$_4, decltype(fp())*)
Line
Count
Source
76
6.87k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
6.87k
    // Avoid building the remark unless we know there are at least *some*
78
6.87k
    // remarks enabled. We can't currently check whether remarks are requested
79
6.87k
    // for the calling pass since that requires actually building the remark.
80
6.87k
81
6.87k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
6.87k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()6.87k
) {
83
33
      auto R = RemarkBuilder();
84
33
      emit((DiagnosticInfoOptimizationBase &)R);
85
33
    }
86
6.87k
  }
LoopVectorize.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_28>(llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_28, decltype(fp())*)
Line
Count
Source
76
1.05k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1.05k
    // Avoid building the remark unless we know there are at least *some*
78
1.05k
    // remarks enabled. We can't currently check whether remarks are requested
79
1.05k
    // for the calling pass since that requires actually building the remark.
80
1.05k
81
1.05k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1.05k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
5
      auto R = RemarkBuilder();
84
5
      emit((DiagnosticInfoOptimizationBase &)R);
85
5
    }
86
1.05k
  }
LoopVectorize.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_29>(llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_29, decltype(fp())*)
Line
Count
Source
76
1.05k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1.05k
    // Avoid building the remark unless we know there are at least *some*
78
1.05k
    // remarks enabled. We can't currently check whether remarks are requested
79
1.05k
    // for the calling pass since that requires actually building the remark.
80
1.05k
81
1.05k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1.05k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
5
      auto R = RemarkBuilder();
84
5
      emit((DiagnosticInfoOptimizationBase &)R);
85
5
    }
86
1.05k
  }
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.47k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1.47k
    // Avoid building the remark unless we know there are at least *some*
78
1.47k
    // remarks enabled. We can't currently check whether remarks are requested
79
1.47k
    // for the calling pass since that requires actually building the remark.
80
1.47k
81
1.47k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1.47k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
2
      auto R = RemarkBuilder();
84
2
      emit((DiagnosticInfoOptimizationBase &)R);
85
2
    }
86
1.47k
  }
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.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
5
      auto R = RemarkBuilder();
84
5
      emit((DiagnosticInfoOptimizationBase &)R);
85
5
    }
86
1.35k
  }
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.47k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
1.47k
    // Avoid building the remark unless we know there are at least *some*
78
1.47k
    // remarks enabled. We can't currently check whether remarks are requested
79
1.47k
    // for the calling pass since that requires actually building the remark.
80
1.47k
81
1.47k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
1.47k
        F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()) {
83
2
      auto R = RemarkBuilder();
84
2
      emit((DiagnosticInfoOptimizationBase &)R);
85
2
    }
86
1.47k
  }
LoopVectorize.cpp:void llvm::OptimizationRemarkEmitter::emit<llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_33>(llvm::LoopVectorizePass::processLoop(llvm::Loop*)::$_33, decltype(fp())*)
Line
Count
Source
76
14.9k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
14.9k
    // Avoid building the remark unless we know there are at least *some*
78
14.9k
    // remarks enabled. We can't currently check whether remarks are requested
79
14.9k
    // for the calling pass since that requires actually building the remark.
80
14.9k
81
14.9k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
14.9k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()14.9k
) {
83
10
      auto R = RemarkBuilder();
84
10
      emit((DiagnosticInfoOptimizationBase &)R);
85
10
    }
86
14.9k
  }
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
4.03k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
4.03k
    // Avoid building the remark unless we know there are at least *some*
78
4.03k
    // remarks enabled. We can't currently check whether remarks are requested
79
4.03k
    // for the calling pass since that requires actually building the remark.
80
4.03k
81
4.03k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
4.03k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()4.00k
) {
83
22
      auto R = RemarkBuilder();
84
22
      emit((DiagnosticInfoOptimizationBase &)R);
85
22
    }
86
4.03k
  }
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
163k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
163k
    // Avoid building the remark unless we know there are at least *some*
78
163k
    // remarks enabled. We can't currently check whether remarks are requested
79
163k
    // for the calling pass since that requires actually building the remark.
80
163k
81
163k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
163k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()163k
) {
83
13
      auto R = RemarkBuilder();
84
13
      emit((DiagnosticInfoOptimizationBase &)R);
85
13
    }
86
163k
  }
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
252k
  void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
77
252k
    // Avoid building the remark unless we know there are at least *some*
78
252k
    // remarks enabled. We can't currently check whether remarks are requested
79
252k
    // for the calling pass since that requires actually building the remark.
80
252k
81
252k
    if (F->getContext().getDiagnosticsOutputFile() ||
82
252k
        
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled()252k
) {
83
1
      auto R = RemarkBuilder();
84
1
      emit((DiagnosticInfoOptimizationBase &)R);
85
1
    }
86
252k
  }
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
3.94M
  bool allowExtraAnalysis(StringRef PassName) const {
96
3.94M
    return (F->getContext().getDiagnosticsOutputFile() ||
97
3.94M
            
F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled(PassName)3.94M
);
98
3.94M
  }
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.66M
  OptimizationRemarkEmitter &getORE() {
148
5.66M
    assert(ORE && "pass not run yet");
149
5.66M
    return *ORE;
150
5.66M
  }
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