Coverage Report

Created: 2019-03-22 08:08

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