Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/IR/InstVisitor.h
Line
Count
Source (jump to first uncovered line)
1
//===- InstVisitor.h - Instruction visitor templates ------------*- 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
10
#ifndef LLVM_IR_INSTVISITOR_H
11
#define LLVM_IR_INSTVISITOR_H
12
13
#include "llvm/IR/CallSite.h"
14
#include "llvm/IR/Function.h"
15
#include "llvm/IR/Instructions.h"
16
#include "llvm/IR/IntrinsicInst.h"
17
#include "llvm/IR/Intrinsics.h"
18
#include "llvm/IR/Module.h"
19
#include "llvm/Support/ErrorHandling.h"
20
21
namespace llvm {
22
23
// We operate on opaque instruction classes, so forward declare all instruction
24
// types now...
25
//
26
#define HANDLE_INST(NUM, OPCODE, CLASS)   class CLASS;
27
#include "llvm/IR/Instruction.def"
28
29
#define DELEGATE(CLASS_TO_VISIT) \
30
389M
  return static_cast<SubClass*>(this)-> \
31
389M
               visit##CLASS_TO_VISIT(static_cast<CLASS_TO_VISIT&>(I))
32
33
34
/// Base class for instruction visitors
35
///
36
/// Instruction visitors are used when you want to perform different actions
37
/// for different kinds of instructions without having to use lots of casts
38
/// and a big switch statement (in your code, that is).
39
///
40
/// To define your own visitor, inherit from this class, specifying your
41
/// new type for the 'SubClass' template parameter, and "override" visitXXX
42
/// functions in your class. I say "override" because this class is defined
43
/// in terms of statically resolved overloading, not virtual functions.
44
///
45
/// For example, here is a visitor that counts the number of malloc
46
/// instructions processed:
47
///
48
///  /// Declare the class.  Note that we derive from InstVisitor instantiated
49
///  /// with _our new subclasses_ type.
50
///  ///
51
///  struct CountAllocaVisitor : public InstVisitor<CountAllocaVisitor> {
52
///    unsigned Count;
53
///    CountAllocaVisitor() : Count(0) {}
54
///
55
///    void visitAllocaInst(AllocaInst &AI) { ++Count; }
56
///  };
57
///
58
///  And this class would be used like this:
59
///    CountAllocaVisitor CAV;
60
///    CAV.visit(function);
61
///    NumAllocas = CAV.Count;
62
///
63
/// The defined has 'visit' methods for Instruction, and also for BasicBlock,
64
/// Function, and Module, which recursively process all contained instructions.
65
///
66
/// Note that if you don't implement visitXXX for some instruction type,
67
/// the visitXXX method for instruction superclass will be invoked. So
68
/// if instructions are added in the future, they will be automatically
69
/// supported, if you handle one of their superclasses.
70
///
71
/// The optional second template argument specifies the type that instruction
72
/// visitation functions should return. If you specify this, you *MUST* provide
73
/// an implementation of visitInstruction though!.
74
///
75
/// Note that this class is specifically designed as a template to avoid
76
/// virtual function call overhead.  Defining and using an InstVisitor is just
77
/// as efficient as having your own switch statement over the instruction
78
/// opcode.
79
template<typename SubClass, typename RetTy=void>
80
class InstVisitor {
81
  //===--------------------------------------------------------------------===//
82
  // Interface code - This is the public interface of the InstVisitor that you
83
  // use to visit instructions...
84
  //
85
86
public:
87
  // Generic visit method - Allow visitation to all instructions in a range
88
  template<class Iterator>
89
14.2M
  void visit(Iterator Start, Iterator End) {
90
85.5M
    while (Start != End)
91
71.3M
      static_cast<SubClass*>(this)->visit(*Start++);
92
14.2M
  }
AMDGPUAnnotateUniformValues.cpp:void llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>)
Line
Count
Source
89
25.6k
  void visit(Iterator Start, Iterator End) {
90
54.4k
    while (Start != End)
91
28.8k
      static_cast<SubClass*>(this)->visit(*Start++);
92
25.6k
  }
AMDGPUAnnotateUniformValues.cpp:void llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>)
Line
Count
Source
89
28.8k
  void visit(Iterator Start, Iterator End) {
90
369k
    while (Start != End)
91
340k
      static_cast<SubClass*>(this)->visit(*Start++);
92
28.8k
  }
AMDGPUAtomicOptimizer.cpp:void llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>)
Line
Count
Source
89
189
  void visit(Iterator Start, Iterator End) {
90
390
    while (Start != End)
91
201
      static_cast<SubClass*>(this)->visit(*Start++);
92
189
  }
AMDGPUAtomicOptimizer.cpp:void llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>)
Line
Count
Source
89
201
  void visit(Iterator Start, Iterator End) {
90
2.25k
    while (Start != End)
91
2.05k
      static_cast<SubClass*>(this)->visit(*Start++);
92
201
  }
AMDGPUFixFunctionBitcasts.cpp:void llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Function, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Function, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Function, false, false, void>, false, false>)
Line
Count
Source
89
2.70k
  void visit(Iterator Start, Iterator End) {
90
35.6k
    while (Start != End)
91
32.9k
      static_cast<SubClass*>(this)->visit(*Start++);
92
2.70k
  }
AMDGPUFixFunctionBitcasts.cpp:void llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>)
Line
Count
Source
89
32.9k
  void visit(Iterator Start, Iterator End) {
90
63.4k
    while (Start != End)
91
30.5k
      static_cast<SubClass*>(this)->visit(*Start++);
92
32.9k
  }
AMDGPUFixFunctionBitcasts.cpp:void llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>)
Line
Count
Source
89
30.5k
  void visit(Iterator Start, Iterator End) {
90
197k
    while (Start != End)
91
166k
      static_cast<SubClass*>(this)->visit(*Start++);
92
30.5k
  }
WebAssemblyOptimizeReturned.cpp:void llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>)
Line
Count
Source
89
4.36k
  void visit(Iterator Start, Iterator End) {
90
9.33k
    while (Start != End)
91
4.96k
      static_cast<SubClass*>(this)->visit(*Start++);
92
4.36k
  }
WebAssemblyOptimizeReturned.cpp:void llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>)
Line
Count
Source
89
4.96k
  void visit(Iterator Start, Iterator End) {
90
18.7k
    while (Start != End)
91
13.7k
      static_cast<SubClass*>(this)->visit(*Start++);
92
4.96k
  }
void llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>)
Line
Count
Source
89
1.19k
  void visit(Iterator Start, Iterator End) {
90
3.09k
    while (Start != End)
91
1.90k
      static_cast<SubClass*>(this)->visit(*Start++);
92
1.19k
  }
void llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>)
Line
Count
Source
89
1.90k
  void visit(Iterator Start, Iterator End) {
90
6.42k
    while (Start != End)
91
4.52k
      static_cast<SubClass*>(this)->visit(*Start++);
92
1.90k
  }
Unexecuted instantiation: InstCount.cpp:void llvm::InstVisitor<(anonymous namespace)::InstCount, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>)
Unexecuted instantiation: InstCount.cpp:void llvm::InstVisitor<(anonymous namespace)::InstCount, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>)
Lint.cpp:void llvm::InstVisitor<(anonymous namespace)::Lint, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>)
Line
Count
Source
89
41
  void visit(Iterator Start, Iterator End) {
90
108
    while (Start != End)
91
67
      static_cast<SubClass*>(this)->visit(*Start++);
92
41
  }
Lint.cpp:void llvm::InstVisitor<(anonymous namespace)::Lint, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>)
Line
Count
Source
89
67
  void visit(Iterator Start, Iterator End) {
90
292
    while (Start != End)
91
225
      static_cast<SubClass*>(this)->visit(*Start++);
92
67
  }
Verifier.cpp:void llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>)
Line
Count
Source
89
1.28M
  void visit(Iterator Start, Iterator End) {
90
2.65M
    while (Start != End)
91
1.36M
      static_cast<SubClass*>(this)->visit(*Start++);
92
1.28M
  }
Verifier.cpp:void llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>)
Line
Count
Source
89
1.36M
  void visit(Iterator Start, Iterator End) {
90
8.60M
    while (Start != End)
91
7.23M
      static_cast<SubClass*>(this)->visit(*Start++);
92
1.36M
  }
AddressSanitizer.cpp:void llvm::InstVisitor<(anonymous namespace)::FunctionStackPoisoner, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>)
Line
Count
Source
89
1.91k
  void visit(Iterator Start, Iterator End) {
90
11.0k
    while (Start != End)
91
9.18k
      static_cast<SubClass*>(this)->visit(*Start++);
92
1.91k
  }
MemorySanitizer.cpp:void llvm::InstVisitor<(anonymous namespace)::MemorySanitizerVisitor, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>)
Line
Count
Source
89
1.05k
  void visit(Iterator Start, Iterator End) {
90
4.44k
    while (Start != End)
91
3.39k
      static_cast<SubClass*>(this)->visit(*Start++);
92
1.05k
  }
PGOInstrumentation.cpp:void llvm::InstVisitor<(anonymous namespace)::SelectInstVisitor, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>)
Line
Count
Source
89
371
  void visit(Iterator Start, Iterator End) {
90
1.90k
    while (Start != End)
91
1.53k
      static_cast<SubClass*>(this)->visit(*Start++);
92
371
  }
PGOInstrumentation.cpp:void llvm::InstVisitor<(anonymous namespace)::SelectInstVisitor, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>)
Line
Count
Source
89
1.53k
  void visit(Iterator Start, Iterator End) {
90
5.51k
    while (Start != End)
91
3.97k
      static_cast<SubClass*>(this)->visit(*Start++);
92
1.53k
  }
PGOInstrumentation.cpp:void llvm::InstVisitor<(anonymous namespace)::MemIntrinsicVisitor, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>)
Line
Count
Source
89
497
  void visit(Iterator Start, Iterator End) {
90
2.43k
    while (Start != End)
91
1.93k
      static_cast<SubClass*>(this)->visit(*Start++);
92
497
  }
PGOInstrumentation.cpp:void llvm::InstVisitor<(anonymous namespace)::MemIntrinsicVisitor, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>)
Line
Count
Source
89
1.93k
  void visit(Iterator Start, Iterator End) {
90
7.03k
    while (Start != End)
91
5.10k
      static_cast<SubClass*>(this)->visit(*Start++);
92
1.93k
  }
PGOMemOPSizeOpt.cpp:void llvm::InstVisitor<(anonymous namespace)::MemOPSizeOpt, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>)
Line
Count
Source
89
462k
  void visit(Iterator Start, Iterator End) {
90
3.06M
    while (Start != End)
91
2.60M
      static_cast<SubClass*>(this)->visit(*Start++);
92
462k
  }
PGOMemOPSizeOpt.cpp:void llvm::InstVisitor<(anonymous namespace)::MemOPSizeOpt, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>)
Line
Count
Source
89
2.60M
  void visit(Iterator Start, Iterator End) {
90
16.7M
    while (Start != End)
91
14.1M
      static_cast<SubClass*>(this)->visit(*Start++);
92
2.60M
  }
SCCP.cpp:void llvm::InstVisitor<(anonymous namespace)::SCCPSolver, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>)
Line
Count
Source
89
5.31M
  void visit(Iterator Start, Iterator End) {
90
33.8M
    while (Start != End)
91
28.5M
      static_cast<SubClass*>(this)->visit(*Start++);
92
5.31M
  }
LibCallsShrinkWrap.cpp:void llvm::InstVisitor<(anonymous namespace)::LibCallsShrinkWrap, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void>, false, false>)
Line
Count
Source
89
463k
  void visit(Iterator Start, Iterator End) {
90
3.07M
    while (Start != End)
91
2.60M
      static_cast<SubClass*>(this)->visit(*Start++);
92
463k
  }
LibCallsShrinkWrap.cpp:void llvm::InstVisitor<(anonymous namespace)::LibCallsShrinkWrap, void>::visit<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false> >(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>)
Line
Count
Source
89
2.60M
  void visit(Iterator Start, Iterator End) {
90
16.7M
    while (Start != End)
91
14.1M
      static_cast<SubClass*>(this)->visit(*Start++);
92
2.60M
  }
93
94
  // Define visitors for functions and basic blocks...
95
  //
96
2.70k
  void visit(Module &M) {
97
2.70k
    static_cast<SubClass*>(this)->visitModule(M);
98
2.70k
    visit(M.begin(), M.end());
99
2.70k
  }
100
2.27M
  void visit(Function &F) {
101
2.27M
    static_cast<SubClass*>(this)->visitFunction(F);
102
2.27M
    visit(F.begin(), F.end());
103
2.27M
  }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visit(llvm::Function&)
Line
Count
Source
100
25.6k
  void visit(Function &F) {
101
25.6k
    static_cast<SubClass*>(this)->visitFunction(F);
102
25.6k
    visit(F.begin(), F.end());
103
25.6k
  }
AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visit(llvm::Function&)
Line
Count
Source
100
189
  void visit(Function &F) {
101
189
    static_cast<SubClass*>(this)->visitFunction(F);
102
189
    visit(F.begin(), F.end());
103
189
  }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visit(llvm::Function&)
Line
Count
Source
100
32.9k
  void visit(Function &F) {
101
32.9k
    static_cast<SubClass*>(this)->visitFunction(F);
102
32.9k
    visit(F.begin(), F.end());
103
32.9k
  }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visit(llvm::Function&)
Line
Count
Source
100
4.36k
  void visit(Function &F) {
101
4.36k
    static_cast<SubClass*>(this)->visitFunction(F);
102
4.36k
    visit(F.begin(), F.end());
103
4.36k
  }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visit(llvm::Function&)
Line
Count
Source
100
1.19k
  void visit(Function &F) {
101
1.19k
    static_cast<SubClass*>(this)->visitFunction(F);
102
1.19k
    visit(F.begin(), F.end());
103
1.19k
  }
Unexecuted instantiation: InstCount.cpp:llvm::InstVisitor<(anonymous namespace)::InstCount, void>::visit(llvm::Function&)
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visit(llvm::Function&)
Line
Count
Source
100
41
  void visit(Function &F) {
101
41
    static_cast<SubClass*>(this)->visitFunction(F);
102
41
    visit(F.begin(), F.end());
103
41
  }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visit(llvm::Function&)
Line
Count
Source
100
1.28M
  void visit(Function &F) {
101
1.28M
    static_cast<SubClass*>(this)->visitFunction(F);
102
1.28M
    visit(F.begin(), F.end());
103
1.28M
  }
PGOInstrumentation.cpp:llvm::InstVisitor<(anonymous namespace)::SelectInstVisitor, void>::visit(llvm::Function&)
Line
Count
Source
100
371
  void visit(Function &F) {
101
371
    static_cast<SubClass*>(this)->visitFunction(F);
102
371
    visit(F.begin(), F.end());
103
371
  }
PGOInstrumentation.cpp:llvm::InstVisitor<(anonymous namespace)::MemIntrinsicVisitor, void>::visit(llvm::Function&)
Line
Count
Source
100
497
  void visit(Function &F) {
101
497
    static_cast<SubClass*>(this)->visitFunction(F);
102
497
    visit(F.begin(), F.end());
103
497
  }
PGOMemOPSizeOpt.cpp:llvm::InstVisitor<(anonymous namespace)::MemOPSizeOpt, void>::visit(llvm::Function&)
Line
Count
Source
100
462k
  void visit(Function &F) {
101
462k
    static_cast<SubClass*>(this)->visitFunction(F);
102
462k
    visit(F.begin(), F.end());
103
462k
  }
LibCallsShrinkWrap.cpp:llvm::InstVisitor<(anonymous namespace)::LibCallsShrinkWrap, void>::visit(llvm::Function&)
Line
Count
Source
100
463k
  void visit(Function &F) {
101
463k
    static_cast<SubClass*>(this)->visitFunction(F);
102
463k
    visit(F.begin(), F.end());
103
463k
  }
104
11.9M
  void visit(BasicBlock &BB) {
105
11.9M
    static_cast<SubClass*>(this)->visitBasicBlock(BB);
106
11.9M
    visit(BB.begin(), BB.end());
107
11.9M
  }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visit(llvm::BasicBlock&)
Line
Count
Source
104
28.8k
  void visit(BasicBlock &BB) {
105
28.8k
    static_cast<SubClass*>(this)->visitBasicBlock(BB);
106
28.8k
    visit(BB.begin(), BB.end());
107
28.8k
  }
AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visit(llvm::BasicBlock&)
Line
Count
Source
104
201
  void visit(BasicBlock &BB) {
105
201
    static_cast<SubClass*>(this)->visitBasicBlock(BB);
106
201
    visit(BB.begin(), BB.end());
107
201
  }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visit(llvm::BasicBlock&)
Line
Count
Source
104
30.5k
  void visit(BasicBlock &BB) {
105
30.5k
    static_cast<SubClass*>(this)->visitBasicBlock(BB);
106
30.5k
    visit(BB.begin(), BB.end());
107
30.5k
  }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visit(llvm::BasicBlock&)
Line
Count
Source
104
4.96k
  void visit(BasicBlock &BB) {
105
4.96k
    static_cast<SubClass*>(this)->visitBasicBlock(BB);
106
4.96k
    visit(BB.begin(), BB.end());
107
4.96k
  }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visit(llvm::BasicBlock&)
Line
Count
Source
104
1.90k
  void visit(BasicBlock &BB) {
105
1.90k
    static_cast<SubClass*>(this)->visitBasicBlock(BB);
106
1.90k
    visit(BB.begin(), BB.end());
107
1.90k
  }
Unexecuted instantiation: InstCount.cpp:llvm::InstVisitor<(anonymous namespace)::InstCount, void>::visit(llvm::BasicBlock&)
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visit(llvm::BasicBlock&)
Line
Count
Source
104
67
  void visit(BasicBlock &BB) {
105
67
    static_cast<SubClass*>(this)->visitBasicBlock(BB);
106
67
    visit(BB.begin(), BB.end());
107
67
  }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visit(llvm::BasicBlock&)
Line
Count
Source
104
1.36M
  void visit(BasicBlock &BB) {
105
1.36M
    static_cast<SubClass*>(this)->visitBasicBlock(BB);
106
1.36M
    visit(BB.begin(), BB.end());
107
1.36M
  }
AddressSanitizer.cpp:llvm::InstVisitor<(anonymous namespace)::FunctionStackPoisoner, void>::visit(llvm::BasicBlock&)
Line
Count
Source
104
1.91k
  void visit(BasicBlock &BB) {
105
1.91k
    static_cast<SubClass*>(this)->visitBasicBlock(BB);
106
1.91k
    visit(BB.begin(), BB.end());
107
1.91k
  }
MemorySanitizer.cpp:llvm::InstVisitor<(anonymous namespace)::MemorySanitizerVisitor, void>::visit(llvm::BasicBlock&)
Line
Count
Source
104
1.05k
  void visit(BasicBlock &BB) {
105
1.05k
    static_cast<SubClass*>(this)->visitBasicBlock(BB);
106
1.05k
    visit(BB.begin(), BB.end());
107
1.05k
  }
PGOInstrumentation.cpp:llvm::InstVisitor<(anonymous namespace)::SelectInstVisitor, void>::visit(llvm::BasicBlock&)
Line
Count
Source
104
1.53k
  void visit(BasicBlock &BB) {
105
1.53k
    static_cast<SubClass*>(this)->visitBasicBlock(BB);
106
1.53k
    visit(BB.begin(), BB.end());
107
1.53k
  }
PGOInstrumentation.cpp:llvm::InstVisitor<(anonymous namespace)::MemIntrinsicVisitor, void>::visit(llvm::BasicBlock&)
Line
Count
Source
104
1.93k
  void visit(BasicBlock &BB) {
105
1.93k
    static_cast<SubClass*>(this)->visitBasicBlock(BB);
106
1.93k
    visit(BB.begin(), BB.end());
107
1.93k
  }
PGOMemOPSizeOpt.cpp:llvm::InstVisitor<(anonymous namespace)::MemOPSizeOpt, void>::visit(llvm::BasicBlock&)
Line
Count
Source
104
2.60M
  void visit(BasicBlock &BB) {
105
2.60M
    static_cast<SubClass*>(this)->visitBasicBlock(BB);
106
2.60M
    visit(BB.begin(), BB.end());
107
2.60M
  }
SCCP.cpp:llvm::InstVisitor<(anonymous namespace)::SCCPSolver, void>::visit(llvm::BasicBlock&)
Line
Count
Source
104
5.31M
  void visit(BasicBlock &BB) {
105
5.31M
    static_cast<SubClass*>(this)->visitBasicBlock(BB);
106
5.31M
    visit(BB.begin(), BB.end());
107
5.31M
  }
LibCallsShrinkWrap.cpp:llvm::InstVisitor<(anonymous namespace)::LibCallsShrinkWrap, void>::visit(llvm::BasicBlock&)
Line
Count
Source
104
2.60M
  void visit(BasicBlock &BB) {
105
2.60M
    static_cast<SubClass*>(this)->visitBasicBlock(BB);
106
2.60M
    visit(BB.begin(), BB.end());
107
2.60M
  }
108
109
  // Forwarding functions so that the user can visit with pointers AND refs.
110
  void visit(Module       *M)  { visit(*M); }
111
  void visit(Function     *F)  { visit(*F); }
112
5.31M
  void visit(BasicBlock   *BB) { visit(*BB); }
113
47.1M
  RetTy visit(Instruction *I)  { return visit(*I); }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visit(llvm::Instruction*)
Line
Count
Source
113
30.0M
  RetTy visit(Instruction *I)  { return visit(*I); }
DataFlowSanitizer.cpp:llvm::InstVisitor<(anonymous namespace)::DFSanVisitor, void>::visit(llvm::Instruction*)
Line
Count
Source
113
1.19k
  RetTy visit(Instruction *I)  { return visit(*I); }
llvm::InstVisitor<llvm::sroa::AllocaSliceRewriter, bool>::visit(llvm::Instruction*)
Line
Count
Source
113
3.91M
  RetTy visit(Instruction *I)  { return visit(*I); }
SROA.cpp:llvm::InstVisitor<(anonymous namespace)::AggLoadStoreRewriter, bool>::visit(llvm::Instruction*)
Line
Count
Source
113
7.48M
  RetTy visit(Instruction *I)  { return visit(*I); }
llvm::InstVisitor<llvm::sroa::AllocaSlices::SliceBuilder, void>::visit(llvm::Instruction*)
Line
Count
Source
113
5.73M
  RetTy visit(Instruction *I)  { return visit(*I); }
Scalarizer.cpp:llvm::InstVisitor<(anonymous namespace)::ScalarizerVisitor, bool>::visit(llvm::Instruction*)
Line
Count
Source
113
422
  RetTy visit(Instruction *I)  { return visit(*I); }
114
115
  // visit - Finally, code to visit an instruction...
116
  //
117
319M
  RetTy visit(Instruction &I) {
118
319M
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
319M
                  "Must pass the derived type to this template!");
120
319M
121
319M
    switch (I.getOpcode()) {
122
319M
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
319M
      // Build the switch statement using the Instruction.def file...
124
319M
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
319M
    case Instruction::OPCODE: return \
126
319M
           static_cast<SubClass*>(this)-> \
127
319M
                      visit##OPCODE(static_cast<CLASS&>(I));
128
319M
#include 
"llvm/IR/Instruction.def"8.16M
129
319M
    }
130
319M
  }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visit(llvm::Instruction&)
Line
Count
Source
117
340k
  RetTy visit(Instruction &I) {
118
340k
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
340k
                  "Must pass the derived type to this template!");
120
340k
121
340k
    switch (I.getOpcode()) {
122
340k
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
340k
      // Build the switch statement using the Instruction.def file...
124
340k
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
340k
    case Instruction::OPCODE: return \
126
340k
           static_cast<SubClass*>(this)-> \
127
340k
                      visit##OPCODE(static_cast<CLASS&>(I));
128
340k
#include 
"llvm/IR/Instruction.def"25.6k
129
340k
    }
130
340k
  }
AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visit(llvm::Instruction&)
Line
Count
Source
117
2.05k
  RetTy visit(Instruction &I) {
118
2.05k
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
2.05k
                  "Must pass the derived type to this template!");
120
2.05k
121
2.05k
    switch (I.getOpcode()) {
122
2.05k
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
2.05k
      // Build the switch statement using the Instruction.def file...
124
2.05k
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
2.05k
    case Instruction::OPCODE: return \
126
2.05k
           static_cast<SubClass*>(this)-> \
127
2.05k
                      visit##OPCODE(static_cast<CLASS&>(I));
128
2.05k
#include 
"llvm/IR/Instruction.def"195
129
2.05k
    }
130
2.05k
  }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visit(llvm::Instruction&)
Line
Count
Source
117
155k
  RetTy visit(Instruction &I) {
118
155k
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
155k
                  "Must pass the derived type to this template!");
120
155k
121
155k
    switch (I.getOpcode()) {
122
155k
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
155k
      // Build the switch statement using the Instruction.def file...
124
155k
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
155k
    case Instruction::OPCODE: return \
126
155k
           static_cast<SubClass*>(this)-> \
127
155k
                      visit##OPCODE(static_cast<CLASS&>(I));
128
155k
#include 
"llvm/IR/Instruction.def"25.5k
129
155k
    }
130
155k
  }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visit(llvm::Instruction&)
Line
Count
Source
117
166k
  RetTy visit(Instruction &I) {
118
166k
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
166k
                  "Must pass the derived type to this template!");
120
166k
121
166k
    switch (I.getOpcode()) {
122
166k
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
166k
      // Build the switch statement using the Instruction.def file...
124
166k
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
166k
    case Instruction::OPCODE: return \
126
166k
           static_cast<SubClass*>(this)-> \
127
166k
                      visit##OPCODE(static_cast<CLASS&>(I));
128
166k
#include 
"llvm/IR/Instruction.def"27.5k
129
166k
    }
130
166k
  }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visit(llvm::Instruction&)
Line
Count
Source
117
13.7k
  RetTy visit(Instruction &I) {
118
13.7k
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
13.7k
                  "Must pass the derived type to this template!");
120
13.7k
121
13.7k
    switch (I.getOpcode()) {
122
13.7k
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
13.7k
      // Build the switch statement using the Instruction.def file...
124
13.7k
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
13.7k
    case Instruction::OPCODE: return \
126
13.7k
           static_cast<SubClass*>(this)-> \
127
13.7k
                      visit##OPCODE(static_cast<CLASS&>(I));
128
13.7k
#include 
"llvm/IR/Instruction.def"4.36k
129
13.7k
    }
130
13.7k
  }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visit(llvm::Instruction&)
Line
Count
Source
117
475
  RetTy visit(Instruction &I) {
118
475
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
475
                  "Must pass the derived type to this template!");
120
475
121
475
    switch (I.getOpcode()) {
122
475
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
475
      // Build the switch statement using the Instruction.def file...
124
475
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
475
    case Instruction::OPCODE: return \
126
475
           static_cast<SubClass*>(this)-> \
127
475
                      visit##OPCODE(static_cast<CLASS&>(I));
128
475
#include 
"llvm/IR/Instruction.def"95
129
475
    }
130
475
  }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visit(llvm::Instruction&)
Line
Count
Source
117
579
  RetTy visit(Instruction &I) {
118
579
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
579
                  "Must pass the derived type to this template!");
120
579
121
579
    switch (I.getOpcode()) {
122
579
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
579
      // Build the switch statement using the Instruction.def file...
124
579
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
579
    case Instruction::OPCODE: return \
126
579
           static_cast<SubClass*>(this)-> \
127
579
                      visit##OPCODE(static_cast<CLASS&>(I));
128
579
#include 
"llvm/IR/Instruction.def"116
129
579
    }
130
579
  }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visit(llvm::Instruction&)
Line
Count
Source
117
4.51k
  RetTy visit(Instruction &I) {
118
4.51k
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
4.51k
                  "Must pass the derived type to this template!");
120
4.51k
121
4.51k
    switch (I.getOpcode()) {
122
4.51k
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
4.51k
      // Build the switch statement using the Instruction.def file...
124
4.51k
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
4.51k
    case Instruction::OPCODE: return \
126
4.51k
           static_cast<SubClass*>(this)-> \
127
4.51k
                      visit##OPCODE(static_cast<CLASS&>(I));
128
4.51k
#include 
"llvm/IR/Instruction.def"1.19k
129
4.51k
    }
130
4.51k
  }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visit(llvm::Instruction&)
Line
Count
Source
117
30.0M
  RetTy visit(Instruction &I) {
118
30.0M
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
30.0M
                  "Must pass the derived type to this template!");
120
30.0M
121
30.0M
    switch (I.getOpcode()) {
122
30.0M
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
30.0M
      // Build the switch statement using the Instruction.def file...
124
30.0M
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
30.0M
    case Instruction::OPCODE: return \
126
30.0M
           static_cast<SubClass*>(this)-> \
127
30.0M
                      visit##OPCODE(static_cast<CLASS&>(I));
128
30.0M
#include 
"llvm/IR/Instruction.def"766k
129
30.0M
    }
130
30.0M
  }
Unexecuted instantiation: InstCount.cpp:llvm::InstVisitor<(anonymous namespace)::InstCount, void>::visit(llvm::Instruction&)
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visit(llvm::Instruction&)
Line
Count
Source
117
225
  RetTy visit(Instruction &I) {
118
225
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
225
                  "Must pass the derived type to this template!");
120
225
121
225
    switch (I.getOpcode()) {
122
225
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
225
      // Build the switch statement using the Instruction.def file...
124
225
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
225
    case Instruction::OPCODE: return \
126
225
           static_cast<SubClass*>(this)-> \
127
225
                      visit##OPCODE(static_cast<CLASS&>(I));
128
225
#include 
"llvm/IR/Instruction.def"38
129
225
    }
130
225
  }
llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visit(llvm::Instruction&)
Line
Count
Source
117
12.6M
  RetTy visit(Instruction &I) {
118
12.6M
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
12.6M
                  "Must pass the derived type to this template!");
120
12.6M
121
12.6M
    switch (I.getOpcode()) {
122
12.6M
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
12.6M
      // Build the switch statement using the Instruction.def file...
124
12.6M
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
12.6M
    case Instruction::OPCODE: return \
126
12.6M
           static_cast<SubClass*>(this)-> \
127
12.6M
                      visit##OPCODE(static_cast<CLASS&>(I));
128
12.6M
#include 
"llvm/IR/Instruction.def"0
129
12.6M
    }
130
12.6M
  }
llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visit(llvm::Instruction&)
Line
Count
Source
117
31
  RetTy visit(Instruction &I) {
118
31
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
31
                  "Must pass the derived type to this template!");
120
31
121
31
    switch (I.getOpcode()) {
122
31
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
31
      // Build the switch statement using the Instruction.def file...
124
31
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
31
    case Instruction::OPCODE: return \
126
31
           static_cast<SubClass*>(this)-> \
127
31
                      visit##OPCODE(static_cast<CLASS&>(I));
128
31
#include 
"llvm/IR/Instruction.def"0
129
31
    }
130
31
  }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visit(llvm::Instruction&)
Line
Count
Source
117
7.23M
  RetTy visit(Instruction &I) {
118
7.23M
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
7.23M
                  "Must pass the derived type to this template!");
120
7.23M
121
7.23M
    switch (I.getOpcode()) {
122
7.23M
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
7.23M
      // Build the switch statement using the Instruction.def file...
124
7.23M
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
7.23M
    case Instruction::OPCODE: return \
126
7.23M
           static_cast<SubClass*>(this)-> \
127
7.23M
                      visit##OPCODE(static_cast<CLASS&>(I));
128
7.23M
#include 
"llvm/IR/Instruction.def"958k
129
7.23M
    }
130
7.23M
  }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visit(llvm::Instruction&)
Line
Count
Source
117
165M
  RetTy visit(Instruction &I) {
118
165M
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
165M
                  "Must pass the derived type to this template!");
120
165M
121
165M
    switch (I.getOpcode()) {
122
165M
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
165M
      // Build the switch statement using the Instruction.def file...
124
165M
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
165M
    case Instruction::OPCODE: return \
126
165M
           static_cast<SubClass*>(this)-> \
127
165M
                      visit##OPCODE(static_cast<CLASS&>(I));
128
165M
#include 
"llvm/IR/Instruction.def"3.73M
129
165M
    }
130
165M
  }
AddressSanitizer.cpp:llvm::InstVisitor<(anonymous namespace)::FunctionStackPoisoner, void>::visit(llvm::Instruction&)
Line
Count
Source
117
9.18k
  RetTy visit(Instruction &I) {
118
9.18k
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
9.18k
                  "Must pass the derived type to this template!");
120
9.18k
121
9.18k
    switch (I.getOpcode()) {
122
9.18k
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
9.18k
      // Build the switch statement using the Instruction.def file...
124
9.18k
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
9.18k
    case Instruction::OPCODE: return \
126
9.18k
           static_cast<SubClass*>(this)-> \
127
9.18k
                      visit##OPCODE(static_cast<CLASS&>(I));
128
9.18k
#include 
"llvm/IR/Instruction.def"752
129
9.18k
    }
130
9.18k
  }
DataFlowSanitizer.cpp:llvm::InstVisitor<(anonymous namespace)::DFSanVisitor, void>::visit(llvm::Instruction&)
Line
Count
Source
117
1.19k
  RetTy visit(Instruction &I) {
118
1.19k
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
1.19k
                  "Must pass the derived type to this template!");
120
1.19k
121
1.19k
    switch (I.getOpcode()) {
122
1.19k
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
1.19k
      // Build the switch statement using the Instruction.def file...
124
1.19k
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
1.19k
    case Instruction::OPCODE: return \
126
1.19k
           static_cast<SubClass*>(this)-> \
127
1.19k
                      visit##OPCODE(static_cast<CLASS&>(I));
128
1.19k
#include 
"llvm/IR/Instruction.def"83
129
1.19k
    }
130
1.19k
  }
MemorySanitizer.cpp:llvm::InstVisitor<(anonymous namespace)::MemorySanitizerVisitor, void>::visit(llvm::Instruction&)
Line
Count
Source
117
3.32k
  RetTy visit(Instruction &I) {
118
3.32k
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
3.32k
                  "Must pass the derived type to this template!");
120
3.32k
121
3.32k
    switch (I.getOpcode()) {
122
3.32k
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
3.32k
      // Build the switch statement using the Instruction.def file...
124
3.32k
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
3.32k
    case Instruction::OPCODE: return \
126
3.32k
           static_cast<SubClass*>(this)-> \
127
3.32k
                      visit##OPCODE(static_cast<CLASS&>(I));
128
3.32k
#include 
"llvm/IR/Instruction.def"912
129
3.32k
    }
130
3.32k
  }
PGOInstrumentation.cpp:llvm::InstVisitor<(anonymous namespace)::SelectInstVisitor, void>::visit(llvm::Instruction&)
Line
Count
Source
117
3.97k
  RetTy visit(Instruction &I) {
118
3.97k
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
3.97k
                  "Must pass the derived type to this template!");
120
3.97k
121
3.97k
    switch (I.getOpcode()) {
122
3.97k
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
3.97k
      // Build the switch statement using the Instruction.def file...
124
3.97k
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
3.97k
    case Instruction::OPCODE: return \
126
3.97k
           static_cast<SubClass*>(this)-> \
127
3.97k
                      visit##OPCODE(static_cast<CLASS&>(I));
128
3.97k
#include 
"llvm/IR/Instruction.def"367
129
3.97k
    }
130
3.97k
  }
PGOInstrumentation.cpp:llvm::InstVisitor<(anonymous namespace)::MemIntrinsicVisitor, void>::visit(llvm::Instruction&)
Line
Count
Source
117
5.10k
  RetTy visit(Instruction &I) {
118
5.10k
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
5.10k
                  "Must pass the derived type to this template!");
120
5.10k
121
5.10k
    switch (I.getOpcode()) {
122
5.10k
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
5.10k
      // Build the switch statement using the Instruction.def file...
124
5.10k
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
5.10k
    case Instruction::OPCODE: return \
126
5.10k
           static_cast<SubClass*>(this)-> \
127
5.10k
                      visit##OPCODE(static_cast<CLASS&>(I));
128
5.10k
#include 
"llvm/IR/Instruction.def"491
129
5.10k
    }
130
5.10k
  }
PGOMemOPSizeOpt.cpp:llvm::InstVisitor<(anonymous namespace)::MemOPSizeOpt, void>::visit(llvm::Instruction&)
Line
Count
Source
117
14.1M
  RetTy visit(Instruction &I) {
118
14.1M
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
14.1M
                  "Must pass the derived type to this template!");
120
14.1M
121
14.1M
    switch (I.getOpcode()) {
122
14.1M
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
14.1M
      // Build the switch statement using the Instruction.def file...
124
14.1M
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
14.1M
    case Instruction::OPCODE: return \
126
14.1M
           static_cast<SubClass*>(this)-> \
127
14.1M
                      visit##OPCODE(static_cast<CLASS&>(I));
128
14.1M
#include 
"llvm/IR/Instruction.def"462k
129
14.1M
    }
130
14.1M
  }
llvm::InstVisitor<llvm::UnrolledInstAnalyzer, bool>::visit(llvm::Instruction&)
Line
Count
Source
117
578k
  RetTy visit(Instruction &I) {
118
578k
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
578k
                  "Must pass the derived type to this template!");
120
578k
121
578k
    switch (I.getOpcode()) {
122
578k
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
578k
      // Build the switch statement using the Instruction.def file...
124
578k
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
578k
    case Instruction::OPCODE: return \
126
578k
           static_cast<SubClass*>(this)-> \
127
578k
                      visit##OPCODE(static_cast<CLASS&>(I));
128
578k
#include 
"llvm/IR/Instruction.def"0
129
578k
    }
130
578k
  }
SCCP.cpp:llvm::InstVisitor<(anonymous namespace)::SCCPSolver, void>::visit(llvm::Instruction&)
Line
Count
Source
117
57.6M
  RetTy visit(Instruction &I) {
118
57.6M
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
57.6M
                  "Must pass the derived type to this template!");
120
57.6M
121
57.6M
    switch (I.getOpcode()) {
122
57.6M
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
57.6M
      // Build the switch statement using the Instruction.def file...
124
57.6M
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
57.6M
    case Instruction::OPCODE: return \
126
57.6M
           static_cast<SubClass*>(this)-> \
127
57.6M
                      visit##OPCODE(static_cast<CLASS&>(I));
128
57.6M
#include 
"llvm/IR/Instruction.def"1.69M
129
57.6M
    }
130
57.6M
  }
llvm::InstVisitor<llvm::sroa::AllocaSliceRewriter, bool>::visit(llvm::Instruction&)
Line
Count
Source
117
3.91M
  RetTy visit(Instruction &I) {
118
3.91M
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
3.91M
                  "Must pass the derived type to this template!");
120
3.91M
121
3.91M
    switch (I.getOpcode()) {
122
3.91M
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
3.91M
      // Build the switch statement using the Instruction.def file...
124
3.91M
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
3.91M
    case Instruction::OPCODE: return \
126
3.91M
           static_cast<SubClass*>(this)-> \
127
3.91M
                      visit##OPCODE(static_cast<CLASS&>(I));
128
3.91M
#include 
"llvm/IR/Instruction.def"0
129
3.91M
    }
130
3.91M
  }
SROA.cpp:llvm::InstVisitor<(anonymous namespace)::AggLoadStoreRewriter, bool>::visit(llvm::Instruction&)
Line
Count
Source
117
7.48M
  RetTy visit(Instruction &I) {
118
7.48M
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
7.48M
                  "Must pass the derived type to this template!");
120
7.48M
121
7.48M
    switch (I.getOpcode()) {
122
7.48M
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
7.48M
      // Build the switch statement using the Instruction.def file...
124
7.48M
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
7.48M
    case Instruction::OPCODE: return \
126
7.48M
           static_cast<SubClass*>(this)-> \
127
7.48M
                      visit##OPCODE(static_cast<CLASS&>(I));
128
7.48M
#include 
"llvm/IR/Instruction.def"2
129
7.48M
    }
130
7.48M
  }
llvm::InstVisitor<llvm::sroa::AllocaSlices::SliceBuilder, void>::visit(llvm::Instruction&)
Line
Count
Source
117
5.73M
  RetTy visit(Instruction &I) {
118
5.73M
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
5.73M
                  "Must pass the derived type to this template!");
120
5.73M
121
5.73M
    switch (I.getOpcode()) {
122
5.73M
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
5.73M
      // Build the switch statement using the Instruction.def file...
124
5.73M
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
5.73M
    case Instruction::OPCODE: return \
126
5.73M
           static_cast<SubClass*>(this)-> \
127
5.73M
                      visit##OPCODE(static_cast<CLASS&>(I));
128
5.73M
#include 
"llvm/IR/Instruction.def"0
129
5.73M
    }
130
5.73M
  }
Scalarizer.cpp:llvm::InstVisitor<(anonymous namespace)::ScalarizerVisitor, bool>::visit(llvm::Instruction&)
Line
Count
Source
117
422
  RetTy visit(Instruction &I) {
118
422
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
422
                  "Must pass the derived type to this template!");
120
422
121
422
    switch (I.getOpcode()) {
122
422
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
422
      // Build the switch statement using the Instruction.def file...
124
422
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
422
    case Instruction::OPCODE: return \
126
422
           static_cast<SubClass*>(this)-> \
127
422
                      visit##OPCODE(static_cast<CLASS&>(I));
128
422
#include 
"llvm/IR/Instruction.def"90
129
422
    }
130
422
  }
LibCallsShrinkWrap.cpp:llvm::InstVisitor<(anonymous namespace)::LibCallsShrinkWrap, void>::visit(llvm::Instruction&)
Line
Count
Source
117
14.1M
  RetTy visit(Instruction &I) {
118
14.1M
    static_assert(std::is_base_of<InstVisitor, SubClass>::value,
119
14.1M
                  "Must pass the derived type to this template!");
120
14.1M
121
14.1M
    switch (I.getOpcode()) {
122
14.1M
    
default: 0
llvm_unreachable0
("Unknown instruction type encountered!");
123
14.1M
      // Build the switch statement using the Instruction.def file...
124
14.1M
#define HANDLE_INST(NUM, OPCODE, CLASS) \
125
14.1M
    case Instruction::OPCODE: return \
126
14.1M
           static_cast<SubClass*>(this)-> \
127
14.1M
                      visit##OPCODE(static_cast<CLASS&>(I));
128
14.1M
#include 
"llvm/IR/Instruction.def"463k
129
14.1M
    }
130
14.1M
  }
131
132
  //===--------------------------------------------------------------------===//
133
  // Visitation functions... these functions provide default fallbacks in case
134
  // the user does not specify what to do for a particular instruction type.
135
  // The default behavior is to generalize the instruction type to its subtype
136
  // and try visiting the subtype.  All of this should be inlined perfectly,
137
  // because there are no virtual functions to get in the way.
138
  //
139
140
  // When visiting a module, function or basic block directly, these methods get
141
  // called to indicate when transitioning into a new unit.
142
  //
143
2.70k
  void visitModule    (Module &M) {}
144
990k
  void visitFunction  (Function &F) {}
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitFunction(llvm::Function&)
Line
Count
Source
144
25.6k
  void visitFunction  (Function &F) {}
AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitFunction(llvm::Function&)
Line
Count
Source
144
189
  void visitFunction  (Function &F) {}
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitFunction(llvm::Function&)
Line
Count
Source
144
32.9k
  void visitFunction  (Function &F) {}
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitFunction(llvm::Function&)
Line
Count
Source
144
4.36k
  void visitFunction  (Function &F) {}
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitFunction(llvm::Function&)
Line
Count
Source
144
1.19k
  void visitFunction  (Function &F) {}
PGOInstrumentation.cpp:llvm::InstVisitor<(anonymous namespace)::SelectInstVisitor, void>::visitFunction(llvm::Function&)
Line
Count
Source
144
371
  void visitFunction  (Function &F) {}
PGOInstrumentation.cpp:llvm::InstVisitor<(anonymous namespace)::MemIntrinsicVisitor, void>::visitFunction(llvm::Function&)
Line
Count
Source
144
497
  void visitFunction  (Function &F) {}
PGOMemOPSizeOpt.cpp:llvm::InstVisitor<(anonymous namespace)::MemOPSizeOpt, void>::visitFunction(llvm::Function&)
Line
Count
Source
144
462k
  void visitFunction  (Function &F) {}
LibCallsShrinkWrap.cpp:llvm::InstVisitor<(anonymous namespace)::LibCallsShrinkWrap, void>::visitFunction(llvm::Function&)
Line
Count
Source
144
463k
  void visitFunction  (Function &F) {}
145
10.6M
  void visitBasicBlock(BasicBlock &BB) {}
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitBasicBlock(llvm::BasicBlock&)
Line
Count
Source
145
28.8k
  void visitBasicBlock(BasicBlock &BB) {}
AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitBasicBlock(llvm::BasicBlock&)
Line
Count
Source
145
201
  void visitBasicBlock(BasicBlock &BB) {}
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitBasicBlock(llvm::BasicBlock&)
Line
Count
Source
145
30.5k
  void visitBasicBlock(BasicBlock &BB) {}
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitBasicBlock(llvm::BasicBlock&)
Line
Count
Source
145
4.96k
  void visitBasicBlock(BasicBlock &BB) {}
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitBasicBlock(llvm::BasicBlock&)
Line
Count
Source
145
1.90k
  void visitBasicBlock(BasicBlock &BB) {}
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitBasicBlock(llvm::BasicBlock&)
Line
Count
Source
145
67
  void visitBasicBlock(BasicBlock &BB) {}
AddressSanitizer.cpp:llvm::InstVisitor<(anonymous namespace)::FunctionStackPoisoner, void>::visitBasicBlock(llvm::BasicBlock&)
Line
Count
Source
145
1.91k
  void visitBasicBlock(BasicBlock &BB) {}
MemorySanitizer.cpp:llvm::InstVisitor<(anonymous namespace)::MemorySanitizerVisitor, void>::visitBasicBlock(llvm::BasicBlock&)
Line
Count
Source
145
1.05k
  void visitBasicBlock(BasicBlock &BB) {}
PGOInstrumentation.cpp:llvm::InstVisitor<(anonymous namespace)::SelectInstVisitor, void>::visitBasicBlock(llvm::BasicBlock&)
Line
Count
Source
145
1.53k
  void visitBasicBlock(BasicBlock &BB) {}
PGOInstrumentation.cpp:llvm::InstVisitor<(anonymous namespace)::MemIntrinsicVisitor, void>::visitBasicBlock(llvm::BasicBlock&)
Line
Count
Source
145
1.93k
  void visitBasicBlock(BasicBlock &BB) {}
PGOMemOPSizeOpt.cpp:llvm::InstVisitor<(anonymous namespace)::MemOPSizeOpt, void>::visitBasicBlock(llvm::BasicBlock&)
Line
Count
Source
145
2.60M
  void visitBasicBlock(BasicBlock &BB) {}
SCCP.cpp:llvm::InstVisitor<(anonymous namespace)::SCCPSolver, void>::visitBasicBlock(llvm::BasicBlock&)
Line
Count
Source
145
5.31M
  void visitBasicBlock(BasicBlock &BB) {}
LibCallsShrinkWrap.cpp:llvm::InstVisitor<(anonymous namespace)::LibCallsShrinkWrap, void>::visitBasicBlock(llvm::BasicBlock&)
Line
Count
Source
145
2.60M
  void visitBasicBlock(BasicBlock &BB) {}
146
147
  // Define instruction specific visitor functions that can be overridden to
148
  // handle SPECIFIC instructions.  These functions automatically define
149
  // visitMul to proxy to visitBinaryOperator for instance in case the user does
150
  // not need this generality.
151
  //
152
  // These functions can also implement fan-out, when a single opcode and
153
  // instruction have multiple more specific Instruction subclasses. The Call
154
  // instruction currently supports this. We implement that by redirecting that
155
  // instruction to a special delegation helper.
156
#define HANDLE_INST(NUM, OPCODE, CLASS) \
157
273M
    RetTy visit##OPCODE(CLASS &I) { \
158
273M
      if (NUM == Instruction::Call) \
159
273M
        
return delegateCallInst(I)42.8M
; \
160
273M
      else \
161
273M
        
DELEGATE230M
(CLASS); \
162
273M
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitRet(llvm::ReturnInst&)
Line
Count
Source
157
25.6k
    RetTy visit##OPCODE(CLASS &I) { \
158
25.6k
      if (NUM == Instruction::Call) \
159
25.6k
        
return delegateCallInst(I)0
; \
160
25.6k
      else \
161
25.6k
        DELEGATE(CLASS); \
162
25.6k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitBr(llvm::BranchInst&)
Line
Count
Source
157
3.15k
    RetTy visit##OPCODE(CLASS &I) { \
158
3.15k
      if (NUM == Instruction::Call) \
159
3.15k
        
return delegateCallInst(I)0
; \
160
3.15k
      else \
161
3.15k
        DELEGATE(CLASS); \
162
3.15k
    }
Unexecuted instantiation: AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitSwitch(llvm::SwitchInst&)
Unexecuted instantiation: AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitIndirectBr(llvm::IndirectBrInst&)
Unexecuted instantiation: AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitInvoke(llvm::InvokeInst&)
Unexecuted instantiation: AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitResume(llvm::ResumeInst&)
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitUnreachable(llvm::UnreachableInst&)
Line
Count
Source
157
64
    RetTy visit##OPCODE(CLASS &I) { \
158
64
      if (NUM == Instruction::Call) \
159
64
        
return delegateCallInst(I)0
; \
160
64
      else \
161
64
        DELEGATE(CLASS); \
162
64
    }
Unexecuted instantiation: AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitCleanupRet(llvm::CleanupReturnInst&)
Unexecuted instantiation: AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitCatchRet(llvm::CatchReturnInst&)
Unexecuted instantiation: AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitCatchSwitch(llvm::CatchSwitchInst&)
Unexecuted instantiation: AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitCallBr(llvm::CallBrInst&)
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitFNeg(llvm::UnaryOperator&)
Line
Count
Source
157
9
    RetTy visit##OPCODE(CLASS &I) { \
158
9
      if (NUM == Instruction::Call) \
159
9
        
return delegateCallInst(I)0
; \
160
9
      else \
161
9
        DELEGATE(CLASS); \
162
9
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitAdd(llvm::BinaryOperator&)
Line
Count
Source
157
4.70k
    RetTy visit##OPCODE(CLASS &I) { \
158
4.70k
      if (NUM == Instruction::Call) \
159
4.70k
        
return delegateCallInst(I)0
; \
160
4.70k
      else \
161
4.70k
        DELEGATE(CLASS); \
162
4.70k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitFAdd(llvm::BinaryOperator&)
Line
Count
Source
157
2.76k
    RetTy visit##OPCODE(CLASS &I) { \
158
2.76k
      if (NUM == Instruction::Call) \
159
2.76k
        
return delegateCallInst(I)0
; \
160
2.76k
      else \
161
2.76k
        DELEGATE(CLASS); \
162
2.76k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitSub(llvm::BinaryOperator&)
Line
Count
Source
157
1.17k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.17k
      if (NUM == Instruction::Call) \
159
1.17k
        
return delegateCallInst(I)0
; \
160
1.17k
      else \
161
1.17k
        DELEGATE(CLASS); \
162
1.17k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitFSub(llvm::BinaryOperator&)
Line
Count
Source
157
2.12k
    RetTy visit##OPCODE(CLASS &I) { \
158
2.12k
      if (NUM == Instruction::Call) \
159
2.12k
        
return delegateCallInst(I)0
; \
160
2.12k
      else \
161
2.12k
        DELEGATE(CLASS); \
162
2.12k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitMul(llvm::BinaryOperator&)
Line
Count
Source
157
2.42k
    RetTy visit##OPCODE(CLASS &I) { \
158
2.42k
      if (NUM == Instruction::Call) \
159
2.42k
        
return delegateCallInst(I)0
; \
160
2.42k
      else \
161
2.42k
        DELEGATE(CLASS); \
162
2.42k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitFMul(llvm::BinaryOperator&)
Line
Count
Source
157
2.27k
    RetTy visit##OPCODE(CLASS &I) { \
158
2.27k
      if (NUM == Instruction::Call) \
159
2.27k
        
return delegateCallInst(I)0
; \
160
2.27k
      else \
161
2.27k
        DELEGATE(CLASS); \
162
2.27k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitUDiv(llvm::BinaryOperator&)
Line
Count
Source
157
45
    RetTy visit##OPCODE(CLASS &I) { \
158
45
      if (NUM == Instruction::Call) \
159
45
        
return delegateCallInst(I)0
; \
160
45
      else \
161
45
        DELEGATE(CLASS); \
162
45
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitSDiv(llvm::BinaryOperator&)
Line
Count
Source
157
51
    RetTy visit##OPCODE(CLASS &I) { \
158
51
      if (NUM == Instruction::Call) \
159
51
        
return delegateCallInst(I)0
; \
160
51
      else \
161
51
        DELEGATE(CLASS); \
162
51
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitFDiv(llvm::BinaryOperator&)
Line
Count
Source
157
481
    RetTy visit##OPCODE(CLASS &I) { \
158
481
      if (NUM == Instruction::Call) \
159
481
        
return delegateCallInst(I)0
; \
160
481
      else \
161
481
        DELEGATE(CLASS); \
162
481
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitURem(llvm::BinaryOperator&)
Line
Count
Source
157
20
    RetTy visit##OPCODE(CLASS &I) { \
158
20
      if (NUM == Instruction::Call) \
159
20
        
return delegateCallInst(I)0
; \
160
20
      else \
161
20
        DELEGATE(CLASS); \
162
20
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitSRem(llvm::BinaryOperator&)
Line
Count
Source
157
36
    RetTy visit##OPCODE(CLASS &I) { \
158
36
      if (NUM == Instruction::Call) \
159
36
        
return delegateCallInst(I)0
; \
160
36
      else \
161
36
        DELEGATE(CLASS); \
162
36
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitFRem(llvm::BinaryOperator&)
Line
Count
Source
157
32
    RetTy visit##OPCODE(CLASS &I) { \
158
32
      if (NUM == Instruction::Call) \
159
32
        
return delegateCallInst(I)0
; \
160
32
      else \
161
32
        DELEGATE(CLASS); \
162
32
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitShl(llvm::BinaryOperator&)
Line
Count
Source
157
844
    RetTy visit##OPCODE(CLASS &I) { \
158
844
      if (NUM == Instruction::Call) \
159
844
        
return delegateCallInst(I)0
; \
160
844
      else \
161
844
        DELEGATE(CLASS); \
162
844
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitLShr(llvm::BinaryOperator&)
Line
Count
Source
157
1.16k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.16k
      if (NUM == Instruction::Call) \
159
1.16k
        
return delegateCallInst(I)0
; \
160
1.16k
      else \
161
1.16k
        DELEGATE(CLASS); \
162
1.16k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitAShr(llvm::BinaryOperator&)
Line
Count
Source
157
467
    RetTy visit##OPCODE(CLASS &I) { \
158
467
      if (NUM == Instruction::Call) \
159
467
        
return delegateCallInst(I)0
; \
160
467
      else \
161
467
        DELEGATE(CLASS); \
162
467
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitAnd(llvm::BinaryOperator&)
Line
Count
Source
157
952
    RetTy visit##OPCODE(CLASS &I) { \
158
952
      if (NUM == Instruction::Call) \
159
952
        
return delegateCallInst(I)0
; \
160
952
      else \
161
952
        DELEGATE(CLASS); \
162
952
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitOr(llvm::BinaryOperator&)
Line
Count
Source
157
484
    RetTy visit##OPCODE(CLASS &I) { \
158
484
      if (NUM == Instruction::Call) \
159
484
        
return delegateCallInst(I)0
; \
160
484
      else \
161
484
        DELEGATE(CLASS); \
162
484
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitXor(llvm::BinaryOperator&)
Line
Count
Source
157
1.09k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.09k
      if (NUM == Instruction::Call) \
159
1.09k
        
return delegateCallInst(I)0
; \
160
1.09k
      else \
161
1.09k
        DELEGATE(CLASS); \
162
1.09k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitAlloca(llvm::AllocaInst&)
Line
Count
Source
157
522
    RetTy visit##OPCODE(CLASS &I) { \
158
522
      if (NUM == Instruction::Call) \
159
522
        
return delegateCallInst(I)0
; \
160
522
      else \
161
522
        DELEGATE(CLASS); \
162
522
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitLoad(llvm::LoadInst&)
Line
Count
Source
157
41.7k
    RetTy visit##OPCODE(CLASS &I) { \
158
41.7k
      if (NUM == Instruction::Call) \
159
41.7k
        
return delegateCallInst(I)0
; \
160
41.7k
      else \
161
41.7k
        DELEGATE(CLASS); \
162
41.7k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitStore(llvm::StoreInst&)
Line
Count
Source
157
21.7k
    RetTy visit##OPCODE(CLASS &I) { \
158
21.7k
      if (NUM == Instruction::Call) \
159
21.7k
        
return delegateCallInst(I)0
; \
160
21.7k
      else \
161
21.7k
        DELEGATE(CLASS); \
162
21.7k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitGetElementPtr(llvm::GetElementPtrInst&)
Line
Count
Source
157
48.1k
    RetTy visit##OPCODE(CLASS &I) { \
158
48.1k
      if (NUM == Instruction::Call) \
159
48.1k
        
return delegateCallInst(I)0
; \
160
48.1k
      else \
161
48.1k
        DELEGATE(CLASS); \
162
48.1k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitFence(llvm::FenceInst&)
Line
Count
Source
157
841
    RetTy visit##OPCODE(CLASS &I) { \
158
841
      if (NUM == Instruction::Call) \
159
841
        
return delegateCallInst(I)0
; \
160
841
      else \
161
841
        DELEGATE(CLASS); \
162
841
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitAtomicCmpXchg(llvm::AtomicCmpXchgInst&)
Line
Count
Source
157
767
    RetTy visit##OPCODE(CLASS &I) { \
158
767
      if (NUM == Instruction::Call) \
159
767
        
return delegateCallInst(I)0
; \
160
767
      else \
161
767
        DELEGATE(CLASS); \
162
767
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitAtomicRMW(llvm::AtomicRMWInst&)
Line
Count
Source
157
1.76k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.76k
      if (NUM == Instruction::Call) \
159
1.76k
        
return delegateCallInst(I)0
; \
160
1.76k
      else \
161
1.76k
        DELEGATE(CLASS); \
162
1.76k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitTrunc(llvm::TruncInst&)
Line
Count
Source
157
3.30k
    RetTy visit##OPCODE(CLASS &I) { \
158
3.30k
      if (NUM == Instruction::Call) \
159
3.30k
        
return delegateCallInst(I)0
; \
160
3.30k
      else \
161
3.30k
        DELEGATE(CLASS); \
162
3.30k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitZExt(llvm::ZExtInst&)
Line
Count
Source
157
5.53k
    RetTy visit##OPCODE(CLASS &I) { \
158
5.53k
      if (NUM == Instruction::Call) \
159
5.53k
        
return delegateCallInst(I)0
; \
160
5.53k
      else \
161
5.53k
        DELEGATE(CLASS); \
162
5.53k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitSExt(llvm::SExtInst&)
Line
Count
Source
157
5.79k
    RetTy visit##OPCODE(CLASS &I) { \
158
5.79k
      if (NUM == Instruction::Call) \
159
5.79k
        
return delegateCallInst(I)0
; \
160
5.79k
      else \
161
5.79k
        DELEGATE(CLASS); \
162
5.79k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitFPToUI(llvm::FPToUIInst&)
Line
Count
Source
157
235
    RetTy visit##OPCODE(CLASS &I) { \
158
235
      if (NUM == Instruction::Call) \
159
235
        
return delegateCallInst(I)0
; \
160
235
      else \
161
235
        DELEGATE(CLASS); \
162
235
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitFPToSI(llvm::FPToSIInst&)
Line
Count
Source
157
121
    RetTy visit##OPCODE(CLASS &I) { \
158
121
      if (NUM == Instruction::Call) \
159
121
        
return delegateCallInst(I)0
; \
160
121
      else \
161
121
        DELEGATE(CLASS); \
162
121
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitUIToFP(llvm::UIToFPInst&)
Line
Count
Source
157
319
    RetTy visit##OPCODE(CLASS &I) { \
158
319
      if (NUM == Instruction::Call) \
159
319
        
return delegateCallInst(I)0
; \
160
319
      else \
161
319
        DELEGATE(CLASS); \
162
319
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitSIToFP(llvm::SIToFPInst&)
Line
Count
Source
157
135
    RetTy visit##OPCODE(CLASS &I) { \
158
135
      if (NUM == Instruction::Call) \
159
135
        
return delegateCallInst(I)0
; \
160
135
      else \
161
135
        DELEGATE(CLASS); \
162
135
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitFPTrunc(llvm::FPTruncInst&)
Line
Count
Source
157
205
    RetTy visit##OPCODE(CLASS &I) { \
158
205
      if (NUM == Instruction::Call) \
159
205
        
return delegateCallInst(I)0
; \
160
205
      else \
161
205
        DELEGATE(CLASS); \
162
205
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitFPExt(llvm::FPExtInst&)
Line
Count
Source
157
909
    RetTy visit##OPCODE(CLASS &I) { \
158
909
      if (NUM == Instruction::Call) \
159
909
        
return delegateCallInst(I)0
; \
160
909
      else \
161
909
        DELEGATE(CLASS); \
162
909
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitPtrToInt(llvm::PtrToIntInst&)
Line
Count
Source
157
35
    RetTy visit##OPCODE(CLASS &I) { \
158
35
      if (NUM == Instruction::Call) \
159
35
        
return delegateCallInst(I)0
; \
160
35
      else \
161
35
        DELEGATE(CLASS); \
162
35
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitIntToPtr(llvm::IntToPtrInst&)
Line
Count
Source
157
17.6k
    RetTy visit##OPCODE(CLASS &I) { \
158
17.6k
      if (NUM == Instruction::Call) \
159
17.6k
        
return delegateCallInst(I)0
; \
160
17.6k
      else \
161
17.6k
        DELEGATE(CLASS); \
162
17.6k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitBitCast(llvm::BitCastInst&)
Line
Count
Source
157
54.3k
    RetTy visit##OPCODE(CLASS &I) { \
158
54.3k
      if (NUM == Instruction::Call) \
159
54.3k
        
return delegateCallInst(I)0
; \
160
54.3k
      else \
161
54.3k
        DELEGATE(CLASS); \
162
54.3k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitAddrSpaceCast(llvm::AddrSpaceCastInst&)
Line
Count
Source
157
94
    RetTy visit##OPCODE(CLASS &I) { \
158
94
      if (NUM == Instruction::Call) \
159
94
        
return delegateCallInst(I)0
; \
160
94
      else \
161
94
        DELEGATE(CLASS); \
162
94
    }
Unexecuted instantiation: AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitCleanupPad(llvm::CleanupPadInst&)
Unexecuted instantiation: AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitCatchPad(llvm::CatchPadInst&)
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitICmp(llvm::ICmpInst&)
Line
Count
Source
157
3.88k
    RetTy visit##OPCODE(CLASS &I) { \
158
3.88k
      if (NUM == Instruction::Call) \
159
3.88k
        
return delegateCallInst(I)0
; \
160
3.88k
      else \
161
3.88k
        DELEGATE(CLASS); \
162
3.88k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitFCmp(llvm::FCmpInst&)
Line
Count
Source
157
981
    RetTy visit##OPCODE(CLASS &I) { \
158
981
      if (NUM == Instruction::Call) \
159
981
        
return delegateCallInst(I)0
; \
160
981
      else \
161
981
        DELEGATE(CLASS); \
162
981
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitPHI(llvm::PHINode&)
Line
Count
Source
157
3.42k
    RetTy visit##OPCODE(CLASS &I) { \
158
3.42k
      if (NUM == Instruction::Call) \
159
3.42k
        
return delegateCallInst(I)0
; \
160
3.42k
      else \
161
3.42k
        DELEGATE(CLASS); \
162
3.42k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitCall(llvm::CallInst&)
Line
Count
Source
157
38.5k
    RetTy visit##OPCODE(CLASS &I) { \
158
38.5k
      if (NUM == Instruction::Call) \
159
38.5k
        return delegateCallInst(I); \
160
38.5k
      else \
161
38.5k
        
DELEGATE0
(CLASS); \
162
38.5k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitSelect(llvm::SelectInst&)
Line
Count
Source
157
3.51k
    RetTy visit##OPCODE(CLASS &I) { \
158
3.51k
      if (NUM == Instruction::Call) \
159
3.51k
        
return delegateCallInst(I)0
; \
160
3.51k
      else \
161
3.51k
        DELEGATE(CLASS); \
162
3.51k
    }
Unexecuted instantiation: AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitUserOp1(llvm::Instruction&)
Unexecuted instantiation: AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitUserOp2(llvm::Instruction&)
Unexecuted instantiation: AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitVAArg(llvm::VAArgInst&)
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitExtractElement(llvm::ExtractElementInst&)
Line
Count
Source
157
30.8k
    RetTy visit##OPCODE(CLASS &I) { \
158
30.8k
      if (NUM == Instruction::Call) \
159
30.8k
        
return delegateCallInst(I)0
; \
160
30.8k
      else \
161
30.8k
        DELEGATE(CLASS); \
162
30.8k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitInsertElement(llvm::InsertElementInst&)
Line
Count
Source
157
3.46k
    RetTy visit##OPCODE(CLASS &I) { \
158
3.46k
      if (NUM == Instruction::Call) \
159
3.46k
        
return delegateCallInst(I)0
; \
160
3.46k
      else \
161
3.46k
        DELEGATE(CLASS); \
162
3.46k
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitShuffleVector(llvm::ShuffleVectorInst&)
Line
Count
Source
157
445
    RetTy visit##OPCODE(CLASS &I) { \
158
445
      if (NUM == Instruction::Call) \
159
445
        
return delegateCallInst(I)0
; \
160
445
      else \
161
445
        DELEGATE(CLASS); \
162
445
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitExtractValue(llvm::ExtractValueInst&)
Line
Count
Source
157
948
    RetTy visit##OPCODE(CLASS &I) { \
158
948
      if (NUM == Instruction::Call) \
159
948
        
return delegateCallInst(I)0
; \
160
948
      else \
161
948
        DELEGATE(CLASS); \
162
948
    }
AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitInsertValue(llvm::InsertValueInst&)
Line
Count
Source
157
461
    RetTy visit##OPCODE(CLASS &I) { \
158
461
      if (NUM == Instruction::Call) \
159
461
        
return delegateCallInst(I)0
; \
160
461
      else \
161
461
        DELEGATE(CLASS); \
162
461
    }
Unexecuted instantiation: AMDGPUAnnotateUniformValues.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAnnotateUniformValues, void>::visitLandingPad(llvm::LandingPadInst&)
AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitRet(llvm::ReturnInst&)
Line
Count
Source
157
195
    RetTy visit##OPCODE(CLASS &I) { \
158
195
      if (NUM == Instruction::Call) \
159
195
        
return delegateCallInst(I)0
; \
160
195
      else \
161
195
        DELEGATE(CLASS); \
162
195
    }
AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitBr(llvm::BranchInst&)
Line
Count
Source
157
6
    RetTy visit##OPCODE(CLASS &I) { \
158
6
      if (NUM == Instruction::Call) \
159
6
        
return delegateCallInst(I)0
; \
160
6
      else \
161
6
        DELEGATE(CLASS); \
162
6
    }
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitSwitch(llvm::SwitchInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitIndirectBr(llvm::IndirectBrInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitInvoke(llvm::InvokeInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitResume(llvm::ResumeInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitUnreachable(llvm::UnreachableInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitCleanupRet(llvm::CleanupReturnInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitCatchRet(llvm::CatchReturnInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitCatchSwitch(llvm::CatchSwitchInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitCallBr(llvm::CallBrInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitFNeg(llvm::UnaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitAdd(llvm::BinaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitFAdd(llvm::BinaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitSub(llvm::BinaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitFSub(llvm::BinaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitMul(llvm::BinaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitFMul(llvm::BinaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitUDiv(llvm::BinaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitSDiv(llvm::BinaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitFDiv(llvm::BinaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitURem(llvm::BinaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitSRem(llvm::BinaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitFRem(llvm::BinaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitShl(llvm::BinaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitLShr(llvm::BinaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitAShr(llvm::BinaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitAnd(llvm::BinaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitOr(llvm::BinaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitXor(llvm::BinaryOperator&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitAlloca(llvm::AllocaInst&)
AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitLoad(llvm::LoadInst&)
Line
Count
Source
157
291
    RetTy visit##OPCODE(CLASS &I) { \
158
291
      if (NUM == Instruction::Call) \
159
291
        
return delegateCallInst(I)0
; \
160
291
      else \
161
291
        DELEGATE(CLASS); \
162
291
    }
AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitStore(llvm::StoreInst&)
Line
Count
Source
157
183
    RetTy visit##OPCODE(CLASS &I) { \
158
183
      if (NUM == Instruction::Call) \
159
183
        
return delegateCallInst(I)0
; \
160
183
      else \
161
183
        DELEGATE(CLASS); \
162
183
    }
AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitGetElementPtr(llvm::GetElementPtrInst&)
Line
Count
Source
157
339
    RetTy visit##OPCODE(CLASS &I) { \
158
339
      if (NUM == Instruction::Call) \
159
339
        
return delegateCallInst(I)0
; \
160
339
      else \
161
339
        DELEGATE(CLASS); \
162
339
    }
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitFence(llvm::FenceInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitAtomicCmpXchg(llvm::AtomicCmpXchgInst&)
AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitAtomicRMW(llvm::AtomicRMWInst&)
Line
Count
Source
157
105
    RetTy visit##OPCODE(CLASS &I) { \
158
105
      if (NUM == Instruction::Call) \
159
105
        
return delegateCallInst(I)0
; \
160
105
      else \
161
105
        DELEGATE(CLASS); \
162
105
    }
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitTrunc(llvm::TruncInst&)
AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitZExt(llvm::ZExtInst&)
Line
Count
Source
157
12
    RetTy visit##OPCODE(CLASS &I) { \
158
12
      if (NUM == Instruction::Call) \
159
12
        
return delegateCallInst(I)0
; \
160
12
      else \
161
12
        DELEGATE(CLASS); \
162
12
    }
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitSExt(llvm::SExtInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitFPToUI(llvm::FPToUIInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitFPToSI(llvm::FPToSIInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitUIToFP(llvm::UIToFPInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitSIToFP(llvm::SIToFPInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitFPTrunc(llvm::FPTruncInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitFPExt(llvm::FPExtInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitPtrToInt(llvm::PtrToIntInst&)
AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitIntToPtr(llvm::IntToPtrInst&)
Line
Count
Source
157
78
    RetTy visit##OPCODE(CLASS &I) { \
158
78
      if (NUM == Instruction::Call) \
159
78
        
return delegateCallInst(I)0
; \
160
78
      else \
161
78
        DELEGATE(CLASS); \
162
78
    }
AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitBitCast(llvm::BitCastInst&)
Line
Count
Source
157
387
    RetTy visit##OPCODE(CLASS &I) { \
158
387
      if (NUM == Instruction::Call) \
159
387
        
return delegateCallInst(I)0
; \
160
387
      else \
161
387
        DELEGATE(CLASS); \
162
387
    }
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitAddrSpaceCast(llvm::AddrSpaceCastInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitCleanupPad(llvm::CleanupPadInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitCatchPad(llvm::CatchPadInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitICmp(llvm::ICmpInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitFCmp(llvm::FCmpInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitPHI(llvm::PHINode&)
AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitCall(llvm::CallInst&)
Line
Count
Source
157
366
    RetTy visit##OPCODE(CLASS &I) { \
158
366
      if (NUM == Instruction::Call) \
159
366
        return delegateCallInst(I); \
160
366
      else \
161
366
        
DELEGATE0
(CLASS); \
162
366
    }
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitSelect(llvm::SelectInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitUserOp1(llvm::Instruction&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitUserOp2(llvm::Instruction&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitVAArg(llvm::VAArgInst&)
AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitExtractElement(llvm::ExtractElementInst&)
Line
Count
Source
157
90
    RetTy visit##OPCODE(CLASS &I) { \
158
90
      if (NUM == Instruction::Call) \
159
90
        
return delegateCallInst(I)0
; \
160
90
      else \
161
90
        DELEGATE(CLASS); \
162
90
    }
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitInsertElement(llvm::InsertElementInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitShuffleVector(llvm::ShuffleVectorInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitExtractValue(llvm::ExtractValueInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitInsertValue(llvm::InsertValueInst&)
Unexecuted instantiation: AMDGPUAtomicOptimizer.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUAtomicOptimizer, void>::visitLandingPad(llvm::LandingPadInst&)
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitRet(llvm::ReturnInst&)
Line
Count
Source
157
25.5k
    RetTy visit##OPCODE(CLASS &I) { \
158
25.5k
      if (NUM == Instruction::Call) \
159
25.5k
        
return delegateCallInst(I)0
; \
160
25.5k
      else \
161
25.5k
        DELEGATE(CLASS); \
162
25.5k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitBr(llvm::BranchInst&)
Line
Count
Source
157
2.74k
    RetTy visit##OPCODE(CLASS &I) { \
158
2.74k
      if (NUM == Instruction::Call) \
159
2.74k
        
return delegateCallInst(I)0
; \
160
2.74k
      else \
161
2.74k
        DELEGATE(CLASS); \
162
2.74k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitSwitch(llvm::SwitchInst&)
Line
Count
Source
157
10
    RetTy visit##OPCODE(CLASS &I) { \
158
10
      if (NUM == Instruction::Call) \
159
10
        
return delegateCallInst(I)0
; \
160
10
      else \
161
10
        DELEGATE(CLASS); \
162
10
    }
Unexecuted instantiation: AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitIndirectBr(llvm::IndirectBrInst&)
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitInvoke(llvm::InvokeInst&)
Line
Count
Source
157
1
    RetTy visit##OPCODE(CLASS &I) { \
158
1
      if (NUM == Instruction::Call) \
159
1
        
return delegateCallInst(I)0
; \
160
1
      else \
161
1
        DELEGATE(CLASS); \
162
1
    }
Unexecuted instantiation: AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitResume(llvm::ResumeInst&)
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitUnreachable(llvm::UnreachableInst&)
Line
Count
Source
157
109
    RetTy visit##OPCODE(CLASS &I) { \
158
109
      if (NUM == Instruction::Call) \
159
109
        
return delegateCallInst(I)0
; \
160
109
      else \
161
109
        DELEGATE(CLASS); \
162
109
    }
Unexecuted instantiation: AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitCleanupRet(llvm::CleanupReturnInst&)
Unexecuted instantiation: AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitCatchRet(llvm::CatchReturnInst&)
Unexecuted instantiation: AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitCatchSwitch(llvm::CatchSwitchInst&)
Unexecuted instantiation: AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitCallBr(llvm::CallBrInst&)
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitFNeg(llvm::UnaryOperator&)
Line
Count
Source
157
9
    RetTy visit##OPCODE(CLASS &I) { \
158
9
      if (NUM == Instruction::Call) \
159
9
        
return delegateCallInst(I)0
; \
160
9
      else \
161
9
        DELEGATE(CLASS); \
162
9
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitAdd(llvm::BinaryOperator&)
Line
Count
Source
157
4.59k
    RetTy visit##OPCODE(CLASS &I) { \
158
4.59k
      if (NUM == Instruction::Call) \
159
4.59k
        
return delegateCallInst(I)0
; \
160
4.59k
      else \
161
4.59k
        DELEGATE(CLASS); \
162
4.59k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitFAdd(llvm::BinaryOperator&)
Line
Count
Source
157
2.77k
    RetTy visit##OPCODE(CLASS &I) { \
158
2.77k
      if (NUM == Instruction::Call) \
159
2.77k
        
return delegateCallInst(I)0
; \
160
2.77k
      else \
161
2.77k
        DELEGATE(CLASS); \
162
2.77k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitSub(llvm::BinaryOperator&)
Line
Count
Source
157
419
    RetTy visit##OPCODE(CLASS &I) { \
158
419
      if (NUM == Instruction::Call) \
159
419
        
return delegateCallInst(I)0
; \
160
419
      else \
161
419
        DELEGATE(CLASS); \
162
419
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitFSub(llvm::BinaryOperator&)
Line
Count
Source
157
1.64k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.64k
      if (NUM == Instruction::Call) \
159
1.64k
        
return delegateCallInst(I)0
; \
160
1.64k
      else \
161
1.64k
        DELEGATE(CLASS); \
162
1.64k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitMul(llvm::BinaryOperator&)
Line
Count
Source
157
1.64k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.64k
      if (NUM == Instruction::Call) \
159
1.64k
        
return delegateCallInst(I)0
; \
160
1.64k
      else \
161
1.64k
        DELEGATE(CLASS); \
162
1.64k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitFMul(llvm::BinaryOperator&)
Line
Count
Source
157
2.08k
    RetTy visit##OPCODE(CLASS &I) { \
158
2.08k
      if (NUM == Instruction::Call) \
159
2.08k
        
return delegateCallInst(I)0
; \
160
2.08k
      else \
161
2.08k
        DELEGATE(CLASS); \
162
2.08k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitUDiv(llvm::BinaryOperator&)
Line
Count
Source
157
100
    RetTy visit##OPCODE(CLASS &I) { \
158
100
      if (NUM == Instruction::Call) \
159
100
        
return delegateCallInst(I)0
; \
160
100
      else \
161
100
        DELEGATE(CLASS); \
162
100
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitSDiv(llvm::BinaryOperator&)
Line
Count
Source
157
82
    RetTy visit##OPCODE(CLASS &I) { \
158
82
      if (NUM == Instruction::Call) \
159
82
        
return delegateCallInst(I)0
; \
160
82
      else \
161
82
        DELEGATE(CLASS); \
162
82
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitURem(llvm::BinaryOperator&)
Line
Count
Source
157
65
    RetTy visit##OPCODE(CLASS &I) { \
158
65
      if (NUM == Instruction::Call) \
159
65
        
return delegateCallInst(I)0
; \
160
65
      else \
161
65
        DELEGATE(CLASS); \
162
65
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitSRem(llvm::BinaryOperator&)
Line
Count
Source
157
62
    RetTy visit##OPCODE(CLASS &I) { \
158
62
      if (NUM == Instruction::Call) \
159
62
        
return delegateCallInst(I)0
; \
160
62
      else \
161
62
        DELEGATE(CLASS); \
162
62
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitFRem(llvm::BinaryOperator&)
Line
Count
Source
157
32
    RetTy visit##OPCODE(CLASS &I) { \
158
32
      if (NUM == Instruction::Call) \
159
32
        
return delegateCallInst(I)0
; \
160
32
      else \
161
32
        DELEGATE(CLASS); \
162
32
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitShl(llvm::BinaryOperator&)
Line
Count
Source
157
951
    RetTy visit##OPCODE(CLASS &I) { \
158
951
      if (NUM == Instruction::Call) \
159
951
        
return delegateCallInst(I)0
; \
160
951
      else \
161
951
        DELEGATE(CLASS); \
162
951
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitLShr(llvm::BinaryOperator&)
Line
Count
Source
157
591
    RetTy visit##OPCODE(CLASS &I) { \
158
591
      if (NUM == Instruction::Call) \
159
591
        
return delegateCallInst(I)0
; \
160
591
      else \
161
591
        DELEGATE(CLASS); \
162
591
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitAShr(llvm::BinaryOperator&)
Line
Count
Source
157
376
    RetTy visit##OPCODE(CLASS &I) { \
158
376
      if (NUM == Instruction::Call) \
159
376
        
return delegateCallInst(I)0
; \
160
376
      else \
161
376
        DELEGATE(CLASS); \
162
376
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitAnd(llvm::BinaryOperator&)
Line
Count
Source
157
878
    RetTy visit##OPCODE(CLASS &I) { \
158
878
      if (NUM == Instruction::Call) \
159
878
        
return delegateCallInst(I)0
; \
160
878
      else \
161
878
        DELEGATE(CLASS); \
162
878
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitOr(llvm::BinaryOperator&)
Line
Count
Source
157
482
    RetTy visit##OPCODE(CLASS &I) { \
158
482
      if (NUM == Instruction::Call) \
159
482
        
return delegateCallInst(I)0
; \
160
482
      else \
161
482
        DELEGATE(CLASS); \
162
482
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitXor(llvm::BinaryOperator&)
Line
Count
Source
157
513
    RetTy visit##OPCODE(CLASS &I) { \
158
513
      if (NUM == Instruction::Call) \
159
513
        
return delegateCallInst(I)0
; \
160
513
      else \
161
513
        DELEGATE(CLASS); \
162
513
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitAlloca(llvm::AllocaInst&)
Line
Count
Source
157
663
    RetTy visit##OPCODE(CLASS &I) { \
158
663
      if (NUM == Instruction::Call) \
159
663
        
return delegateCallInst(I)0
; \
160
663
      else \
161
663
        DELEGATE(CLASS); \
162
663
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitLoad(llvm::LoadInst&)
Line
Count
Source
157
18.2k
    RetTy visit##OPCODE(CLASS &I) { \
158
18.2k
      if (NUM == Instruction::Call) \
159
18.2k
        
return delegateCallInst(I)0
; \
160
18.2k
      else \
161
18.2k
        DELEGATE(CLASS); \
162
18.2k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitStore(llvm::StoreInst&)
Line
Count
Source
157
22.1k
    RetTy visit##OPCODE(CLASS &I) { \
158
22.1k
      if (NUM == Instruction::Call) \
159
22.1k
        
return delegateCallInst(I)0
; \
160
22.1k
      else \
161
22.1k
        DELEGATE(CLASS); \
162
22.1k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitGetElementPtr(llvm::GetElementPtrInst&)
Line
Count
Source
157
15.1k
    RetTy visit##OPCODE(CLASS &I) { \
158
15.1k
      if (NUM == Instruction::Call) \
159
15.1k
        
return delegateCallInst(I)0
; \
160
15.1k
      else \
161
15.1k
        DELEGATE(CLASS); \
162
15.1k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitFence(llvm::FenceInst&)
Line
Count
Source
157
841
    RetTy visit##OPCODE(CLASS &I) { \
158
841
      if (NUM == Instruction::Call) \
159
841
        
return delegateCallInst(I)0
; \
160
841
      else \
161
841
        DELEGATE(CLASS); \
162
841
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitAtomicCmpXchg(llvm::AtomicCmpXchgInst&)
Line
Count
Source
157
767
    RetTy visit##OPCODE(CLASS &I) { \
158
767
      if (NUM == Instruction::Call) \
159
767
        
return delegateCallInst(I)0
; \
160
767
      else \
161
767
        DELEGATE(CLASS); \
162
767
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitAtomicRMW(llvm::AtomicRMWInst&)
Line
Count
Source
157
1.76k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.76k
      if (NUM == Instruction::Call) \
159
1.76k
        
return delegateCallInst(I)0
; \
160
1.76k
      else \
161
1.76k
        DELEGATE(CLASS); \
162
1.76k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitTrunc(llvm::TruncInst&)
Line
Count
Source
157
531
    RetTy visit##OPCODE(CLASS &I) { \
158
531
      if (NUM == Instruction::Call) \
159
531
        
return delegateCallInst(I)0
; \
160
531
      else \
161
531
        DELEGATE(CLASS); \
162
531
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitZExt(llvm::ZExtInst&)
Line
Count
Source
157
2.37k
    RetTy visit##OPCODE(CLASS &I) { \
158
2.37k
      if (NUM == Instruction::Call) \
159
2.37k
        
return delegateCallInst(I)0
; \
160
2.37k
      else \
161
2.37k
        DELEGATE(CLASS); \
162
2.37k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitSExt(llvm::SExtInst&)
Line
Count
Source
157
3.03k
    RetTy visit##OPCODE(CLASS &I) { \
158
3.03k
      if (NUM == Instruction::Call) \
159
3.03k
        
return delegateCallInst(I)0
; \
160
3.03k
      else \
161
3.03k
        DELEGATE(CLASS); \
162
3.03k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitFPToUI(llvm::FPToUIInst&)
Line
Count
Source
157
64
    RetTy visit##OPCODE(CLASS &I) { \
158
64
      if (NUM == Instruction::Call) \
159
64
        
return delegateCallInst(I)0
; \
160
64
      else \
161
64
        DELEGATE(CLASS); \
162
64
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitFPToSI(llvm::FPToSIInst&)
Line
Count
Source
157
89
    RetTy visit##OPCODE(CLASS &I) { \
158
89
      if (NUM == Instruction::Call) \
159
89
        
return delegateCallInst(I)0
; \
160
89
      else \
161
89
        DELEGATE(CLASS); \
162
89
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitUIToFP(llvm::UIToFPInst&)
Line
Count
Source
157
124
    RetTy visit##OPCODE(CLASS &I) { \
158
124
      if (NUM == Instruction::Call) \
159
124
        
return delegateCallInst(I)0
; \
160
124
      else \
161
124
        DELEGATE(CLASS); \
162
124
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitSIToFP(llvm::SIToFPInst&)
Line
Count
Source
157
71
    RetTy visit##OPCODE(CLASS &I) { \
158
71
      if (NUM == Instruction::Call) \
159
71
        
return delegateCallInst(I)0
; \
160
71
      else \
161
71
        DELEGATE(CLASS); \
162
71
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitFPTrunc(llvm::FPTruncInst&)
Line
Count
Source
157
169
    RetTy visit##OPCODE(CLASS &I) { \
158
169
      if (NUM == Instruction::Call) \
159
169
        
return delegateCallInst(I)0
; \
160
169
      else \
161
169
        DELEGATE(CLASS); \
162
169
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitFPExt(llvm::FPExtInst&)
Line
Count
Source
157
897
    RetTy visit##OPCODE(CLASS &I) { \
158
897
      if (NUM == Instruction::Call) \
159
897
        
return delegateCallInst(I)0
; \
160
897
      else \
161
897
        DELEGATE(CLASS); \
162
897
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitPtrToInt(llvm::PtrToIntInst&)
Line
Count
Source
157
35
    RetTy visit##OPCODE(CLASS &I) { \
158
35
      if (NUM == Instruction::Call) \
159
35
        
return delegateCallInst(I)0
; \
160
35
      else \
161
35
        DELEGATE(CLASS); \
162
35
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitIntToPtr(llvm::IntToPtrInst&)
Line
Count
Source
157
106
    RetTy visit##OPCODE(CLASS &I) { \
158
106
      if (NUM == Instruction::Call) \
159
106
        
return delegateCallInst(I)0
; \
160
106
      else \
161
106
        DELEGATE(CLASS); \
162
106
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitBitCast(llvm::BitCastInst&)
Line
Count
Source
157
3.29k
    RetTy visit##OPCODE(CLASS &I) { \
158
3.29k
      if (NUM == Instruction::Call) \
159
3.29k
        
return delegateCallInst(I)0
; \
160
3.29k
      else \
161
3.29k
        DELEGATE(CLASS); \
162
3.29k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitAddrSpaceCast(llvm::AddrSpaceCastInst&)
Line
Count
Source
157
108
    RetTy visit##OPCODE(CLASS &I) { \
158
108
      if (NUM == Instruction::Call) \
159
108
        
return delegateCallInst(I)0
; \
160
108
      else \
161
108
        DELEGATE(CLASS); \
162
108
    }
Unexecuted instantiation: AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitCleanupPad(llvm::CleanupPadInst&)
Unexecuted instantiation: AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitCatchPad(llvm::CatchPadInst&)
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitICmp(llvm::ICmpInst&)
Line
Count
Source
157
3.40k
    RetTy visit##OPCODE(CLASS &I) { \
158
3.40k
      if (NUM == Instruction::Call) \
159
3.40k
        
return delegateCallInst(I)0
; \
160
3.40k
      else \
161
3.40k
        DELEGATE(CLASS); \
162
3.40k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitFCmp(llvm::FCmpInst&)
Line
Count
Source
157
1.01k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.01k
      if (NUM == Instruction::Call) \
159
1.01k
        
return delegateCallInst(I)0
; \
160
1.01k
      else \
161
1.01k
        DELEGATE(CLASS); \
162
1.01k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitPHI(llvm::PHINode&)
Line
Count
Source
157
1.89k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.89k
      if (NUM == Instruction::Call) \
159
1.89k
        
return delegateCallInst(I)0
; \
160
1.89k
      else \
161
1.89k
        DELEGATE(CLASS); \
162
1.89k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitCall(llvm::CallInst&)
Line
Count
Source
157
18.6k
    RetTy visit##OPCODE(CLASS &I) { \
158
18.6k
      if (NUM == Instruction::Call) \
159
18.6k
        return delegateCallInst(I); \
160
18.6k
      else \
161
18.6k
        
DELEGATE0
(CLASS); \
162
18.6k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitSelect(llvm::SelectInst&)
Line
Count
Source
157
2.58k
    RetTy visit##OPCODE(CLASS &I) { \
158
2.58k
      if (NUM == Instruction::Call) \
159
2.58k
        
return delegateCallInst(I)0
; \
160
2.58k
      else \
161
2.58k
        DELEGATE(CLASS); \
162
2.58k
    }
Unexecuted instantiation: AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitUserOp1(llvm::Instruction&)
Unexecuted instantiation: AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitUserOp2(llvm::Instruction&)
Unexecuted instantiation: AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitVAArg(llvm::VAArgInst&)
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitExtractElement(llvm::ExtractElementInst&)
Line
Count
Source
157
6.16k
    RetTy visit##OPCODE(CLASS &I) { \
158
6.16k
      if (NUM == Instruction::Call) \
159
6.16k
        
return delegateCallInst(I)0
; \
160
6.16k
      else \
161
6.16k
        DELEGATE(CLASS); \
162
6.16k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitInsertElement(llvm::InsertElementInst&)
Line
Count
Source
157
2.98k
    RetTy visit##OPCODE(CLASS &I) { \
158
2.98k
      if (NUM == Instruction::Call) \
159
2.98k
        
return delegateCallInst(I)0
; \
160
2.98k
      else \
161
2.98k
        DELEGATE(CLASS); \
162
2.98k
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitShuffleVector(llvm::ShuffleVectorInst&)
Line
Count
Source
157
349
    RetTy visit##OPCODE(CLASS &I) { \
158
349
      if (NUM == Instruction::Call) \
159
349
        
return delegateCallInst(I)0
; \
160
349
      else \
161
349
        DELEGATE(CLASS); \
162
349
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitExtractValue(llvm::ExtractValueInst&)
Line
Count
Source
157
964
    RetTy visit##OPCODE(CLASS &I) { \
158
964
      if (NUM == Instruction::Call) \
159
964
        
return delegateCallInst(I)0
; \
160
964
      else \
161
964
        DELEGATE(CLASS); \
162
964
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitInsertValue(llvm::InsertValueInst&)
Line
Count
Source
157
474
    RetTy visit##OPCODE(CLASS &I) { \
158
474
      if (NUM == Instruction::Call) \
159
474
        
return delegateCallInst(I)0
; \
160
474
      else \
161
474
        DELEGATE(CLASS); \
162
474
    }
AMDGPUCodeGenPrepare.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUCodeGenPrepare, bool>::visitLandingPad(llvm::LandingPadInst&)
Line
Count
Source
157
1
    RetTy visit##OPCODE(CLASS &I) { \
158
1
      if (NUM == Instruction::Call) \
159
1
        
return delegateCallInst(I)0
; \
160
1
      else \
161
1
        DELEGATE(CLASS); \
162
1
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitRet(llvm::ReturnInst&)
Line
Count
Source
157
27.5k
    RetTy visit##OPCODE(CLASS &I) { \
158
27.5k
      if (NUM == Instruction::Call) \
159
27.5k
        
return delegateCallInst(I)0
; \
160
27.5k
      else \
161
27.5k
        DELEGATE(CLASS); \
162
27.5k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitBr(llvm::BranchInst&)
Line
Count
Source
157
2.83k
    RetTy visit##OPCODE(CLASS &I) { \
158
2.83k
      if (NUM == Instruction::Call) \
159
2.83k
        
return delegateCallInst(I)0
; \
160
2.83k
      else \
161
2.83k
        DELEGATE(CLASS); \
162
2.83k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitSwitch(llvm::SwitchInst&)
Line
Count
Source
157
10
    RetTy visit##OPCODE(CLASS &I) { \
158
10
      if (NUM == Instruction::Call) \
159
10
        
return delegateCallInst(I)0
; \
160
10
      else \
161
10
        DELEGATE(CLASS); \
162
10
    }
Unexecuted instantiation: AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitIndirectBr(llvm::IndirectBrInst&)
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitInvoke(llvm::InvokeInst&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
Unexecuted instantiation: AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitResume(llvm::ResumeInst&)
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitUnreachable(llvm::UnreachableInst&)
Line
Count
Source
157
110
    RetTy visit##OPCODE(CLASS &I) { \
158
110
      if (NUM == Instruction::Call) \
159
110
        
return delegateCallInst(I)0
; \
160
110
      else \
161
110
        DELEGATE(CLASS); \
162
110
    }
Unexecuted instantiation: AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitCleanupRet(llvm::CleanupReturnInst&)
Unexecuted instantiation: AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitCatchRet(llvm::CatchReturnInst&)
Unexecuted instantiation: AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitCatchSwitch(llvm::CatchSwitchInst&)
Unexecuted instantiation: AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitCallBr(llvm::CallBrInst&)
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitFNeg(llvm::UnaryOperator&)
Line
Count
Source
157
9
    RetTy visit##OPCODE(CLASS &I) { \
158
9
      if (NUM == Instruction::Call) \
159
9
        
return delegateCallInst(I)0
; \
160
9
      else \
161
9
        DELEGATE(CLASS); \
162
9
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitAdd(llvm::BinaryOperator&)
Line
Count
Source
157
4.75k
    RetTy visit##OPCODE(CLASS &I) { \
158
4.75k
      if (NUM == Instruction::Call) \
159
4.75k
        
return delegateCallInst(I)0
; \
160
4.75k
      else \
161
4.75k
        DELEGATE(CLASS); \
162
4.75k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitFAdd(llvm::BinaryOperator&)
Line
Count
Source
157
3.23k
    RetTy visit##OPCODE(CLASS &I) { \
158
3.23k
      if (NUM == Instruction::Call) \
159
3.23k
        
return delegateCallInst(I)0
; \
160
3.23k
      else \
161
3.23k
        DELEGATE(CLASS); \
162
3.23k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitSub(llvm::BinaryOperator&)
Line
Count
Source
157
435
    RetTy visit##OPCODE(CLASS &I) { \
158
435
      if (NUM == Instruction::Call) \
159
435
        
return delegateCallInst(I)0
; \
160
435
      else \
161
435
        DELEGATE(CLASS); \
162
435
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitFSub(llvm::BinaryOperator&)
Line
Count
Source
157
1.76k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.76k
      if (NUM == Instruction::Call) \
159
1.76k
        
return delegateCallInst(I)0
; \
160
1.76k
      else \
161
1.76k
        DELEGATE(CLASS); \
162
1.76k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitMul(llvm::BinaryOperator&)
Line
Count
Source
157
1.67k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.67k
      if (NUM == Instruction::Call) \
159
1.67k
        
return delegateCallInst(I)0
; \
160
1.67k
      else \
161
1.67k
        DELEGATE(CLASS); \
162
1.67k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitFMul(llvm::BinaryOperator&)
Line
Count
Source
157
2.50k
    RetTy visit##OPCODE(CLASS &I) { \
158
2.50k
      if (NUM == Instruction::Call) \
159
2.50k
        
return delegateCallInst(I)0
; \
160
2.50k
      else \
161
2.50k
        DELEGATE(CLASS); \
162
2.50k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitUDiv(llvm::BinaryOperator&)
Line
Count
Source
157
140
    RetTy visit##OPCODE(CLASS &I) { \
158
140
      if (NUM == Instruction::Call) \
159
140
        
return delegateCallInst(I)0
; \
160
140
      else \
161
140
        DELEGATE(CLASS); \
162
140
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitSDiv(llvm::BinaryOperator&)
Line
Count
Source
157
99
    RetTy visit##OPCODE(CLASS &I) { \
158
99
      if (NUM == Instruction::Call) \
159
99
        
return delegateCallInst(I)0
; \
160
99
      else \
161
99
        DELEGATE(CLASS); \
162
99
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitFDiv(llvm::BinaryOperator&)
Line
Count
Source
157
330
    RetTy visit##OPCODE(CLASS &I) { \
158
330
      if (NUM == Instruction::Call) \
159
330
        
return delegateCallInst(I)0
; \
160
330
      else \
161
330
        DELEGATE(CLASS); \
162
330
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitURem(llvm::BinaryOperator&)
Line
Count
Source
157
79
    RetTy visit##OPCODE(CLASS &I) { \
158
79
      if (NUM == Instruction::Call) \
159
79
        
return delegateCallInst(I)0
; \
160
79
      else \
161
79
        DELEGATE(CLASS); \
162
79
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitSRem(llvm::BinaryOperator&)
Line
Count
Source
157
77
    RetTy visit##OPCODE(CLASS &I) { \
158
77
      if (NUM == Instruction::Call) \
159
77
        
return delegateCallInst(I)0
; \
160
77
      else \
161
77
        DELEGATE(CLASS); \
162
77
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitFRem(llvm::BinaryOperator&)
Line
Count
Source
157
32
    RetTy visit##OPCODE(CLASS &I) { \
158
32
      if (NUM == Instruction::Call) \
159
32
        
return delegateCallInst(I)0
; \
160
32
      else \
161
32
        DELEGATE(CLASS); \
162
32
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitShl(llvm::BinaryOperator&)
Line
Count
Source
157
1.11k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.11k
      if (NUM == Instruction::Call) \
159
1.11k
        
return delegateCallInst(I)0
; \
160
1.11k
      else \
161
1.11k
        DELEGATE(CLASS); \
162
1.11k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitLShr(llvm::BinaryOperator&)
Line
Count
Source
157
675
    RetTy visit##OPCODE(CLASS &I) { \
158
675
      if (NUM == Instruction::Call) \
159
675
        
return delegateCallInst(I)0
; \
160
675
      else \
161
675
        DELEGATE(CLASS); \
162
675
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitAShr(llvm::BinaryOperator&)
Line
Count
Source
157
444
    RetTy visit##OPCODE(CLASS &I) { \
158
444
      if (NUM == Instruction::Call) \
159
444
        
return delegateCallInst(I)0
; \
160
444
      else \
161
444
        DELEGATE(CLASS); \
162
444
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitAnd(llvm::BinaryOperator&)
Line
Count
Source
157
978
    RetTy visit##OPCODE(CLASS &I) { \
158
978
      if (NUM == Instruction::Call) \
159
978
        
return delegateCallInst(I)0
; \
160
978
      else \
161
978
        DELEGATE(CLASS); \
162
978
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitOr(llvm::BinaryOperator&)
Line
Count
Source
157
527
    RetTy visit##OPCODE(CLASS &I) { \
158
527
      if (NUM == Instruction::Call) \
159
527
        
return delegateCallInst(I)0
; \
160
527
      else \
161
527
        DELEGATE(CLASS); \
162
527
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitXor(llvm::BinaryOperator&)
Line
Count
Source
157
548
    RetTy visit##OPCODE(CLASS &I) { \
158
548
      if (NUM == Instruction::Call) \
159
548
        
return delegateCallInst(I)0
; \
160
548
      else \
161
548
        DELEGATE(CLASS); \
162
548
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitAlloca(llvm::AllocaInst&)
Line
Count
Source
157
777
    RetTy visit##OPCODE(CLASS &I) { \
158
777
      if (NUM == Instruction::Call) \
159
777
        
return delegateCallInst(I)0
; \
160
777
      else \
161
777
        DELEGATE(CLASS); \
162
777
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitLoad(llvm::LoadInst&)
Line
Count
Source
157
20.1k
    RetTy visit##OPCODE(CLASS &I) { \
158
20.1k
      if (NUM == Instruction::Call) \
159
20.1k
        
return delegateCallInst(I)0
; \
160
20.1k
      else \
161
20.1k
        DELEGATE(CLASS); \
162
20.1k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitStore(llvm::StoreInst&)
Line
Count
Source
157
24.1k
    RetTy visit##OPCODE(CLASS &I) { \
158
24.1k
      if (NUM == Instruction::Call) \
159
24.1k
        
return delegateCallInst(I)0
; \
160
24.1k
      else \
161
24.1k
        DELEGATE(CLASS); \
162
24.1k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitGetElementPtr(llvm::GetElementPtrInst&)
Line
Count
Source
157
16.1k
    RetTy visit##OPCODE(CLASS &I) { \
158
16.1k
      if (NUM == Instruction::Call) \
159
16.1k
        
return delegateCallInst(I)0
; \
160
16.1k
      else \
161
16.1k
        DELEGATE(CLASS); \
162
16.1k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitFence(llvm::FenceInst&)
Line
Count
Source
157
841
    RetTy visit##OPCODE(CLASS &I) { \
158
841
      if (NUM == Instruction::Call) \
159
841
        
return delegateCallInst(I)0
; \
160
841
      else \
161
841
        DELEGATE(CLASS); \
162
841
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitAtomicCmpXchg(llvm::AtomicCmpXchgInst&)
Line
Count
Source
157
732
    RetTy visit##OPCODE(CLASS &I) { \
158
732
      if (NUM == Instruction::Call) \
159
732
        
return delegateCallInst(I)0
; \
160
732
      else \
161
732
        DELEGATE(CLASS); \
162
732
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitAtomicRMW(llvm::AtomicRMWInst&)
Line
Count
Source
157
1.95k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.95k
      if (NUM == Instruction::Call) \
159
1.95k
        
return delegateCallInst(I)0
; \
160
1.95k
      else \
161
1.95k
        DELEGATE(CLASS); \
162
1.95k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitTrunc(llvm::TruncInst&)
Line
Count
Source
157
609
    RetTy visit##OPCODE(CLASS &I) { \
158
609
      if (NUM == Instruction::Call) \
159
609
        
return delegateCallInst(I)0
; \
160
609
      else \
161
609
        DELEGATE(CLASS); \
162
609
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitZExt(llvm::ZExtInst&)
Line
Count
Source
157
2.66k
    RetTy visit##OPCODE(CLASS &I) { \
158
2.66k
      if (NUM == Instruction::Call) \
159
2.66k
        
return delegateCallInst(I)0
; \
160
2.66k
      else \
161
2.66k
        DELEGATE(CLASS); \
162
2.66k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitSExt(llvm::SExtInst&)
Line
Count
Source
157
3.41k
    RetTy visit##OPCODE(CLASS &I) { \
158
3.41k
      if (NUM == Instruction::Call) \
159
3.41k
        
return delegateCallInst(I)0
; \
160
3.41k
      else \
161
3.41k
        DELEGATE(CLASS); \
162
3.41k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitFPToUI(llvm::FPToUIInst&)
Line
Count
Source
157
74
    RetTy visit##OPCODE(CLASS &I) { \
158
74
      if (NUM == Instruction::Call) \
159
74
        
return delegateCallInst(I)0
; \
160
74
      else \
161
74
        DELEGATE(CLASS); \
162
74
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitFPToSI(llvm::FPToSIInst&)
Line
Count
Source
157
107
    RetTy visit##OPCODE(CLASS &I) { \
158
107
      if (NUM == Instruction::Call) \
159
107
        
return delegateCallInst(I)0
; \
160
107
      else \
161
107
        DELEGATE(CLASS); \
162
107
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitUIToFP(llvm::UIToFPInst&)
Line
Count
Source
157
136
    RetTy visit##OPCODE(CLASS &I) { \
158
136
      if (NUM == Instruction::Call) \
159
136
        
return delegateCallInst(I)0
; \
160
136
      else \
161
136
        DELEGATE(CLASS); \
162
136
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitSIToFP(llvm::SIToFPInst&)
Line
Count
Source
157
80
    RetTy visit##OPCODE(CLASS &I) { \
158
80
      if (NUM == Instruction::Call) \
159
80
        
return delegateCallInst(I)0
; \
160
80
      else \
161
80
        DELEGATE(CLASS); \
162
80
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitFPTrunc(llvm::FPTruncInst&)
Line
Count
Source
157
170
    RetTy visit##OPCODE(CLASS &I) { \
158
170
      if (NUM == Instruction::Call) \
159
170
        
return delegateCallInst(I)0
; \
160
170
      else \
161
170
        DELEGATE(CLASS); \
162
170
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitFPExt(llvm::FPExtInst&)
Line
Count
Source
157
897
    RetTy visit##OPCODE(CLASS &I) { \
158
897
      if (NUM == Instruction::Call) \
159
897
        
return delegateCallInst(I)0
; \
160
897
      else \
161
897
        DELEGATE(CLASS); \
162
897
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitPtrToInt(llvm::PtrToIntInst&)
Line
Count
Source
157
35
    RetTy visit##OPCODE(CLASS &I) { \
158
35
      if (NUM == Instruction::Call) \
159
35
        
return delegateCallInst(I)0
; \
160
35
      else \
161
35
        DELEGATE(CLASS); \
162
35
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitIntToPtr(llvm::IntToPtrInst&)
Line
Count
Source
157
106
    RetTy visit##OPCODE(CLASS &I) { \
158
106
      if (NUM == Instruction::Call) \
159
106
        
return delegateCallInst(I)0
; \
160
106
      else \
161
106
        DELEGATE(CLASS); \
162
106
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitBitCast(llvm::BitCastInst&)
Line
Count
Source
157
3.27k
    RetTy visit##OPCODE(CLASS &I) { \
158
3.27k
      if (NUM == Instruction::Call) \
159
3.27k
        
return delegateCallInst(I)0
; \
160
3.27k
      else \
161
3.27k
        DELEGATE(CLASS); \
162
3.27k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitAddrSpaceCast(llvm::AddrSpaceCastInst&)
Line
Count
Source
157
120
    RetTy visit##OPCODE(CLASS &I) { \
158
120
      if (NUM == Instruction::Call) \
159
120
        
return delegateCallInst(I)0
; \
160
120
      else \
161
120
        DELEGATE(CLASS); \
162
120
    }
Unexecuted instantiation: AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitCleanupPad(llvm::CleanupPadInst&)
Unexecuted instantiation: AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitCatchPad(llvm::CatchPadInst&)
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitICmp(llvm::ICmpInst&)
Line
Count
Source
157
2.64k
    RetTy visit##OPCODE(CLASS &I) { \
158
2.64k
      if (NUM == Instruction::Call) \
159
2.64k
        
return delegateCallInst(I)0
; \
160
2.64k
      else \
161
2.64k
        DELEGATE(CLASS); \
162
2.64k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitFCmp(llvm::FCmpInst&)
Line
Count
Source
157
1.15k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.15k
      if (NUM == Instruction::Call) \
159
1.15k
        
return delegateCallInst(I)0
; \
160
1.15k
      else \
161
1.15k
        DELEGATE(CLASS); \
162
1.15k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitPHI(llvm::PHINode&)
Line
Count
Source
157
1.97k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.97k
      if (NUM == Instruction::Call) \
159
1.97k
        
return delegateCallInst(I)0
; \
160
1.97k
      else \
161
1.97k
        DELEGATE(CLASS); \
162
1.97k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitCall(llvm::CallInst&)
Line
Count
Source
157
20.6k
    RetTy visit##OPCODE(CLASS &I) { \
158
20.6k
      if (NUM == Instruction::Call) \
159
20.6k
        return delegateCallInst(I); \
160
20.6k
      else \
161
20.6k
        
DELEGATE0
(CLASS); \
162
20.6k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitSelect(llvm::SelectInst&)
Line
Count
Source
157
1.78k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.78k
      if (NUM == Instruction::Call) \
159
1.78k
        
return delegateCallInst(I)0
; \
160
1.78k
      else \
161
1.78k
        DELEGATE(CLASS); \
162
1.78k
    }
Unexecuted instantiation: AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitUserOp1(llvm::Instruction&)
Unexecuted instantiation: AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitUserOp2(llvm::Instruction&)
Unexecuted instantiation: AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitVAArg(llvm::VAArgInst&)
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitExtractElement(llvm::ExtractElementInst&)
Line
Count
Source
157
6.55k
    RetTy visit##OPCODE(CLASS &I) { \
158
6.55k
      if (NUM == Instruction::Call) \
159
6.55k
        
return delegateCallInst(I)0
; \
160
6.55k
      else \
161
6.55k
        DELEGATE(CLASS); \
162
6.55k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitInsertElement(llvm::InsertElementInst&)
Line
Count
Source
157
3.50k
    RetTy visit##OPCODE(CLASS &I) { \
158
3.50k
      if (NUM == Instruction::Call) \
159
3.50k
        
return delegateCallInst(I)0
; \
160
3.50k
      else \
161
3.50k
        DELEGATE(CLASS); \
162
3.50k
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitShuffleVector(llvm::ShuffleVectorInst&)
Line
Count
Source
157
631
    RetTy visit##OPCODE(CLASS &I) { \
158
631
      if (NUM == Instruction::Call) \
159
631
        
return delegateCallInst(I)0
; \
160
631
      else \
161
631
        DELEGATE(CLASS); \
162
631
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitExtractValue(llvm::ExtractValueInst&)
Line
Count
Source
157
906
    RetTy visit##OPCODE(CLASS &I) { \
158
906
      if (NUM == Instruction::Call) \
159
906
        
return delegateCallInst(I)0
; \
160
906
      else \
161
906
        DELEGATE(CLASS); \
162
906
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitInsertValue(llvm::InsertValueInst&)
Line
Count
Source
157
466
    RetTy visit##OPCODE(CLASS &I) { \
158
466
      if (NUM == Instruction::Call) \
159
466
        
return delegateCallInst(I)0
; \
160
466
      else \
161
466
        DELEGATE(CLASS); \
162
466
    }
AMDGPUFixFunctionBitcasts.cpp:llvm::InstVisitor<(anonymous namespace)::AMDGPUFixFunctionBitcasts, void>::visitLandingPad(llvm::LandingPadInst&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitRet(llvm::ReturnInst&)
Line
Count
Source
157
4.36k
    RetTy visit##OPCODE(CLASS &I) { \
158
4.36k
      if (NUM == Instruction::Call) \
159
4.36k
        
return delegateCallInst(I)0
; \
160
4.36k
      else \
161
4.36k
        DELEGATE(CLASS); \
162
4.36k
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitBr(llvm::BranchInst&)
Line
Count
Source
157
341
    RetTy visit##OPCODE(CLASS &I) { \
158
341
      if (NUM == Instruction::Call) \
159
341
        
return delegateCallInst(I)0
; \
160
341
      else \
161
341
        DELEGATE(CLASS); \
162
341
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitSwitch(llvm::SwitchInst&)
Line
Count
Source
157
8
    RetTy visit##OPCODE(CLASS &I) { \
158
8
      if (NUM == Instruction::Call) \
159
8
        
return delegateCallInst(I)0
; \
160
8
      else \
161
8
        DELEGATE(CLASS); \
162
8
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitIndirectBr(llvm::IndirectBrInst&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitInvoke(llvm::InvokeInst&)
Line
Count
Source
157
82
    RetTy visit##OPCODE(CLASS &I) { \
158
82
      if (NUM == Instruction::Call) \
159
82
        
return delegateCallInst(I)0
; \
160
82
      else \
161
82
        DELEGATE(CLASS); \
162
82
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitResume(llvm::ResumeInst&)
Line
Count
Source
157
1
    RetTy visit##OPCODE(CLASS &I) { \
158
1
      if (NUM == Instruction::Call) \
159
1
        
return delegateCallInst(I)0
; \
160
1
      else \
161
1
        DELEGATE(CLASS); \
162
1
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitUnreachable(llvm::UnreachableInst&)
Line
Count
Source
157
62
    RetTy visit##OPCODE(CLASS &I) { \
158
62
      if (NUM == Instruction::Call) \
159
62
        
return delegateCallInst(I)0
; \
160
62
      else \
161
62
        DELEGATE(CLASS); \
162
62
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitCleanupRet(llvm::CleanupReturnInst&)
Line
Count
Source
157
15
    RetTy visit##OPCODE(CLASS &I) { \
158
15
      if (NUM == Instruction::Call) \
159
15
        
return delegateCallInst(I)0
; \
160
15
      else \
161
15
        DELEGATE(CLASS); \
162
15
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitCatchRet(llvm::CatchReturnInst&)
Line
Count
Source
157
50
    RetTy visit##OPCODE(CLASS &I) { \
158
50
      if (NUM == Instruction::Call) \
159
50
        
return delegateCallInst(I)0
; \
160
50
      else \
161
50
        DELEGATE(CLASS); \
162
50
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitCatchSwitch(llvm::CatchSwitchInst&)
Line
Count
Source
157
43
    RetTy visit##OPCODE(CLASS &I) { \
158
43
      if (NUM == Instruction::Call) \
159
43
        
return delegateCallInst(I)0
; \
160
43
      else \
161
43
        DELEGATE(CLASS); \
162
43
    }
Unexecuted instantiation: WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitCallBr(llvm::CallBrInst&)
Unexecuted instantiation: WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitFNeg(llvm::UnaryOperator&)
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitAdd(llvm::BinaryOperator&)
Line
Count
Source
157
300
    RetTy visit##OPCODE(CLASS &I) { \
158
300
      if (NUM == Instruction::Call) \
159
300
        
return delegateCallInst(I)0
; \
160
300
      else \
161
300
        DELEGATE(CLASS); \
162
300
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitFAdd(llvm::BinaryOperator&)
Line
Count
Source
157
26
    RetTy visit##OPCODE(CLASS &I) { \
158
26
      if (NUM == Instruction::Call) \
159
26
        
return delegateCallInst(I)0
; \
160
26
      else \
161
26
        DELEGATE(CLASS); \
162
26
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitSub(llvm::BinaryOperator&)
Line
Count
Source
157
86
    RetTy visit##OPCODE(CLASS &I) { \
158
86
      if (NUM == Instruction::Call) \
159
86
        
return delegateCallInst(I)0
; \
160
86
      else \
161
86
        DELEGATE(CLASS); \
162
86
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitFSub(llvm::BinaryOperator&)
Line
Count
Source
157
32
    RetTy visit##OPCODE(CLASS &I) { \
158
32
      if (NUM == Instruction::Call) \
159
32
        
return delegateCallInst(I)0
; \
160
32
      else \
161
32
        DELEGATE(CLASS); \
162
32
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitMul(llvm::BinaryOperator&)
Line
Count
Source
157
41
    RetTy visit##OPCODE(CLASS &I) { \
158
41
      if (NUM == Instruction::Call) \
159
41
        
return delegateCallInst(I)0
; \
160
41
      else \
161
41
        DELEGATE(CLASS); \
162
41
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitFMul(llvm::BinaryOperator&)
Line
Count
Source
157
19
    RetTy visit##OPCODE(CLASS &I) { \
158
19
      if (NUM == Instruction::Call) \
159
19
        
return delegateCallInst(I)0
; \
160
19
      else \
161
19
        DELEGATE(CLASS); \
162
19
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitUDiv(llvm::BinaryOperator&)
Line
Count
Source
157
9
    RetTy visit##OPCODE(CLASS &I) { \
158
9
      if (NUM == Instruction::Call) \
159
9
        
return delegateCallInst(I)0
; \
160
9
      else \
161
9
        DELEGATE(CLASS); \
162
9
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitSDiv(llvm::BinaryOperator&)
Line
Count
Source
157
45
    RetTy visit##OPCODE(CLASS &I) { \
158
45
      if (NUM == Instruction::Call) \
159
45
        
return delegateCallInst(I)0
; \
160
45
      else \
161
45
        DELEGATE(CLASS); \
162
45
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitFDiv(llvm::BinaryOperator&)
Line
Count
Source
157
17
    RetTy visit##OPCODE(CLASS &I) { \
158
17
      if (NUM == Instruction::Call) \
159
17
        
return delegateCallInst(I)0
; \
160
17
      else \
161
17
        DELEGATE(CLASS); \
162
17
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitURem(llvm::BinaryOperator&)
Line
Count
Source
157
12
    RetTy visit##OPCODE(CLASS &I) { \
158
12
      if (NUM == Instruction::Call) \
159
12
        
return delegateCallInst(I)0
; \
160
12
      else \
161
12
        DELEGATE(CLASS); \
162
12
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitSRem(llvm::BinaryOperator&)
Line
Count
Source
157
9
    RetTy visit##OPCODE(CLASS &I) { \
158
9
      if (NUM == Instruction::Call) \
159
9
        
return delegateCallInst(I)0
; \
160
9
      else \
161
9
        DELEGATE(CLASS); \
162
9
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitFRem(llvm::BinaryOperator&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitShl(llvm::BinaryOperator&)
Line
Count
Source
157
118
    RetTy visit##OPCODE(CLASS &I) { \
158
118
      if (NUM == Instruction::Call) \
159
118
        
return delegateCallInst(I)0
; \
160
118
      else \
161
118
        DELEGATE(CLASS); \
162
118
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitLShr(llvm::BinaryOperator&)
Line
Count
Source
157
92
    RetTy visit##OPCODE(CLASS &I) { \
158
92
      if (NUM == Instruction::Call) \
159
92
        
return delegateCallInst(I)0
; \
160
92
      else \
161
92
        DELEGATE(CLASS); \
162
92
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitAShr(llvm::BinaryOperator&)
Line
Count
Source
157
81
    RetTy visit##OPCODE(CLASS &I) { \
158
81
      if (NUM == Instruction::Call) \
159
81
        
return delegateCallInst(I)0
; \
160
81
      else \
161
81
        DELEGATE(CLASS); \
162
81
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitAnd(llvm::BinaryOperator&)
Line
Count
Source
157
165
    RetTy visit##OPCODE(CLASS &I) { \
158
165
      if (NUM == Instruction::Call) \
159
165
        
return delegateCallInst(I)0
; \
160
165
      else \
161
165
        DELEGATE(CLASS); \
162
165
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitOr(llvm::BinaryOperator&)
Line
Count
Source
157
87
    RetTy visit##OPCODE(CLASS &I) { \
158
87
      if (NUM == Instruction::Call) \
159
87
        
return delegateCallInst(I)0
; \
160
87
      else \
161
87
        DELEGATE(CLASS); \
162
87
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitXor(llvm::BinaryOperator&)
Line
Count
Source
157
135
    RetTy visit##OPCODE(CLASS &I) { \
158
135
      if (NUM == Instruction::Call) \
159
135
        
return delegateCallInst(I)0
; \
160
135
      else \
161
135
        DELEGATE(CLASS); \
162
135
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitAlloca(llvm::AllocaInst&)
Line
Count
Source
157
83
    RetTy visit##OPCODE(CLASS &I) { \
158
83
      if (NUM == Instruction::Call) \
159
83
        
return delegateCallInst(I)0
; \
160
83
      else \
161
83
        DELEGATE(CLASS); \
162
83
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitLoad(llvm::LoadInst&)
Line
Count
Source
157
868
    RetTy visit##OPCODE(CLASS &I) { \
158
868
      if (NUM == Instruction::Call) \
159
868
        
return delegateCallInst(I)0
; \
160
868
      else \
161
868
        DELEGATE(CLASS); \
162
868
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitStore(llvm::StoreInst&)
Line
Count
Source
157
749
    RetTy visit##OPCODE(CLASS &I) { \
158
749
      if (NUM == Instruction::Call) \
159
749
        
return delegateCallInst(I)0
; \
160
749
      else \
161
749
        DELEGATE(CLASS); \
162
749
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitGetElementPtr(llvm::GetElementPtrInst&)
Line
Count
Source
157
443
    RetTy visit##OPCODE(CLASS &I) { \
158
443
      if (NUM == Instruction::Call) \
159
443
        
return delegateCallInst(I)0
; \
160
443
      else \
161
443
        DELEGATE(CLASS); \
162
443
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitFence(llvm::FenceInst&)
Line
Count
Source
157
24
    RetTy visit##OPCODE(CLASS &I) { \
158
24
      if (NUM == Instruction::Call) \
159
24
        
return delegateCallInst(I)0
; \
160
24
      else \
161
24
        DELEGATE(CLASS); \
162
24
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitAtomicCmpXchg(llvm::AtomicCmpXchgInst&)
Line
Count
Source
157
80
    RetTy visit##OPCODE(CLASS &I) { \
158
80
      if (NUM == Instruction::Call) \
159
80
        
return delegateCallInst(I)0
; \
160
80
      else \
161
80
        DELEGATE(CLASS); \
162
80
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitAtomicRMW(llvm::AtomicRMWInst&)
Line
Count
Source
157
110
    RetTy visit##OPCODE(CLASS &I) { \
158
110
      if (NUM == Instruction::Call) \
159
110
        
return delegateCallInst(I)0
; \
160
110
      else \
161
110
        DELEGATE(CLASS); \
162
110
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitTrunc(llvm::TruncInst&)
Line
Count
Source
157
348
    RetTy visit##OPCODE(CLASS &I) { \
158
348
      if (NUM == Instruction::Call) \
159
348
        
return delegateCallInst(I)0
; \
160
348
      else \
161
348
        DELEGATE(CLASS); \
162
348
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitZExt(llvm::ZExtInst&)
Line
Count
Source
157
307
    RetTy visit##OPCODE(CLASS &I) { \
158
307
      if (NUM == Instruction::Call) \
159
307
        
return delegateCallInst(I)0
; \
160
307
      else \
161
307
        DELEGATE(CLASS); \
162
307
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitSExt(llvm::SExtInst&)
Line
Count
Source
157
483
    RetTy visit##OPCODE(CLASS &I) { \
158
483
      if (NUM == Instruction::Call) \
159
483
        
return delegateCallInst(I)0
; \
160
483
      else \
161
483
        DELEGATE(CLASS); \
162
483
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitFPToUI(llvm::FPToUIInst&)
Line
Count
Source
157
20
    RetTy visit##OPCODE(CLASS &I) { \
158
20
      if (NUM == Instruction::Call) \
159
20
        
return delegateCallInst(I)0
; \
160
20
      else \
161
20
        DELEGATE(CLASS); \
162
20
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitFPToSI(llvm::FPToSIInst&)
Line
Count
Source
157
14
    RetTy visit##OPCODE(CLASS &I) { \
158
14
      if (NUM == Instruction::Call) \
159
14
        
return delegateCallInst(I)0
; \
160
14
      else \
161
14
        DELEGATE(CLASS); \
162
14
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitUIToFP(llvm::UIToFPInst&)
Line
Count
Source
157
10
    RetTy visit##OPCODE(CLASS &I) { \
158
10
      if (NUM == Instruction::Call) \
159
10
        
return delegateCallInst(I)0
; \
160
10
      else \
161
10
        DELEGATE(CLASS); \
162
10
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitSIToFP(llvm::SIToFPInst&)
Line
Count
Source
157
11
    RetTy visit##OPCODE(CLASS &I) { \
158
11
      if (NUM == Instruction::Call) \
159
11
        
return delegateCallInst(I)0
; \
160
11
      else \
161
11
        DELEGATE(CLASS); \
162
11
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitFPTrunc(llvm::FPTruncInst&)
Line
Count
Source
157
10
    RetTy visit##OPCODE(CLASS &I) { \
158
10
      if (NUM == Instruction::Call) \
159
10
        
return delegateCallInst(I)0
; \
160
10
      else \
161
10
        DELEGATE(CLASS); \
162
10
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitFPExt(llvm::FPExtInst&)
Line
Count
Source
157
9
    RetTy visit##OPCODE(CLASS &I) { \
158
9
      if (NUM == Instruction::Call) \
159
9
        
return delegateCallInst(I)0
; \
160
9
      else \
161
9
        DELEGATE(CLASS); \
162
9
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitPtrToInt(llvm::PtrToIntInst&)
Line
Count
Source
157
148
    RetTy visit##OPCODE(CLASS &I) { \
158
148
      if (NUM == Instruction::Call) \
159
148
        
return delegateCallInst(I)0
; \
160
148
      else \
161
148
        DELEGATE(CLASS); \
162
148
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitIntToPtr(llvm::IntToPtrInst&)
Line
Count
Source
157
241
    RetTy visit##OPCODE(CLASS &I) { \
158
241
      if (NUM == Instruction::Call) \
159
241
        
return delegateCallInst(I)0
; \
160
241
      else \
161
241
        DELEGATE(CLASS); \
162
241
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitBitCast(llvm::BitCastInst&)
Line
Count
Source
157
175
    RetTy visit##OPCODE(CLASS &I) { \
158
175
      if (NUM == Instruction::Call) \
159
175
        
return delegateCallInst(I)0
; \
160
175
      else \
161
175
        DELEGATE(CLASS); \
162
175
    }
Unexecuted instantiation: WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitAddrSpaceCast(llvm::AddrSpaceCastInst&)
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitCleanupPad(llvm::CleanupPadInst&)
Line
Count
Source
157
20
    RetTy visit##OPCODE(CLASS &I) { \
158
20
      if (NUM == Instruction::Call) \
159
20
        
return delegateCallInst(I)0
; \
160
20
      else \
161
20
        DELEGATE(CLASS); \
162
20
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitCatchPad(llvm::CatchPadInst&)
Line
Count
Source
157
43
    RetTy visit##OPCODE(CLASS &I) { \
158
43
      if (NUM == Instruction::Call) \
159
43
        
return delegateCallInst(I)0
; \
160
43
      else \
161
43
        DELEGATE(CLASS); \
162
43
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitICmp(llvm::ICmpInst&)
Line
Count
Source
157
468
    RetTy visit##OPCODE(CLASS &I) { \
158
468
      if (NUM == Instruction::Call) \
159
468
        
return delegateCallInst(I)0
; \
160
468
      else \
161
468
        DELEGATE(CLASS); \
162
468
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitFCmp(llvm::FCmpInst&)
Line
Count
Source
157
434
    RetTy visit##OPCODE(CLASS &I) { \
158
434
      if (NUM == Instruction::Call) \
159
434
        
return delegateCallInst(I)0
; \
160
434
      else \
161
434
        DELEGATE(CLASS); \
162
434
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitPHI(llvm::PHINode&)
Line
Count
Source
157
81
    RetTy visit##OPCODE(CLASS &I) { \
158
81
      if (NUM == Instruction::Call) \
159
81
        
return delegateCallInst(I)0
; \
160
81
      else \
161
81
        DELEGATE(CLASS); \
162
81
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitCall(llvm::CallInst&)
Line
Count
Source
157
1.20k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.20k
      if (NUM == Instruction::Call) \
159
1.20k
        return delegateCallInst(I); \
160
1.20k
      else \
161
1.20k
        
DELEGATE0
(CLASS); \
162
1.20k
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitSelect(llvm::SelectInst&)
Line
Count
Source
157
216
    RetTy visit##OPCODE(CLASS &I) { \
158
216
      if (NUM == Instruction::Call) \
159
216
        
return delegateCallInst(I)0
; \
160
216
      else \
161
216
        DELEGATE(CLASS); \
162
216
    }
Unexecuted instantiation: WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitUserOp1(llvm::Instruction&)
Unexecuted instantiation: WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitUserOp2(llvm::Instruction&)
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitVAArg(llvm::VAArgInst&)
Line
Count
Source
157
3
    RetTy visit##OPCODE(CLASS &I) { \
158
3
      if (NUM == Instruction::Call) \
159
3
        
return delegateCallInst(I)0
; \
160
3
      else \
161
3
        DELEGATE(CLASS); \
162
3
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitExtractElement(llvm::ExtractElementInst&)
Line
Count
Source
157
94
    RetTy visit##OPCODE(CLASS &I) { \
158
94
      if (NUM == Instruction::Call) \
159
94
        
return delegateCallInst(I)0
; \
160
94
      else \
161
94
        DELEGATE(CLASS); \
162
94
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitInsertElement(llvm::InsertElementInst&)
Line
Count
Source
157
328
    RetTy visit##OPCODE(CLASS &I) { \
158
328
      if (NUM == Instruction::Call) \
159
328
        
return delegateCallInst(I)0
; \
160
328
      else \
161
328
        DELEGATE(CLASS); \
162
328
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitShuffleVector(llvm::ShuffleVectorInst&)
Line
Count
Source
157
181
    RetTy visit##OPCODE(CLASS &I) { \
158
181
      if (NUM == Instruction::Call) \
159
181
        
return delegateCallInst(I)0
; \
160
181
      else \
161
181
        DELEGATE(CLASS); \
162
181
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitExtractValue(llvm::ExtractValueInst&)
Line
Count
Source
157
178
    RetTy visit##OPCODE(CLASS &I) { \
158
178
      if (NUM == Instruction::Call) \
159
178
        
return delegateCallInst(I)0
; \
160
178
      else \
161
178
        DELEGATE(CLASS); \
162
178
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitInsertValue(llvm::InsertValueInst&)
Line
Count
Source
157
114
    RetTy visit##OPCODE(CLASS &I) { \
158
114
      if (NUM == Instruction::Call) \
159
114
        
return delegateCallInst(I)0
; \
160
114
      else \
161
114
        DELEGATE(CLASS); \
162
114
    }
WebAssemblyOptimizeReturned.cpp:llvm::InstVisitor<(anonymous namespace)::OptimizeReturned, void>::visitLandingPad(llvm::LandingPadInst&)
Line
Count
Source
157
9
    RetTy visit##OPCODE(CLASS &I) { \
158
9
      if (NUM == Instruction::Call) \
159
9
        
return delegateCallInst(I)0
; \
160
9
      else \
161
9
        DELEGATE(CLASS); \
162
9
    }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitRet(llvm::ReturnInst&)
Line
Count
Source
157
95
    RetTy visit##OPCODE(CLASS &I) { \
158
95
      if (NUM == Instruction::Call) \
159
95
        
return delegateCallInst(I)0
; \
160
95
      else \
161
95
        DELEGATE(CLASS); \
162
95
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitBr(llvm::BranchInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitSwitch(llvm::SwitchInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitIndirectBr(llvm::IndirectBrInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitInvoke(llvm::InvokeInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitResume(llvm::ResumeInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitUnreachable(llvm::UnreachableInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitCleanupRet(llvm::CleanupReturnInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitCatchRet(llvm::CatchReturnInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitCatchSwitch(llvm::CatchSwitchInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitCallBr(llvm::CallBrInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitFNeg(llvm::UnaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitAdd(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitFAdd(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitSub(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitFSub(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitMul(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitFMul(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitUDiv(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitSDiv(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitFDiv(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitURem(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitSRem(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitFRem(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitShl(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitLShr(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitAShr(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitAnd(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitOr(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitXor(llvm::BinaryOperator&)
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitAlloca(llvm::AllocaInst&)
Line
Count
Source
157
125
    RetTy visit##OPCODE(CLASS &I) { \
158
125
      if (NUM == Instruction::Call) \
159
125
        
return delegateCallInst(I)0
; \
160
125
      else \
161
125
        DELEGATE(CLASS); \
162
125
    }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitLoad(llvm::LoadInst&)
Line
Count
Source
157
79
    RetTy visit##OPCODE(CLASS &I) { \
158
79
      if (NUM == Instruction::Call) \
159
79
        
return delegateCallInst(I)0
; \
160
79
      else \
161
79
        DELEGATE(CLASS); \
162
79
    }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitStore(llvm::StoreInst&)
Line
Count
Source
157
67
    RetTy visit##OPCODE(CLASS &I) { \
158
67
      if (NUM == Instruction::Call) \
159
67
        
return delegateCallInst(I)0
; \
160
67
      else \
161
67
        DELEGATE(CLASS); \
162
67
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitGetElementPtr(llvm::GetElementPtrInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitFence(llvm::FenceInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitAtomicCmpXchg(llvm::AtomicCmpXchgInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitAtomicRMW(llvm::AtomicRMWInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitTrunc(llvm::TruncInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitZExt(llvm::ZExtInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitSExt(llvm::SExtInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitFPToUI(llvm::FPToUIInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitFPToSI(llvm::FPToSIInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitUIToFP(llvm::UIToFPInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitSIToFP(llvm::SIToFPInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitFPTrunc(llvm::FPTruncInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitFPExt(llvm::FPExtInst&)
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitPtrToInt(llvm::PtrToIntInst&)
Line
Count
Source
157
6
    RetTy visit##OPCODE(CLASS &I) { \
158
6
      if (NUM == Instruction::Call) \
159
6
        
return delegateCallInst(I)0
; \
160
6
      else \
161
6
        DELEGATE(CLASS); \
162
6
    }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitIntToPtr(llvm::IntToPtrInst&)
Line
Count
Source
157
4
    RetTy visit##OPCODE(CLASS &I) { \
158
4
      if (NUM == Instruction::Call) \
159
4
        
return delegateCallInst(I)0
; \
160
4
      else \
161
4
        DELEGATE(CLASS); \
162
4
    }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitBitCast(llvm::BitCastInst&)
Line
Count
Source
157
27
    RetTy visit##OPCODE(CLASS &I) { \
158
27
      if (NUM == Instruction::Call) \
159
27
        
return delegateCallInst(I)0
; \
160
27
      else \
161
27
        DELEGATE(CLASS); \
162
27
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitAddrSpaceCast(llvm::AddrSpaceCastInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitCleanupPad(llvm::CleanupPadInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitCatchPad(llvm::CatchPadInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitICmp(llvm::ICmpInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitFCmp(llvm::FCmpInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitPHI(llvm::PHINode&)
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitCall(llvm::CallInst&)
Line
Count
Source
157
65
    RetTy visit##OPCODE(CLASS &I) { \
158
65
      if (NUM == Instruction::Call) \
159
65
        return delegateCallInst(I); \
160
65
      else \
161
65
        
DELEGATE0
(CLASS); \
162
65
    }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitSelect(llvm::SelectInst&)
Line
Count
Source
157
6
    RetTy visit##OPCODE(CLASS &I) { \
158
6
      if (NUM == Instruction::Call) \
159
6
        
return delegateCallInst(I)0
; \
160
6
      else \
161
6
        DELEGATE(CLASS); \
162
6
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitUserOp1(llvm::Instruction&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitUserOp2(llvm::Instruction&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitVAArg(llvm::VAArgInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitExtractElement(llvm::ExtractElementInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitInsertElement(llvm::InsertElementInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitShuffleVector(llvm::ShuffleVectorInst&)
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitExtractValue(llvm::ExtractValueInst&)
Line
Count
Source
157
1
    RetTy visit##OPCODE(CLASS &I) { \
158
1
      if (NUM == Instruction::Call) \
159
1
        
return delegateCallInst(I)0
; \
160
1
      else \
161
1
        DELEGATE(CLASS); \
162
1
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitInsertValue(llvm::InsertValueInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLAndersAAResult>::GetEdgesVisitor, void>::visitLandingPad(llvm::LandingPadInst&)
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitRet(llvm::ReturnInst&)
Line
Count
Source
157
116
    RetTy visit##OPCODE(CLASS &I) { \
158
116
      if (NUM == Instruction::Call) \
159
116
        
return delegateCallInst(I)0
; \
160
116
      else \
161
116
        DELEGATE(CLASS); \
162
116
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitBr(llvm::BranchInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitSwitch(llvm::SwitchInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitIndirectBr(llvm::IndirectBrInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitInvoke(llvm::InvokeInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitResume(llvm::ResumeInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitUnreachable(llvm::UnreachableInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitCleanupRet(llvm::CleanupReturnInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitCatchRet(llvm::CatchReturnInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitCatchSwitch(llvm::CatchSwitchInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitCallBr(llvm::CallBrInst&)
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitFNeg(llvm::UnaryOperator&)
Line
Count
Source
157
1
    RetTy visit##OPCODE(CLASS &I) { \
158
1
      if (NUM == Instruction::Call) \
159
1
        
return delegateCallInst(I)0
; \
160
1
      else \
161
1
        DELEGATE(CLASS); \
162
1
    }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitAdd(llvm::BinaryOperator&)
Line
Count
Source
157
4
    RetTy visit##OPCODE(CLASS &I) { \
158
4
      if (NUM == Instruction::Call) \
159
4
        
return delegateCallInst(I)0
; \
160
4
      else \
161
4
        DELEGATE(CLASS); \
162
4
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitFAdd(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitSub(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitFSub(llvm::BinaryOperator&)
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitMul(llvm::BinaryOperator&)
Line
Count
Source
157
1
    RetTy visit##OPCODE(CLASS &I) { \
158
1
      if (NUM == Instruction::Call) \
159
1
        
return delegateCallInst(I)0
; \
160
1
      else \
161
1
        DELEGATE(CLASS); \
162
1
    }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitFMul(llvm::BinaryOperator&)
Line
Count
Source
157
1
    RetTy visit##OPCODE(CLASS &I) { \
158
1
      if (NUM == Instruction::Call) \
159
1
        
return delegateCallInst(I)0
; \
160
1
      else \
161
1
        DELEGATE(CLASS); \
162
1
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitUDiv(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitSDiv(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitFDiv(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitURem(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitSRem(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitFRem(llvm::BinaryOperator&)
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitShl(llvm::BinaryOperator&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitLShr(llvm::BinaryOperator&)
Line
Count
Source
157
1
    RetTy visit##OPCODE(CLASS &I) { \
158
1
      if (NUM == Instruction::Call) \
159
1
        
return delegateCallInst(I)0
; \
160
1
      else \
161
1
        DELEGATE(CLASS); \
162
1
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitAShr(llvm::BinaryOperator&)
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitAnd(llvm::BinaryOperator&)
Line
Count
Source
157
1
    RetTy visit##OPCODE(CLASS &I) { \
158
1
      if (NUM == Instruction::Call) \
159
1
        
return delegateCallInst(I)0
; \
160
1
      else \
161
1
        DELEGATE(CLASS); \
162
1
    }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitOr(llvm::BinaryOperator&)
Line
Count
Source
157
1
    RetTy visit##OPCODE(CLASS &I) { \
158
1
      if (NUM == Instruction::Call) \
159
1
        
return delegateCallInst(I)0
; \
160
1
      else \
161
1
        DELEGATE(CLASS); \
162
1
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitXor(llvm::BinaryOperator&)
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitAlloca(llvm::AllocaInst&)
Line
Count
Source
157
128
    RetTy visit##OPCODE(CLASS &I) { \
158
128
      if (NUM == Instruction::Call) \
159
128
        
return delegateCallInst(I)0
; \
160
128
      else \
161
128
        DELEGATE(CLASS); \
162
128
    }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitLoad(llvm::LoadInst&)
Line
Count
Source
157
87
    RetTy visit##OPCODE(CLASS &I) { \
158
87
      if (NUM == Instruction::Call) \
159
87
        
return delegateCallInst(I)0
; \
160
87
      else \
161
87
        DELEGATE(CLASS); \
162
87
    }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitStore(llvm::StoreInst&)
Line
Count
Source
157
87
    RetTy visit##OPCODE(CLASS &I) { \
158
87
      if (NUM == Instruction::Call) \
159
87
        
return delegateCallInst(I)0
; \
160
87
      else \
161
87
        DELEGATE(CLASS); \
162
87
    }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitGetElementPtr(llvm::GetElementPtrInst&)
Line
Count
Source
157
21
    RetTy visit##OPCODE(CLASS &I) { \
158
21
      if (NUM == Instruction::Call) \
159
21
        
return delegateCallInst(I)0
; \
160
21
      else \
161
21
        DELEGATE(CLASS); \
162
21
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitFence(llvm::FenceInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitAtomicCmpXchg(llvm::AtomicCmpXchgInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitAtomicRMW(llvm::AtomicRMWInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitTrunc(llvm::TruncInst&)
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitZExt(llvm::ZExtInst&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitSExt(llvm::SExtInst&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitFPToUI(llvm::FPToUIInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitFPToSI(llvm::FPToSIInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitUIToFP(llvm::UIToFPInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitSIToFP(llvm::SIToFPInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitFPTrunc(llvm::FPTruncInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitFPExt(llvm::FPExtInst&)
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitPtrToInt(llvm::PtrToIntInst&)
Line
Count
Source
157
5
    RetTy visit##OPCODE(CLASS &I) { \
158
5
      if (NUM == Instruction::Call) \
159
5
        
return delegateCallInst(I)0
; \
160
5
      else \
161
5
        DELEGATE(CLASS); \
162
5
    }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitIntToPtr(llvm::IntToPtrInst&)
Line
Count
Source
157
3
    RetTy visit##OPCODE(CLASS &I) { \
158
3
      if (NUM == Instruction::Call) \
159
3
        
return delegateCallInst(I)0
; \
160
3
      else \
161
3
        DELEGATE(CLASS); \
162
3
    }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitBitCast(llvm::BitCastInst&)
Line
Count
Source
157
20
    RetTy visit##OPCODE(CLASS &I) { \
158
20
      if (NUM == Instruction::Call) \
159
20
        
return delegateCallInst(I)0
; \
160
20
      else \
161
20
        DELEGATE(CLASS); \
162
20
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitAddrSpaceCast(llvm::AddrSpaceCastInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitCleanupPad(llvm::CleanupPadInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitCatchPad(llvm::CatchPadInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitICmp(llvm::ICmpInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitFCmp(llvm::FCmpInst&)
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitPHI(llvm::PHINode&)
Line
Count
Source
157
4
    RetTy visit##OPCODE(CLASS &I) { \
158
4
      if (NUM == Instruction::Call) \
159
4
        
return delegateCallInst(I)0
; \
160
4
      else \
161
4
        DELEGATE(CLASS); \
162
4
    }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitCall(llvm::CallInst&)
Line
Count
Source
157
78
    RetTy visit##OPCODE(CLASS &I) { \
158
78
      if (NUM == Instruction::Call) \
159
78
        return delegateCallInst(I); \
160
78
      else \
161
78
        
DELEGATE0
(CLASS); \
162
78
    }
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitSelect(llvm::SelectInst&)
Line
Count
Source
157
13
    RetTy visit##OPCODE(CLASS &I) { \
158
13
      if (NUM == Instruction::Call) \
159
13
        
return delegateCallInst(I)0
; \
160
13
      else \
161
13
        DELEGATE(CLASS); \
162
13
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitUserOp1(llvm::Instruction&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitUserOp2(llvm::Instruction&)
llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitVAArg(llvm::VAArgInst&)
Line
Count
Source
157
1
    RetTy visit##OPCODE(CLASS &I) { \
158
1
      if (NUM == Instruction::Call) \
159
1
        
return delegateCallInst(I)0
; \
160
1
      else \
161
1
        DELEGATE(CLASS); \
162
1
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitExtractElement(llvm::ExtractElementInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitInsertElement(llvm::InsertElementInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitShuffleVector(llvm::ShuffleVectorInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitExtractValue(llvm::ExtractValueInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitInsertValue(llvm::InsertValueInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::cflaa::CFLGraphBuilder<llvm::CFLSteensAAResult>::GetEdgesVisitor, void>::visitLandingPad(llvm::LandingPadInst&)
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitRet(llvm::ReturnInst&)
Line
Count
Source
157
1.19k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.19k
      if (NUM == Instruction::Call) \
159
1.19k
        
return delegateCallInst(I)0
; \
160
1.19k
      else \
161
1.19k
        DELEGATE(CLASS); \
162
1.19k
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitBr(llvm::BranchInst&)
Line
Count
Source
157
614
    RetTy visit##OPCODE(CLASS &I) { \
158
614
      if (NUM == Instruction::Call) \
159
614
        
return delegateCallInst(I)0
; \
160
614
      else \
161
614
        DELEGATE(CLASS); \
162
614
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitSwitch(llvm::SwitchInst&)
Line
Count
Source
157
10
    RetTy visit##OPCODE(CLASS &I) { \
158
10
      if (NUM == Instruction::Call) \
159
10
        
return delegateCallInst(I)0
; \
160
10
      else \
161
10
        DELEGATE(CLASS); \
162
10
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitIndirectBr(llvm::IndirectBrInst&)
Line
Count
Source
157
6
    RetTy visit##OPCODE(CLASS &I) { \
158
6
      if (NUM == Instruction::Call) \
159
6
        
return delegateCallInst(I)0
; \
160
6
      else \
161
6
        DELEGATE(CLASS); \
162
6
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitInvoke(llvm::InvokeInst&)
Line
Count
Source
157
34
    RetTy visit##OPCODE(CLASS &I) { \
158
34
      if (NUM == Instruction::Call) \
159
34
        
return delegateCallInst(I)0
; \
160
34
      else \
161
34
        DELEGATE(CLASS); \
162
34
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitResume(llvm::ResumeInst&)
Line
Count
Source
157
12
    RetTy visit##OPCODE(CLASS &I) { \
158
12
      if (NUM == Instruction::Call) \
159
12
        
return delegateCallInst(I)0
; \
160
12
      else \
161
12
        DELEGATE(CLASS); \
162
12
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitUnreachable(llvm::UnreachableInst&)
Line
Count
Source
157
17
    RetTy visit##OPCODE(CLASS &I) { \
158
17
      if (NUM == Instruction::Call) \
159
17
        
return delegateCallInst(I)0
; \
160
17
      else \
161
17
        DELEGATE(CLASS); \
162
17
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitCleanupRet(llvm::CleanupReturnInst&)
Line
Count
Source
157
4
    RetTy visit##OPCODE(CLASS &I) { \
158
4
      if (NUM == Instruction::Call) \
159
4
        
return delegateCallInst(I)0
; \
160
4
      else \
161
4
        DELEGATE(CLASS); \
162
4
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitCatchRet(llvm::CatchReturnInst&)
Line
Count
Source
157
8
    RetTy visit##OPCODE(CLASS &I) { \
158
8
      if (NUM == Instruction::Call) \
159
8
        
return delegateCallInst(I)0
; \
160
8
      else \
161
8
        DELEGATE(CLASS); \
162
8
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitCatchSwitch(llvm::CatchSwitchInst&)
Line
Count
Source
157
8
    RetTy visit##OPCODE(CLASS &I) { \
158
8
      if (NUM == Instruction::Call) \
159
8
        
return delegateCallInst(I)0
; \
160
8
      else \
161
8
        DELEGATE(CLASS); \
162
8
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitCallBr(llvm::CallBrInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitFNeg(llvm::UnaryOperator&)
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitAdd(llvm::BinaryOperator&)
Line
Count
Source
157
278
    RetTy visit##OPCODE(CLASS &I) { \
158
278
      if (NUM == Instruction::Call) \
159
278
        
return delegateCallInst(I)0
; \
160
278
      else \
161
278
        DELEGATE(CLASS); \
162
278
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitFAdd(llvm::BinaryOperator&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitSub(llvm::BinaryOperator&)
Line
Count
Source
157
26
    RetTy visit##OPCODE(CLASS &I) { \
158
26
      if (NUM == Instruction::Call) \
159
26
        
return delegateCallInst(I)0
; \
160
26
      else \
161
26
        DELEGATE(CLASS); \
162
26
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitFSub(llvm::BinaryOperator&)
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitMul(llvm::BinaryOperator&)
Line
Count
Source
157
24
    RetTy visit##OPCODE(CLASS &I) { \
158
24
      if (NUM == Instruction::Call) \
159
24
        
return delegateCallInst(I)0
; \
160
24
      else \
161
24
        DELEGATE(CLASS); \
162
24
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitFMul(llvm::BinaryOperator&)
Line
Count
Source
157
1
    RetTy visit##OPCODE(CLASS &I) { \
158
1
      if (NUM == Instruction::Call) \
159
1
        
return delegateCallInst(I)0
; \
160
1
      else \
161
1
        DELEGATE(CLASS); \
162
1
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitUDiv(llvm::BinaryOperator&)
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitSDiv(llvm::BinaryOperator&)
Line
Count
Source
157
1
    RetTy visit##OPCODE(CLASS &I) { \
158
1
      if (NUM == Instruction::Call) \
159
1
        
return delegateCallInst(I)0
; \
160
1
      else \
161
1
        DELEGATE(CLASS); \
162
1
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitFDiv(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitURem(llvm::BinaryOperator&)
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitSRem(llvm::BinaryOperator&)
Line
Count
Source
157
20
    RetTy visit##OPCODE(CLASS &I) { \
158
20
      if (NUM == Instruction::Call) \
159
20
        
return delegateCallInst(I)0
; \
160
20
      else \
161
20
        DELEGATE(CLASS); \
162
20
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitFRem(llvm::BinaryOperator&)
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitShl(llvm::BinaryOperator&)
Line
Count
Source
157
5
    RetTy visit##OPCODE(CLASS &I) { \
158
5
      if (NUM == Instruction::Call) \
159
5
        
return delegateCallInst(I)0
; \
160
5
      else \
161
5
        DELEGATE(CLASS); \
162
5
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitLShr(llvm::BinaryOperator&)
Line
Count
Source
157
5
    RetTy visit##OPCODE(CLASS &I) { \
158
5
      if (NUM == Instruction::Call) \
159
5
        
return delegateCallInst(I)0
; \
160
5
      else \
161
5
        DELEGATE(CLASS); \
162
5
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitAShr(llvm::BinaryOperator&)
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitAnd(llvm::BinaryOperator&)
Line
Count
Source
157
3
    RetTy visit##OPCODE(CLASS &I) { \
158
3
      if (NUM == Instruction::Call) \
159
3
        
return delegateCallInst(I)0
; \
160
3
      else \
161
3
        DELEGATE(CLASS); \
162
3
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitOr(llvm::BinaryOperator&)
Line
Count
Source
157
6
    RetTy visit##OPCODE(CLASS &I) { \
158
6
      if (NUM == Instruction::Call) \
159
6
        
return delegateCallInst(I)0
; \
160
6
      else \
161
6
        DELEGATE(CLASS); \
162
6
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitXor(llvm::BinaryOperator&)
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitAlloca(llvm::AllocaInst&)
Line
Count
Source
157
65
    RetTy visit##OPCODE(CLASS &I) { \
158
65
      if (NUM == Instruction::Call) \
159
65
        
return delegateCallInst(I)0
; \
160
65
      else \
161
65
        DELEGATE(CLASS); \
162
65
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitLoad(llvm::LoadInst&)
Line
Count
Source
157
415
    RetTy visit##OPCODE(CLASS &I) { \
158
415
      if (NUM == Instruction::Call) \
159
415
        
return delegateCallInst(I)0
; \
160
415
      else \
161
415
        DELEGATE(CLASS); \
162
415
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitStore(llvm::StoreInst&)
Line
Count
Source
157
199
    RetTy visit##OPCODE(CLASS &I) { \
158
199
      if (NUM == Instruction::Call) \
159
199
        
return delegateCallInst(I)0
; \
160
199
      else \
161
199
        DELEGATE(CLASS); \
162
199
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitGetElementPtr(llvm::GetElementPtrInst&)
Line
Count
Source
157
113
    RetTy visit##OPCODE(CLASS &I) { \
158
113
      if (NUM == Instruction::Call) \
159
113
        
return delegateCallInst(I)0
; \
160
113
      else \
161
113
        DELEGATE(CLASS); \
162
113
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitFence(llvm::FenceInst&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitAtomicCmpXchg(llvm::AtomicCmpXchgInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitAtomicRMW(llvm::AtomicRMWInst&)
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitTrunc(llvm::TruncInst&)
Line
Count
Source
157
6
    RetTy visit##OPCODE(CLASS &I) { \
158
6
      if (NUM == Instruction::Call) \
159
6
        
return delegateCallInst(I)0
; \
160
6
      else \
161
6
        DELEGATE(CLASS); \
162
6
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitZExt(llvm::ZExtInst&)
Line
Count
Source
157
6
    RetTy visit##OPCODE(CLASS &I) { \
158
6
      if (NUM == Instruction::Call) \
159
6
        
return delegateCallInst(I)0
; \
160
6
      else \
161
6
        DELEGATE(CLASS); \
162
6
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitSExt(llvm::SExtInst&)
Line
Count
Source
157
14
    RetTy visit##OPCODE(CLASS &I) { \
158
14
      if (NUM == Instruction::Call) \
159
14
        
return delegateCallInst(I)0
; \
160
14
      else \
161
14
        DELEGATE(CLASS); \
162
14
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitFPToUI(llvm::FPToUIInst&)
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitFPToSI(llvm::FPToSIInst&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitUIToFP(llvm::UIToFPInst&)
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitSIToFP(llvm::SIToFPInst&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitFPTrunc(llvm::FPTruncInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitFPExt(llvm::FPExtInst&)
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitPtrToInt(llvm::PtrToIntInst&)
Line
Count
Source
157
15
    RetTy visit##OPCODE(CLASS &I) { \
158
15
      if (NUM == Instruction::Call) \
159
15
        
return delegateCallInst(I)0
; \
160
15
      else \
161
15
        DELEGATE(CLASS); \
162
15
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitIntToPtr(llvm::IntToPtrInst&)
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitBitCast(llvm::BitCastInst&)
Line
Count
Source
157
107
    RetTy visit##OPCODE(CLASS &I) { \
158
107
      if (NUM == Instruction::Call) \
159
107
        
return delegateCallInst(I)0
; \
160
107
      else \
161
107
        DELEGATE(CLASS); \
162
107
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitAddrSpaceCast(llvm::AddrSpaceCastInst&)
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitCleanupPad(llvm::CleanupPadInst&)
Line
Count
Source
157
4
    RetTy visit##OPCODE(CLASS &I) { \
158
4
      if (NUM == Instruction::Call) \
159
4
        
return delegateCallInst(I)0
; \
160
4
      else \
161
4
        DELEGATE(CLASS); \
162
4
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitCatchPad(llvm::CatchPadInst&)
Line
Count
Source
157
8
    RetTy visit##OPCODE(CLASS &I) { \
158
8
      if (NUM == Instruction::Call) \
159
8
        
return delegateCallInst(I)0
; \
160
8
      else \
161
8
        DELEGATE(CLASS); \
162
8
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitICmp(llvm::ICmpInst&)
Line
Count
Source
157
258
    RetTy visit##OPCODE(CLASS &I) { \
158
258
      if (NUM == Instruction::Call) \
159
258
        
return delegateCallInst(I)0
; \
160
258
      else \
161
258
        DELEGATE(CLASS); \
162
258
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitFCmp(llvm::FCmpInst&)
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitPHI(llvm::PHINode&)
Line
Count
Source
157
202
    RetTy visit##OPCODE(CLASS &I) { \
158
202
      if (NUM == Instruction::Call) \
159
202
        
return delegateCallInst(I)0
; \
160
202
      else \
161
202
        DELEGATE(CLASS); \
162
202
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitCall(llvm::CallInst&)
Line
Count
Source
157
721
    RetTy visit##OPCODE(CLASS &I) { \
158
721
      if (NUM == Instruction::Call) \
159
721
        return delegateCallInst(I); \
160
721
      else \
161
721
        
DELEGATE0
(CLASS); \
162
721
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitSelect(llvm::SelectInst&)
Line
Count
Source
157
46
    RetTy visit##OPCODE(CLASS &I) { \
158
46
      if (NUM == Instruction::Call) \
159
46
        
return delegateCallInst(I)0
; \
160
46
      else \
161
46
        DELEGATE(CLASS); \
162
46
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitUserOp1(llvm::Instruction&)
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitUserOp2(llvm::Instruction&)
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitVAArg(llvm::VAArgInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitExtractElement(llvm::ExtractElementInst&)
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitInsertElement(llvm::InsertElementInst&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitShuffleVector(llvm::ShuffleVectorInst&)
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitExtractValue(llvm::ExtractValueInst&)
Line
Count
Source
157
36
    RetTy visit##OPCODE(CLASS &I) { \
158
36
      if (NUM == Instruction::Call) \
159
36
        
return delegateCallInst(I)0
; \
160
36
      else \
161
36
        DELEGATE(CLASS); \
162
36
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitInsertValue(llvm::InsertValueInst&)
Line
Count
Source
157
16
    RetTy visit##OPCODE(CLASS &I) { \
158
16
      if (NUM == Instruction::Call) \
159
16
        
return delegateCallInst(I)0
; \
160
16
      else \
161
16
        DELEGATE(CLASS); \
162
16
    }
llvm::InstVisitor<llvm::PGOIndirectCallVisitor, void>::visitLandingPad(llvm::LandingPadInst&)
Line
Count
Source
157
14
    RetTy visit##OPCODE(CLASS &I) { \
158
14
      if (NUM == Instruction::Call) \
159
14
        
return delegateCallInst(I)0
; \
160
14
      else \
161
14
        DELEGATE(CLASS); \
162
14
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitRet(llvm::ReturnInst&)
Line
Count
Source
157
766k
    RetTy visit##OPCODE(CLASS &I) { \
158
766k
      if (NUM == Instruction::Call) \
159
766k
        
return delegateCallInst(I)0
; \
160
766k
      else \
161
766k
        DELEGATE(CLASS); \
162
766k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitBr(llvm::BranchInst&)
Line
Count
Source
157
3.79M
    RetTy visit##OPCODE(CLASS &I) { \
158
3.79M
      if (NUM == Instruction::Call) \
159
3.79M
        
return delegateCallInst(I)0
; \
160
3.79M
      else \
161
3.79M
        DELEGATE(CLASS); \
162
3.79M
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitSwitch(llvm::SwitchInst&)
Line
Count
Source
157
48.6k
    RetTy visit##OPCODE(CLASS &I) { \
158
48.6k
      if (NUM == Instruction::Call) \
159
48.6k
        
return delegateCallInst(I)0
; \
160
48.6k
      else \
161
48.6k
        DELEGATE(CLASS); \
162
48.6k
    }
Unexecuted instantiation: InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitIndirectBr(llvm::IndirectBrInst&)
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitInvoke(llvm::InvokeInst&)
Line
Count
Source
157
205k
    RetTy visit##OPCODE(CLASS &I) { \
158
205k
      if (NUM == Instruction::Call) \
159
205k
        
return delegateCallInst(I)0
; \
160
205k
      else \
161
205k
        DELEGATE(CLASS); \
162
205k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitResume(llvm::ResumeInst&)
Line
Count
Source
157
30.8k
    RetTy visit##OPCODE(CLASS &I) { \
158
30.8k
      if (NUM == Instruction::Call) \
159
30.8k
        
return delegateCallInst(I)0
; \
160
30.8k
      else \
161
30.8k
        DELEGATE(CLASS); \
162
30.8k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitUnreachable(llvm::UnreachableInst&)
Line
Count
Source
157
184k
    RetTy visit##OPCODE(CLASS &I) { \
158
184k
      if (NUM == Instruction::Call) \
159
184k
        
return delegateCallInst(I)0
; \
160
184k
      else \
161
184k
        DELEGATE(CLASS); \
162
184k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitCleanupRet(llvm::CleanupReturnInst&)
Line
Count
Source
157
4
    RetTy visit##OPCODE(CLASS &I) { \
158
4
      if (NUM == Instruction::Call) \
159
4
        
return delegateCallInst(I)0
; \
160
4
      else \
161
4
        DELEGATE(CLASS); \
162
4
    }
Unexecuted instantiation: InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitCatchRet(llvm::CatchReturnInst&)
Unexecuted instantiation: InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitCatchSwitch(llvm::CatchSwitchInst&)
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitCallBr(llvm::CallBrInst&)
Line
Count
Source
157
6
    RetTy visit##OPCODE(CLASS &I) { \
158
6
      if (NUM == Instruction::Call) \
159
6
        
return delegateCallInst(I)0
; \
160
6
      else \
161
6
        DELEGATE(CLASS); \
162
6
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitAdd(llvm::BinaryOperator&)
Line
Count
Source
157
984k
    RetTy visit##OPCODE(CLASS &I) { \
158
984k
      if (NUM == Instruction::Call) \
159
984k
        
return delegateCallInst(I)0
; \
160
984k
      else \
161
984k
        DELEGATE(CLASS); \
162
984k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitFAdd(llvm::BinaryOperator&)
Line
Count
Source
157
151k
    RetTy visit##OPCODE(CLASS &I) { \
158
151k
      if (NUM == Instruction::Call) \
159
151k
        
return delegateCallInst(I)0
; \
160
151k
      else \
161
151k
        DELEGATE(CLASS); \
162
151k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitSub(llvm::BinaryOperator&)
Line
Count
Source
157
240k
    RetTy visit##OPCODE(CLASS &I) { \
158
240k
      if (NUM == Instruction::Call) \
159
240k
        
return delegateCallInst(I)0
; \
160
240k
      else \
161
240k
        DELEGATE(CLASS); \
162
240k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitFSub(llvm::BinaryOperator&)
Line
Count
Source
157
28.2k
    RetTy visit##OPCODE(CLASS &I) { \
158
28.2k
      if (NUM == Instruction::Call) \
159
28.2k
        
return delegateCallInst(I)0
; \
160
28.2k
      else \
161
28.2k
        DELEGATE(CLASS); \
162
28.2k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitMul(llvm::BinaryOperator&)
Line
Count
Source
157
98.2k
    RetTy visit##OPCODE(CLASS &I) { \
158
98.2k
      if (NUM == Instruction::Call) \
159
98.2k
        
return delegateCallInst(I)0
; \
160
98.2k
      else \
161
98.2k
        DELEGATE(CLASS); \
162
98.2k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitFMul(llvm::BinaryOperator&)
Line
Count
Source
157
134k
    RetTy visit##OPCODE(CLASS &I) { \
158
134k
      if (NUM == Instruction::Call) \
159
134k
        
return delegateCallInst(I)0
; \
160
134k
      else \
161
134k
        DELEGATE(CLASS); \
162
134k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitUDiv(llvm::BinaryOperator&)
Line
Count
Source
157
13.6k
    RetTy visit##OPCODE(CLASS &I) { \
158
13.6k
      if (NUM == Instruction::Call) \
159
13.6k
        
return delegateCallInst(I)0
; \
160
13.6k
      else \
161
13.6k
        DELEGATE(CLASS); \
162
13.6k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitSDiv(llvm::BinaryOperator&)
Line
Count
Source
157
45.4k
    RetTy visit##OPCODE(CLASS &I) { \
158
45.4k
      if (NUM == Instruction::Call) \
159
45.4k
        
return delegateCallInst(I)0
; \
160
45.4k
      else \
161
45.4k
        DELEGATE(CLASS); \
162
45.4k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitFDiv(llvm::BinaryOperator&)
Line
Count
Source
157
26.2k
    RetTy visit##OPCODE(CLASS &I) { \
158
26.2k
      if (NUM == Instruction::Call) \
159
26.2k
        
return delegateCallInst(I)0
; \
160
26.2k
      else \
161
26.2k
        DELEGATE(CLASS); \
162
26.2k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitURem(llvm::BinaryOperator&)
Line
Count
Source
157
13.0k
    RetTy visit##OPCODE(CLASS &I) { \
158
13.0k
      if (NUM == Instruction::Call) \
159
13.0k
        
return delegateCallInst(I)0
; \
160
13.0k
      else \
161
13.0k
        DELEGATE(CLASS); \
162
13.0k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitSRem(llvm::BinaryOperator&)
Line
Count
Source
157
2.98k
    RetTy visit##OPCODE(CLASS &I) { \
158
2.98k
      if (NUM == Instruction::Call) \
159
2.98k
        
return delegateCallInst(I)0
; \
160
2.98k
      else \
161
2.98k
        DELEGATE(CLASS); \
162
2.98k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitFRem(llvm::BinaryOperator&)
Line
Count
Source
157
160
    RetTy visit##OPCODE(CLASS &I) { \
158
160
      if (NUM == Instruction::Call) \
159
160
        
return delegateCallInst(I)0
; \
160
160
      else \
161
160
        DELEGATE(CLASS); \
162
160
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitShl(llvm::BinaryOperator&)
Line
Count
Source
157
152k
    RetTy visit##OPCODE(CLASS &I) { \
158
152k
      if (NUM == Instruction::Call) \
159
152k
        
return delegateCallInst(I)0
; \
160
152k
      else \
161
152k
        DELEGATE(CLASS); \
162
152k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitLShr(llvm::BinaryOperator&)
Line
Count
Source
157
249k
    RetTy visit##OPCODE(CLASS &I) { \
158
249k
      if (NUM == Instruction::Call) \
159
249k
        
return delegateCallInst(I)0
; \
160
249k
      else \
161
249k
        DELEGATE(CLASS); \
162
249k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitAShr(llvm::BinaryOperator&)
Line
Count
Source
157
69.6k
    RetTy visit##OPCODE(CLASS &I) { \
158
69.6k
      if (NUM == Instruction::Call) \
159
69.6k
        
return delegateCallInst(I)0
; \
160
69.6k
      else \
161
69.6k
        DELEGATE(CLASS); \
162
69.6k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitAnd(llvm::BinaryOperator&)
Line
Count
Source
157
442k
    RetTy visit##OPCODE(CLASS &I) { \
158
442k
      if (NUM == Instruction::Call) \
159
442k
        
return delegateCallInst(I)0
; \
160
442k
      else \
161
442k
        DELEGATE(CLASS); \
162
442k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitOr(llvm::BinaryOperator&)
Line
Count
Source
157
146k
    RetTy visit##OPCODE(CLASS &I) { \
158
146k
      if (NUM == Instruction::Call) \
159
146k
        
return delegateCallInst(I)0
; \
160
146k
      else \
161
146k
        DELEGATE(CLASS); \
162
146k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitXor(llvm::BinaryOperator&)
Line
Count
Source
157
72.9k
    RetTy visit##OPCODE(CLASS &I) { \
158
72.9k
      if (NUM == Instruction::Call) \
159
72.9k
        
return delegateCallInst(I)0
; \
160
72.9k
      else \
161
72.9k
        DELEGATE(CLASS); \
162
72.9k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitAlloca(llvm::AllocaInst&)
Line
Count
Source
157
708k
    RetTy visit##OPCODE(CLASS &I) { \
158
708k
      if (NUM == Instruction::Call) \
159
708k
        
return delegateCallInst(I)0
; \
160
708k
      else \
161
708k
        DELEGATE(CLASS); \
162
708k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitFence(llvm::FenceInst&)
Line
Count
Source
157
13.1k
    RetTy visit##OPCODE(CLASS &I) { \
158
13.1k
      if (NUM == Instruction::Call) \
159
13.1k
        
return delegateCallInst(I)0
; \
160
13.1k
      else \
161
13.1k
        DELEGATE(CLASS); \
162
13.1k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitAtomicCmpXchg(llvm::AtomicCmpXchgInst&)
Line
Count
Source
157
2.76k
    RetTy visit##OPCODE(CLASS &I) { \
158
2.76k
      if (NUM == Instruction::Call) \
159
2.76k
        
return delegateCallInst(I)0
; \
160
2.76k
      else \
161
2.76k
        DELEGATE(CLASS); \
162
2.76k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitAtomicRMW(llvm::AtomicRMWInst&)
Line
Count
Source
157
26.7k
    RetTy visit##OPCODE(CLASS &I) { \
158
26.7k
      if (NUM == Instruction::Call) \
159
26.7k
        
return delegateCallInst(I)0
; \
160
26.7k
      else \
161
26.7k
        DELEGATE(CLASS); \
162
26.7k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitTrunc(llvm::TruncInst&)
Line
Count
Source
157
180k
    RetTy visit##OPCODE(CLASS &I) { \
158
180k
      if (NUM == Instruction::Call) \
159
180k
        
return delegateCallInst(I)0
; \
160
180k
      else \
161
180k
        DELEGATE(CLASS); \
162
180k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitZExt(llvm::ZExtInst&)
Line
Count
Source
157
240k
    RetTy visit##OPCODE(CLASS &I) { \
158
240k
      if (NUM == Instruction::Call) \
159
240k
        
return delegateCallInst(I)0
; \
160
240k
      else \
161
240k
        DELEGATE(CLASS); \
162
240k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitSExt(llvm::SExtInst&)
Line
Count
Source
157
307k
    RetTy visit##OPCODE(CLASS &I) { \
158
307k
      if (NUM == Instruction::Call) \
159
307k
        
return delegateCallInst(I)0
; \
160
307k
      else \
161
307k
        DELEGATE(CLASS); \
162
307k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitFPToUI(llvm::FPToUIInst&)
Line
Count
Source
157
1.83k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.83k
      if (NUM == Instruction::Call) \
159
1.83k
        
return delegateCallInst(I)0
; \
160
1.83k
      else \
161
1.83k
        DELEGATE(CLASS); \
162
1.83k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitFPToSI(llvm::FPToSIInst&)
Line
Count
Source
157
4.56k
    RetTy visit##OPCODE(CLASS &I) { \
158
4.56k
      if (NUM == Instruction::Call) \
159
4.56k
        
return delegateCallInst(I)0
; \
160
4.56k
      else \
161
4.56k
        DELEGATE(CLASS); \
162
4.56k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitUIToFP(llvm::UIToFPInst&)
Line
Count
Source
157
6.77k
    RetTy visit##OPCODE(CLASS &I) { \
158
6.77k
      if (NUM == Instruction::Call) \
159
6.77k
        
return delegateCallInst(I)0
; \
160
6.77k
      else \
161
6.77k
        DELEGATE(CLASS); \
162
6.77k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitSIToFP(llvm::SIToFPInst&)
Line
Count
Source
157
27.6k
    RetTy visit##OPCODE(CLASS &I) { \
158
27.6k
      if (NUM == Instruction::Call) \
159
27.6k
        
return delegateCallInst(I)0
; \
160
27.6k
      else \
161
27.6k
        DELEGATE(CLASS); \
162
27.6k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitFPTrunc(llvm::FPTruncInst&)
Line
Count
Source
157
879
    RetTy visit##OPCODE(CLASS &I) { \
158
879
      if (NUM == Instruction::Call) \
159
879
        
return delegateCallInst(I)0
; \
160
879
      else \
161
879
        DELEGATE(CLASS); \
162
879
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitFPExt(llvm::FPExtInst&)
Line
Count
Source
157
2.29k
    RetTy visit##OPCODE(CLASS &I) { \
158
2.29k
      if (NUM == Instruction::Call) \
159
2.29k
        
return delegateCallInst(I)0
; \
160
2.29k
      else \
161
2.29k
        DELEGATE(CLASS); \
162
2.29k
    }
Unexecuted instantiation: InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitAddrSpaceCast(llvm::AddrSpaceCastInst&)
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitCleanupPad(llvm::CleanupPadInst&)
Line
Count
Source
157
6
    RetTy visit##OPCODE(CLASS &I) { \
158
6
      if (NUM == Instruction::Call) \
159
6
        
return delegateCallInst(I)0
; \
160
6
      else \
161
6
        DELEGATE(CLASS); \
162
6
    }
Unexecuted instantiation: InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitCatchPad(llvm::CatchPadInst&)
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitICmp(llvm::ICmpInst&)
Line
Count
Source
157
2.57M
    RetTy visit##OPCODE(CLASS &I) { \
158
2.57M
      if (NUM == Instruction::Call) \
159
2.57M
        
return delegateCallInst(I)0
; \
160
2.57M
      else \
161
2.57M
        DELEGATE(CLASS); \
162
2.57M
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitFCmp(llvm::FCmpInst&)
Line
Count
Source
157
24.9k
    RetTy visit##OPCODE(CLASS &I) { \
158
24.9k
      if (NUM == Instruction::Call) \
159
24.9k
        
return delegateCallInst(I)0
; \
160
24.9k
      else \
161
24.9k
        DELEGATE(CLASS); \
162
24.9k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitCall(llvm::CallInst&)
Line
Count
Source
157
2.76M
    RetTy visit##OPCODE(CLASS &I) { \
158
2.76M
      if (NUM == Instruction::Call) \
159
2.76M
        return delegateCallInst(I); \
160
2.76M
      else \
161
2.76M
        
DELEGATE0
(CLASS); \
162
2.76M
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitSelect(llvm::SelectInst&)
Line
Count
Source
157
164k
    RetTy visit##OPCODE(CLASS &I) { \
158
164k
      if (NUM == Instruction::Call) \
159
164k
        
return delegateCallInst(I)0
; \
160
164k
      else \
161
164k
        DELEGATE(CLASS); \
162
164k
    }
Unexecuted instantiation: InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitUserOp1(llvm::Instruction&)
Unexecuted instantiation: InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitUserOp2(llvm::Instruction&)
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitVAArg(llvm::VAArgInst&)
Line
Count
Source
157
81
    RetTy visit##OPCODE(CLASS &I) { \
158
81
      if (NUM == Instruction::Call) \
159
81
        
return delegateCallInst(I)0
; \
160
81
      else \
161
81
        DELEGATE(CLASS); \
162
81
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitExtractElement(llvm::ExtractElementInst&)
Line
Count
Source
157
3.77k
    RetTy visit##OPCODE(CLASS &I) { \
158
3.77k
      if (NUM == Instruction::Call) \
159
3.77k
        
return delegateCallInst(I)0
; \
160
3.77k
      else \
161
3.77k
        DELEGATE(CLASS); \
162
3.77k
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitInsertElement(llvm::InsertElementInst&)
Line
Count
Source
157
206
    RetTy visit##OPCODE(CLASS &I) { \
158
206
      if (NUM == Instruction::Call) \
159
206
        
return delegateCallInst(I)0
; \
160
206
      else \
161
206
        DELEGATE(CLASS); \
162
206
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitShuffleVector(llvm::ShuffleVectorInst&)
Line
Count
Source
157
116
    RetTy visit##OPCODE(CLASS &I) { \
158
116
      if (NUM == Instruction::Call) \
159
116
        
return delegateCallInst(I)0
; \
160
116
      else \
161
116
        DELEGATE(CLASS); \
162
116
    }
InlineCost.cpp:llvm::InstVisitor<(anonymous namespace)::CallAnalyzer, bool>::visitLandingPad(llvm::LandingPadInst&)
Line
Count
Source
157
120k
    RetTy visit##OPCODE(CLASS &I) { \
158
120k
      if (NUM == Instruction::Call) \
159
120k
        
return delegateCallInst(I)0
; \
160
120k
      else \
161
120k
        DELEGATE(CLASS); \
162
120k
    }
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitRet(llvm::ReturnInst&)
Line
Count
Source
157
38
    RetTy visit##OPCODE(CLASS &I) { \
158
38
      if (NUM == Instruction::Call) \
159
38
        
return delegateCallInst(I)0
; \
160
38
      else \
161
38
        DELEGATE(CLASS); \
162
38
    }
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitBr(llvm::BranchInst&)
Line
Count
Source
157
12
    RetTy visit##OPCODE(CLASS &I) { \
158
12
      if (NUM == Instruction::Call) \
159
12
        
return delegateCallInst(I)0
; \
160
12
      else \
161
12
        DELEGATE(CLASS); \
162
12
    }
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitSwitch(llvm::SwitchInst&)
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitIndirectBr(llvm::IndirectBrInst&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitInvoke(llvm::InvokeInst&)
Line
Count
Source
157
6
    RetTy visit##OPCODE(CLASS &I) { \
158
6
      if (NUM == Instruction::Call) \
159
6
        
return delegateCallInst(I)0
; \
160
6
      else \
161
6
        DELEGATE(CLASS); \
162
6
    }
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitResume(llvm::ResumeInst&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitUnreachable(llvm::UnreachableInst&)
Line
Count
Source
157
3
    RetTy visit##OPCODE(CLASS &I) { \
158
3
      if (NUM == Instruction::Call) \
159
3
        
return delegateCallInst(I)0
; \
160
3
      else \
161
3
        DELEGATE(CLASS); \
162
3
    }
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitCleanupRet(llvm::CleanupReturnInst&)
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitCatchRet(llvm::CatchReturnInst&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitCatchSwitch(llvm::CatchSwitchInst&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitCallBr(llvm::CallBrInst&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitFNeg(llvm::UnaryOperator&)
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitAdd(llvm::BinaryOperator&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitFAdd(llvm::BinaryOperator&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitFSub(llvm::BinaryOperator&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitMul(llvm::BinaryOperator&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitFMul(llvm::BinaryOperator&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitFDiv(llvm::BinaryOperator&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitFRem(llvm::BinaryOperator&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitAnd(llvm::BinaryOperator&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitOr(llvm::BinaryOperator&)
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitAlloca(llvm::AllocaInst&)
Line
Count
Source
157
18
    RetTy visit##OPCODE(CLASS &I) { \
158
18
      if (NUM == Instruction::Call) \
159
18
        
return delegateCallInst(I)0
; \
160
18
      else \
161
18
        DELEGATE(CLASS); \
162
18
    }
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitLoad(llvm::LoadInst&)
Line
Count
Source
157
5
    RetTy visit##OPCODE(CLASS &I) { \
158
5
      if (NUM == Instruction::Call) \
159
5
        
return delegateCallInst(I)0
; \
160
5
      else \
161
5
        DELEGATE(CLASS); \
162
5
    }
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitStore(llvm::StoreInst&)
Line
Count
Source
157
13
    RetTy visit##OPCODE(CLASS &I) { \
158
13
      if (NUM == Instruction::Call) \
159
13
        
return delegateCallInst(I)0
; \
160
13
      else \
161
13
        DELEGATE(CLASS); \
162
13
    }
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitGetElementPtr(llvm::GetElementPtrInst&)
Line
Count
Source
157
4
    RetTy visit##OPCODE(CLASS &I) { \
158
4
      if (NUM == Instruction::Call) \
159
4
        
return delegateCallInst(I)0
; \
160
4
      else \
161
4
        DELEGATE(CLASS); \
162
4
    }
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitFence(llvm::FenceInst&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitAtomicCmpXchg(llvm::AtomicCmpXchgInst&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitAtomicRMW(llvm::AtomicRMWInst&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitTrunc(llvm::TruncInst&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitZExt(llvm::ZExtInst&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitSExt(llvm::SExtInst&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitFPToUI(llvm::FPToUIInst&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitFPToSI(llvm::FPToSIInst&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitUIToFP(llvm::UIToFPInst&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitSIToFP(llvm::SIToFPInst&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitFPTrunc(llvm::FPTruncInst&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitFPExt(llvm::FPExtInst&)
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitPtrToInt(llvm::PtrToIntInst&)
Line
Count
Source
157
3
    RetTy visit##OPCODE(CLASS &I) { \
158
3
      if (NUM == Instruction::Call) \
159
3
        
return delegateCallInst(I)0
; \
160
3
      else \
161
3
        DELEGATE(CLASS); \
162
3
    }
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitIntToPtr(llvm::IntToPtrInst&)
Line
Count
Source
157
3
    RetTy visit##OPCODE(CLASS &I) { \
158
3
      if (NUM == Instruction::Call) \
159
3
        
return delegateCallInst(I)0
; \
160
3
      else \
161
3
        DELEGATE(CLASS); \
162
3
    }
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitBitCast(llvm::BitCastInst&)
Line
Count
Source
157
15
    RetTy visit##OPCODE(CLASS &I) { \
158
15
      if (NUM == Instruction::Call) \
159
15
        
return delegateCallInst(I)0
; \
160
15
      else \
161
15
        DELEGATE(CLASS); \
162
15
    }
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitAddrSpaceCast(llvm::AddrSpaceCastInst&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitCleanupPad(llvm::CleanupPadInst&)
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitCatchPad(llvm::CatchPadInst&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitICmp(llvm::ICmpInst&)
Line
Count
Source
157
4
    RetTy visit##OPCODE(CLASS &I) { \
158
4
      if (NUM == Instruction::Call) \
159
4
        
return delegateCallInst(I)0
; \
160
4
      else \
161
4
        DELEGATE(CLASS); \
162
4
    }
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitFCmp(llvm::FCmpInst&)
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitPHI(llvm::PHINode&)
Line
Count
Source
157
4
    RetTy visit##OPCODE(CLASS &I) { \
158
4
      if (NUM == Instruction::Call) \
159
4
        
return delegateCallInst(I)0
; \
160
4
      else \
161
4
        DELEGATE(CLASS); \
162
4
    }
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitCall(llvm::CallInst&)
Line
Count
Source
157
50
    RetTy visit##OPCODE(CLASS &I) { \
158
50
      if (NUM == Instruction::Call) \
159
50
        return delegateCallInst(I); \
160
50
      else \
161
50
        
DELEGATE0
(CLASS); \
162
50
    }
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitSelect(llvm::SelectInst&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitUserOp1(llvm::Instruction&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitUserOp2(llvm::Instruction&)
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitVAArg(llvm::VAArgInst&)
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitExtractElement(llvm::ExtractElementInst&)
Line
Count
Source
157
1
    RetTy visit##OPCODE(CLASS &I) { \
158
1
      if (NUM == Instruction::Call) \
159
1
        
return delegateCallInst(I)0
; \
160
1
      else \
161
1
        DELEGATE(CLASS); \
162
1
    }
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitInsertElement(llvm::InsertElementInst&)
Line
Count
Source
157
1
    RetTy visit##OPCODE(CLASS &I) { \
158
1
      if (NUM == Instruction::Call) \
159
1
        
return delegateCallInst(I)0
; \
160
1
      else \
161
1
        DELEGATE(CLASS); \
162
1
    }
Unexecuted instantiation: Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitShuffleVector(llvm::ShuffleVectorInst&)
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitExtractValue(llvm::ExtractValueInst&)
Line
Count
Source
157
7
    RetTy visit##OPCODE(CLASS &I) { \
158
7
      if (NUM == Instruction::Call) \
159
7
        
return delegateCallInst(I)0
; \
160
7
      else \
161
7
        DELEGATE(CLASS); \
162
7
    }
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitInsertValue(llvm::InsertValueInst&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
Lint.cpp:llvm::InstVisitor<(anonymous namespace)::Lint, void>::visitLandingPad(llvm::LandingPadInst&)
Line
Count
Source
157
3
    RetTy visit##OPCODE(CLASS &I) { \
158
3
      if (NUM == Instruction::Call) \
159
3
        
return delegateCallInst(I)0
; \
160
3
      else \
161
3
        DELEGATE(CLASS); \
162
3
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitRet(llvm::ReturnInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitBr(llvm::BranchInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitSwitch(llvm::SwitchInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitIndirectBr(llvm::IndirectBrInst&)
llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitInvoke(llvm::InvokeInst&)
Line
Count
Source
157
164k
    RetTy visit##OPCODE(CLASS &I) { \
158
164k
      if (NUM == Instruction::Call) \
159
164k
        
return delegateCallInst(I)0
; \
160
164k
      else \
161
164k
        DELEGATE(CLASS); \
162
164k
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitResume(llvm::ResumeInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitUnreachable(llvm::UnreachableInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitCleanupRet(llvm::CleanupReturnInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitCatchRet(llvm::CatchReturnInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitCatchSwitch(llvm::CatchSwitchInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitCallBr(llvm::CallBrInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitFNeg(llvm::UnaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitAdd(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitFAdd(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitSub(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitFSub(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitMul(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitFMul(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitUDiv(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitSDiv(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitFDiv(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitURem(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitSRem(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitFRem(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitShl(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitLShr(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitAShr(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitAnd(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitOr(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitXor(llvm::BinaryOperator&)
llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitAlloca(llvm::AllocaInst&)
Line
Count
Source
157
11.1M
    RetTy visit##OPCODE(CLASS &I) { \
158
11.1M
      if (NUM == Instruction::Call) \
159
11.1M
        
return delegateCallInst(I)0
; \
160
11.1M
      else \
161
11.1M
        DELEGATE(CLASS); \
162
11.1M
    }
llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitLoad(llvm::LoadInst&)
Line
Count
Source
157
305k
    RetTy visit##OPCODE(CLASS &I) { \
158
305k
      if (NUM == Instruction::Call) \
159
305k
        
return delegateCallInst(I)0
; \
160
305k
      else \
161
305k
        DELEGATE(CLASS); \
162
305k
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitStore(llvm::StoreInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitGetElementPtr(llvm::GetElementPtrInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitFence(llvm::FenceInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitAtomicCmpXchg(llvm::AtomicCmpXchgInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitAtomicRMW(llvm::AtomicRMWInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitTrunc(llvm::TruncInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitZExt(llvm::ZExtInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitSExt(llvm::SExtInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitFPToUI(llvm::FPToUIInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitFPToSI(llvm::FPToSIInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitUIToFP(llvm::UIToFPInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitSIToFP(llvm::SIToFPInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitFPTrunc(llvm::FPTruncInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitFPExt(llvm::FPExtInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitPtrToInt(llvm::PtrToIntInst&)
llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitIntToPtr(llvm::IntToPtrInst&)
Line
Count
Source
157
5.19k
    RetTy visit##OPCODE(CLASS &I) { \
158
5.19k
      if (NUM == Instruction::Call) \
159
5.19k
        
return delegateCallInst(I)0
; \
160
5.19k
      else \
161
5.19k
        DELEGATE(CLASS); \
162
5.19k
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitBitCast(llvm::BitCastInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitAddrSpaceCast(llvm::AddrSpaceCastInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitCleanupPad(llvm::CleanupPadInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitCatchPad(llvm::CatchPadInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitICmp(llvm::ICmpInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitFCmp(llvm::FCmpInst&)
llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitPHI(llvm::PHINode&)
Line
Count
Source
157
98.8k
    RetTy visit##OPCODE(CLASS &I) { \
158
98.8k
      if (NUM == Instruction::Call) \
159
98.8k
        
return delegateCallInst(I)0
; \
160
98.8k
      else \
161
98.8k
        DELEGATE(CLASS); \
162
98.8k
    }
llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitCall(llvm::CallInst&)
Line
Count
Source
157
996k
    RetTy visit##OPCODE(CLASS &I) { \
158
996k
      if (NUM == Instruction::Call) \
159
996k
        return delegateCallInst(I); \
160
996k
      else \
161
996k
        
DELEGATE0
(CLASS); \
162
996k
    }
llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitSelect(llvm::SelectInst&)
Line
Count
Source
157
1.15k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.15k
      if (NUM == Instruction::Call) \
159
1.15k
        
return delegateCallInst(I)0
; \
160
1.15k
      else \
161
1.15k
        DELEGATE(CLASS); \
162
1.15k
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitUserOp1(llvm::Instruction&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitUserOp2(llvm::Instruction&)
llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitVAArg(llvm::VAArgInst&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitExtractElement(llvm::ExtractElementInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitInsertElement(llvm::InsertElementInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitShuffleVector(llvm::ShuffleVectorInst&)
llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitExtractValue(llvm::ExtractValueInst&)
Line
Count
Source
157
52
    RetTy visit##OPCODE(CLASS &I) { \
158
52
      if (NUM == Instruction::Call) \
159
52
        
return delegateCallInst(I)0
; \
160
52
      else \
161
52
        DELEGATE(CLASS); \
162
52
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitInsertValue(llvm::InsertValueInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetVisitor, std::__1::pair<llvm::APInt, llvm::APInt> >::visitLandingPad(llvm::LandingPadInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitRet(llvm::ReturnInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitBr(llvm::BranchInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitSwitch(llvm::SwitchInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitIndirectBr(llvm::IndirectBrInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitInvoke(llvm::InvokeInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitResume(llvm::ResumeInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitUnreachable(llvm::UnreachableInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitCleanupRet(llvm::CleanupReturnInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitCatchRet(llvm::CatchReturnInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitCatchSwitch(llvm::CatchSwitchInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitCallBr(llvm::CallBrInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitFNeg(llvm::UnaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitAdd(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitFAdd(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitSub(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitFSub(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitMul(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitFMul(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitUDiv(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitSDiv(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitFDiv(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitURem(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitSRem(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitFRem(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitShl(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitLShr(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitAShr(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitAnd(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitOr(llvm::BinaryOperator&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitXor(llvm::BinaryOperator&)
llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitAlloca(llvm::AllocaInst&)
Line
Count
Source
157
10
    RetTy visit##OPCODE(CLASS &I) { \
158
10
      if (NUM == Instruction::Call) \
159
10
        
return delegateCallInst(I)0
; \
160
10
      else \
161
10
        DELEGATE(CLASS); \
162
10
    }
llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitLoad(llvm::LoadInst&)
Line
Count
Source
157
2
    RetTy visit##OPCODE(CLASS &I) { \
158
2
      if (NUM == Instruction::Call) \
159
2
        
return delegateCallInst(I)0
; \
160
2
      else \
161
2
        DELEGATE(CLASS); \
162
2
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitStore(llvm::StoreInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitGetElementPtr(llvm::GetElementPtrInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitFence(llvm::FenceInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitAtomicCmpXchg(llvm::AtomicCmpXchgInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitAtomicRMW(llvm::AtomicRMWInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitTrunc(llvm::TruncInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitZExt(llvm::ZExtInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitSExt(llvm::SExtInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitFPToUI(llvm::FPToUIInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitFPToSI(llvm::FPToSIInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitUIToFP(llvm::UIToFPInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitSIToFP(llvm::SIToFPInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitFPTrunc(llvm::FPTruncInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitFPExt(llvm::FPExtInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitPtrToInt(llvm::PtrToIntInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitIntToPtr(llvm::IntToPtrInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitBitCast(llvm::BitCastInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitAddrSpaceCast(llvm::AddrSpaceCastInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitCleanupPad(llvm::CleanupPadInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitCatchPad(llvm::CatchPadInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitICmp(llvm::ICmpInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitFCmp(llvm::FCmpInst&)
llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitPHI(llvm::PHINode&)
Line
Count
Source
157
7
    RetTy visit##OPCODE(CLASS &I) { \
158
7
      if (NUM == Instruction::Call) \
159
7
        
return delegateCallInst(I)0
; \
160
7
      else \
161
7
        DELEGATE(CLASS); \
162
7
    }
llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitCall(llvm::CallInst&)
Line
Count
Source
157
8
    RetTy visit##OPCODE(CLASS &I) { \
158
8
      if (NUM == Instruction::Call) \
159
8
        return delegateCallInst(I); \
160
8
      else \
161
8
        
DELEGATE0
(CLASS); \
162
8
    }
llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitSelect(llvm::SelectInst&)
Line
Count
Source
157
4
    RetTy visit##OPCODE(CLASS &I) { \
158
4
      if (NUM == Instruction::Call) \
159
4
        
return delegateCallInst(I)0
; \
160
4
      else \
161
4
        DELEGATE(CLASS); \
162
4
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitUserOp1(llvm::Instruction&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitUserOp2(llvm::Instruction&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitVAArg(llvm::VAArgInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitExtractElement(llvm::ExtractElementInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitInsertElement(llvm::InsertElementInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitShuffleVector(llvm::ShuffleVectorInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitExtractValue(llvm::ExtractValueInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitInsertValue(llvm::InsertValueInst&)
Unexecuted instantiation: llvm::InstVisitor<llvm::ObjectSizeOffsetEvaluator, std::__1::pair<llvm::Value*, llvm::Value*> >::visitLandingPad(llvm::LandingPadInst&)
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitRet(llvm::ReturnInst&)
Line
Count
Source
157
958k
    RetTy visit##OPCODE(CLASS &I) { \
158
958k
      if (NUM == Instruction::Call) \
159
958k
        
return delegateCallInst(I)0
; \
160
958k
      else \
161
958k
        DELEGATE(CLASS); \
162
958k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitBr(llvm::BranchInst&)
Line
Count
Source
157
379k
    RetTy visit##OPCODE(CLASS &I) { \
158
379k
      if (NUM == Instruction::Call) \
159
379k
        
return delegateCallInst(I)0
; \
160
379k
      else \
161
379k
        DELEGATE(CLASS); \
162
379k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitSwitch(llvm::SwitchInst&)
Line
Count
Source
157
4.98k
    RetTy visit##OPCODE(CLASS &I) { \
158
4.98k
      if (NUM == Instruction::Call) \
159
4.98k
        
return delegateCallInst(I)0
; \
160
4.98k
      else \
161
4.98k
        DELEGATE(CLASS); \
162
4.98k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitIndirectBr(llvm::IndirectBrInst&)
Line
Count
Source
157
835
    RetTy visit##OPCODE(CLASS &I) { \
158
835
      if (NUM == Instruction::Call) \
159
835
        
return delegateCallInst(I)0
; \
160
835
      else \
161
835
        DELEGATE(CLASS); \
162
835
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitInvoke(llvm::InvokeInst&)
Line
Count
Source
157
7.73k
    RetTy visit##OPCODE(CLASS &I) { \
158
7.73k
      if (NUM == Instruction::Call) \
159
7.73k
        
return delegateCallInst(I)0
; \
160
7.73k
      else \
161
7.73k
        DELEGATE(CLASS); \
162
7.73k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitResume(llvm::ResumeInst&)
Line
Count
Source
157
1.09k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.09k
      if (NUM == Instruction::Call) \
159
1.09k
        
return delegateCallInst(I)0
; \
160
1.09k
      else \
161
1.09k
        DELEGATE(CLASS); \
162
1.09k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitUnreachable(llvm::UnreachableInst&)
Line
Count
Source
157
13.8k
    RetTy visit##OPCODE(CLASS &I) { \
158
13.8k
      if (NUM == Instruction::Call) \
159
13.8k
        
return delegateCallInst(I)0
; \
160
13.8k
      else \
161
13.8k
        DELEGATE(CLASS); \
162
13.8k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitCleanupRet(llvm::CleanupReturnInst&)
Line
Count
Source
157
688
    RetTy visit##OPCODE(CLASS &I) { \
158
688
      if (NUM == Instruction::Call) \
159
688
        
return delegateCallInst(I)0
; \
160
688
      else \
161
688
        DELEGATE(CLASS); \
162
688
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitCatchRet(llvm::CatchReturnInst&)
Line
Count
Source
157
860
    RetTy visit##OPCODE(CLASS &I) { \
158
860
      if (NUM == Instruction::Call) \
159
860
        
return delegateCallInst(I)0
; \
160
860
      else \
161
860
        DELEGATE(CLASS); \
162
860
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitCatchSwitch(llvm::CatchSwitchInst&)
Line
Count
Source
157
977
    RetTy visit##OPCODE(CLASS &I) { \
158
977
      if (NUM == Instruction::Call) \
159
977
        
return delegateCallInst(I)0
; \
160
977
      else \
161
977
        DELEGATE(CLASS); \
162
977
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitCallBr(llvm::CallBrInst&)
Line
Count
Source
157
72
    RetTy visit##OPCODE(CLASS &I) { \
158
72
      if (NUM == Instruction::Call) \
159
72
        
return delegateCallInst(I)0
; \
160
72
      else \
161
72
        DELEGATE(CLASS); \
162
72
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitFNeg(llvm::UnaryOperator&)
Line
Count
Source
157
856
    RetTy visit##OPCODE(CLASS &I) { \
158
856
      if (NUM == Instruction::Call) \
159
856
        
return delegateCallInst(I)0
; \
160
856
      else \
161
856
        DELEGATE(CLASS); \
162
856
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitAdd(llvm::BinaryOperator&)
Line
Count
Source
157
211k
    RetTy visit##OPCODE(CLASS &I) { \
158
211k
      if (NUM == Instruction::Call) \
159
211k
        
return delegateCallInst(I)0
; \
160
211k
      else \
161
211k
        DELEGATE(CLASS); \
162
211k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitFAdd(llvm::BinaryOperator&)
Line
Count
Source
157
52.7k
    RetTy visit##OPCODE(CLASS &I) { \
158
52.7k
      if (NUM == Instruction::Call) \
159
52.7k
        
return delegateCallInst(I)0
; \
160
52.7k
      else \
161
52.7k
        DELEGATE(CLASS); \
162
52.7k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitSub(llvm::BinaryOperator&)
Line
Count
Source
157
50.3k
    RetTy visit##OPCODE(CLASS &I) { \
158
50.3k
      if (NUM == Instruction::Call) \
159
50.3k
        
return delegateCallInst(I)0
; \
160
50.3k
      else \
161
50.3k
        DELEGATE(CLASS); \
162
50.3k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitFSub(llvm::BinaryOperator&)
Line
Count
Source
157
29.5k
    RetTy visit##OPCODE(CLASS &I) { \
158
29.5k
      if (NUM == Instruction::Call) \
159
29.5k
        
return delegateCallInst(I)0
; \
160
29.5k
      else \
161
29.5k
        DELEGATE(CLASS); \
162
29.5k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitMul(llvm::BinaryOperator&)
Line
Count
Source
157
57.3k
    RetTy visit##OPCODE(CLASS &I) { \
158
57.3k
      if (NUM == Instruction::Call) \
159
57.3k
        
return delegateCallInst(I)0
; \
160
57.3k
      else \
161
57.3k
        DELEGATE(CLASS); \
162
57.3k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitFMul(llvm::BinaryOperator&)
Line
Count
Source
157
33.4k
    RetTy visit##OPCODE(CLASS &I) { \
158
33.4k
      if (NUM == Instruction::Call) \
159
33.4k
        
return delegateCallInst(I)0
; \
160
33.4k
      else \
161
33.4k
        DELEGATE(CLASS); \
162
33.4k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitUDiv(llvm::BinaryOperator&)
Line
Count
Source
157
6.60k
    RetTy visit##OPCODE(CLASS &I) { \
158
6.60k
      if (NUM == Instruction::Call) \
159
6.60k
        
return delegateCallInst(I)0
; \
160
6.60k
      else \
161
6.60k
        DELEGATE(CLASS); \
162
6.60k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitSDiv(llvm::BinaryOperator&)
Line
Count
Source
157
13.2k
    RetTy visit##OPCODE(CLASS &I) { \
158
13.2k
      if (NUM == Instruction::Call) \
159
13.2k
        
return delegateCallInst(I)0
; \
160
13.2k
      else \
161
13.2k
        DELEGATE(CLASS); \
162
13.2k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitFDiv(llvm::BinaryOperator&)
Line
Count
Source
157
9.21k
    RetTy visit##OPCODE(CLASS &I) { \
158
9.21k
      if (NUM == Instruction::Call) \
159
9.21k
        
return delegateCallInst(I)0
; \
160
9.21k
      else \
161
9.21k
        DELEGATE(CLASS); \
162
9.21k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitURem(llvm::BinaryOperator&)
Line
Count
Source
157
5.99k
    RetTy visit##OPCODE(CLASS &I) { \
158
5.99k
      if (NUM == Instruction::Call) \
159
5.99k
        
return delegateCallInst(I)0
; \
160
5.99k
      else \
161
5.99k
        DELEGATE(CLASS); \
162
5.99k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitSRem(llvm::BinaryOperator&)
Line
Count
Source
157
6.48k
    RetTy visit##OPCODE(CLASS &I) { \
158
6.48k
      if (NUM == Instruction::Call) \
159
6.48k
        
return delegateCallInst(I)0
; \
160
6.48k
      else \
161
6.48k
        DELEGATE(CLASS); \
162
6.48k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitFRem(llvm::BinaryOperator&)
Line
Count
Source
157
1.01k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.01k
      if (NUM == Instruction::Call) \
159
1.01k
        
return delegateCallInst(I)0
; \
160
1.01k
      else \
161
1.01k
        DELEGATE(CLASS); \
162
1.01k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitShl(llvm::BinaryOperator&)
Line
Count
Source
157
43.7k
    RetTy visit##OPCODE(CLASS &I) { \
158
43.7k
      if (NUM == Instruction::Call) \
159
43.7k
        
return delegateCallInst(I)0
; \
160
43.7k
      else \
161
43.7k
        DELEGATE(CLASS); \
162
43.7k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitLShr(llvm::BinaryOperator&)
Line
Count
Source
157
39.7k
    RetTy visit##OPCODE(CLASS &I) { \
158
39.7k
      if (NUM == Instruction::Call) \
159
39.7k
        
return delegateCallInst(I)0
; \
160
39.7k
      else \
161
39.7k
        DELEGATE(CLASS); \
162
39.7k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitAShr(llvm::BinaryOperator&)
Line
Count
Source
157
18.7k
    RetTy visit##OPCODE(CLASS &I) { \
158
18.7k
      if (NUM == Instruction::Call) \
159
18.7k
        
return delegateCallInst(I)0
; \
160
18.7k
      else \
161
18.7k
        DELEGATE(CLASS); \
162
18.7k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitAnd(llvm::BinaryOperator&)
Line
Count
Source
157
78.0k
    RetTy visit##OPCODE(CLASS &I) { \
158
78.0k
      if (NUM == Instruction::Call) \
159
78.0k
        
return delegateCallInst(I)0
; \
160
78.0k
      else \
161
78.0k
        DELEGATE(CLASS); \
162
78.0k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitOr(llvm::BinaryOperator&)
Line
Count
Source
157
38.4k
    RetTy visit##OPCODE(CLASS &I) { \
158
38.4k
      if (NUM == Instruction::Call) \
159
38.4k
        
return delegateCallInst(I)0
; \
160
38.4k
      else \
161
38.4k
        DELEGATE(CLASS); \
162
38.4k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitXor(llvm::BinaryOperator&)
Line
Count
Source
157
31.5k
    RetTy visit##OPCODE(CLASS &I) { \
158
31.5k
      if (NUM == Instruction::Call) \
159
31.5k
        
return delegateCallInst(I)0
; \
160
31.5k
      else \
161
31.5k
        DELEGATE(CLASS); \
162
31.5k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitAlloca(llvm::AllocaInst&)
Line
Count
Source
157
446k
    RetTy visit##OPCODE(CLASS &I) { \
158
446k
      if (NUM == Instruction::Call) \
159
446k
        
return delegateCallInst(I)0
; \
160
446k
      else \
161
446k
        DELEGATE(CLASS); \
162
446k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitLoad(llvm::LoadInst&)
Line
Count
Source
157
919k
    RetTy visit##OPCODE(CLASS &I) { \
158
919k
      if (NUM == Instruction::Call) \
159
919k
        
return delegateCallInst(I)0
; \
160
919k
      else \
161
919k
        DELEGATE(CLASS); \
162
919k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitStore(llvm::StoreInst&)
Line
Count
Source
157
787k
    RetTy visit##OPCODE(CLASS &I) { \
158
787k
      if (NUM == Instruction::Call) \
159
787k
        
return delegateCallInst(I)0
; \
160
787k
      else \
161
787k
        DELEGATE(CLASS); \
162
787k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitGetElementPtr(llvm::GetElementPtrInst&)
Line
Count
Source
157
456k
    RetTy visit##OPCODE(CLASS &I) { \
158
456k
      if (NUM == Instruction::Call) \
159
456k
        
return delegateCallInst(I)0
; \
160
456k
      else \
161
456k
        DELEGATE(CLASS); \
162
456k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitFence(llvm::FenceInst&)
Line
Count
Source
157
4.08k
    RetTy visit##OPCODE(CLASS &I) { \
158
4.08k
      if (NUM == Instruction::Call) \
159
4.08k
        
return delegateCallInst(I)0
; \
160
4.08k
      else \
161
4.08k
        DELEGATE(CLASS); \
162
4.08k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitAtomicCmpXchg(llvm::AtomicCmpXchgInst&)
Line
Count
Source
157
6.43k
    RetTy visit##OPCODE(CLASS &I) { \
158
6.43k
      if (NUM == Instruction::Call) \
159
6.43k
        
return delegateCallInst(I)0
; \
160
6.43k
      else \
161
6.43k
        DELEGATE(CLASS); \
162
6.43k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitAtomicRMW(llvm::AtomicRMWInst&)
Line
Count
Source
157
20.4k
    RetTy visit##OPCODE(CLASS &I) { \
158
20.4k
      if (NUM == Instruction::Call) \
159
20.4k
        
return delegateCallInst(I)0
; \
160
20.4k
      else \
161
20.4k
        DELEGATE(CLASS); \
162
20.4k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitTrunc(llvm::TruncInst&)
Line
Count
Source
157
61.6k
    RetTy visit##OPCODE(CLASS &I) { \
158
61.6k
      if (NUM == Instruction::Call) \
159
61.6k
        
return delegateCallInst(I)0
; \
160
61.6k
      else \
161
61.6k
        DELEGATE(CLASS); \
162
61.6k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitZExt(llvm::ZExtInst&)
Line
Count
Source
157
84.9k
    RetTy visit##OPCODE(CLASS &I) { \
158
84.9k
      if (NUM == Instruction::Call) \
159
84.9k
        
return delegateCallInst(I)0
; \
160
84.9k
      else \
161
84.9k
        DELEGATE(CLASS); \
162
84.9k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitSExt(llvm::SExtInst&)
Line
Count
Source
157
75.3k
    RetTy visit##OPCODE(CLASS &I) { \
158
75.3k
      if (NUM == Instruction::Call) \
159
75.3k
        
return delegateCallInst(I)0
; \
160
75.3k
      else \
161
75.3k
        DELEGATE(CLASS); \
162
75.3k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitFPToUI(llvm::FPToUIInst&)
Line
Count
Source
157
9.07k
    RetTy visit##OPCODE(CLASS &I) { \
158
9.07k
      if (NUM == Instruction::Call) \
159
9.07k
        
return delegateCallInst(I)0
; \
160
9.07k
      else \
161
9.07k
        DELEGATE(CLASS); \
162
9.07k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitFPToSI(llvm::FPToSIInst&)
Line
Count
Source
157
10.9k
    RetTy visit##OPCODE(CLASS &I) { \
158
10.9k
      if (NUM == Instruction::Call) \
159
10.9k
        
return delegateCallInst(I)0
; \
160
10.9k
      else \
161
10.9k
        DELEGATE(CLASS); \
162
10.9k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitUIToFP(llvm::UIToFPInst&)
Line
Count
Source
157
13.4k
    RetTy visit##OPCODE(CLASS &I) { \
158
13.4k
      if (NUM == Instruction::Call) \
159
13.4k
        
return delegateCallInst(I)0
; \
160
13.4k
      else \
161
13.4k
        DELEGATE(CLASS); \
162
13.4k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitSIToFP(llvm::SIToFPInst&)
Line
Count
Source
157
18.9k
    RetTy visit##OPCODE(CLASS &I) { \
158
18.9k
      if (NUM == Instruction::Call) \
159
18.9k
        
return delegateCallInst(I)0
; \
160
18.9k
      else \
161
18.9k
        DELEGATE(CLASS); \
162
18.9k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitFPTrunc(llvm::FPTruncInst&)
Line
Count
Source
157
5.17k
    RetTy visit##OPCODE(CLASS &I) { \
158
5.17k
      if (NUM == Instruction::Call) \
159
5.17k
        
return delegateCallInst(I)0
; \
160
5.17k
      else \
161
5.17k
        DELEGATE(CLASS); \
162
5.17k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitFPExt(llvm::FPExtInst&)
Line
Count
Source
157
11.6k
    RetTy visit##OPCODE(CLASS &I) { \
158
11.6k
      if (NUM == Instruction::Call) \
159
11.6k
        
return delegateCallInst(I)0
; \
160
11.6k
      else \
161
11.6k
        DELEGATE(CLASS); \
162
11.6k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitPtrToInt(llvm::PtrToIntInst&)
Line
Count
Source
157
10.2k
    RetTy visit##OPCODE(CLASS &I) { \
158
10.2k
      if (NUM == Instruction::Call) \
159
10.2k
        
return delegateCallInst(I)0
; \
160
10.2k
      else \
161
10.2k
        DELEGATE(CLASS); \
162
10.2k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitIntToPtr(llvm::IntToPtrInst&)
Line
Count
Source
157
26.8k
    RetTy visit##OPCODE(CLASS &I) { \
158
26.8k
      if (NUM == Instruction::Call) \
159
26.8k
        
return delegateCallInst(I)0
; \
160
26.8k
      else \
161
26.8k
        DELEGATE(CLASS); \
162
26.8k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitBitCast(llvm::BitCastInst&)
Line
Count
Source
157
411k
    RetTy visit##OPCODE(CLASS &I) { \
158
411k
      if (NUM == Instruction::Call) \
159
411k
        
return delegateCallInst(I)0
; \
160
411k
      else \
161
411k
        DELEGATE(CLASS); \
162
411k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitAddrSpaceCast(llvm::AddrSpaceCastInst&)
Line
Count
Source
157
2.16k
    RetTy visit##OPCODE(CLASS &I) { \
158
2.16k
      if (NUM == Instruction::Call) \
159
2.16k
        
return delegateCallInst(I)0
; \
160
2.16k
      else \
161
2.16k
        DELEGATE(CLASS); \
162
2.16k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitCleanupPad(llvm::CleanupPadInst&)
Line
Count
Source
157
946
    RetTy visit##OPCODE(CLASS &I) { \
158
946
      if (NUM == Instruction::Call) \
159
946
        
return delegateCallInst(I)0
; \
160
946
      else \
161
946
        DELEGATE(CLASS); \
162
946
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitCatchPad(llvm::CatchPadInst&)
Line
Count
Source
157
1.03k
    RetTy visit##OPCODE(CLASS &I) { \
158
1.03k
      if (NUM == Instruction::Call) \
159
1.03k
        
return delegateCallInst(I)0
; \
160
1.03k
      else \
161
1.03k
        DELEGATE(CLASS); \
162
1.03k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitICmp(llvm::ICmpInst&)
Line
Count
Source
157
270k
    RetTy visit##OPCODE(CLASS &I) { \
158
270k
      if (NUM == Instruction::Call) \
159
270k
        
return delegateCallInst(I)0
; \
160
270k
      else \
161
270k
        DELEGATE(CLASS); \
162
270k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitFCmp(llvm::FCmpInst&)
Line
Count
Source
157
40.4k
    RetTy visit##OPCODE(CLASS &I) { \
158
40.4k
      if (NUM == Instruction::Call) \
159
40.4k
        
return delegateCallInst(I)0
; \
160
40.4k
      else \
161
40.4k
        DELEGATE(CLASS); \
162
40.4k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitPHI(llvm::PHINode&)
Line
Count
Source
157
97.8k
    RetTy visit##OPCODE(CLASS &I) { \
158
97.8k
      if (NUM == Instruction::Call) \
159
97.8k
        
return delegateCallInst(I)0
; \
160
97.8k
      else \
161
97.8k
        DELEGATE(CLASS); \
162
97.8k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitCall(llvm::CallInst&)
Line
Count
Source
157
734k
    RetTy visit##OPCODE(CLASS &I) { \
158
734k
      if (NUM == Instruction::Call) \
159
734k
        return delegateCallInst(I); \
160
734k
      else \
161
734k
        
DELEGATE0
(CLASS); \
162
734k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitSelect(llvm::SelectInst&)
Line
Count
Source
157
120k
    RetTy visit##OPCODE(CLASS &I) { \
158
120k
      if (NUM == Instruction::Call) \
159
120k
        
return delegateCallInst(I)0
; \
160
120k
      else \
161
120k
        DELEGATE(CLASS); \
162
120k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitVAArg(llvm::VAArgInst&)
Line
Count
Source
157
905
    RetTy visit##OPCODE(CLASS &I) { \
158
905
      if (NUM == Instruction::Call) \
159
905
        
return delegateCallInst(I)0
; \
160
905
      else \
161
905
        DELEGATE(CLASS); \
162
905
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitExtractElement(llvm::ExtractElementInst&)
Line
Count
Source
157
146k
    RetTy visit##OPCODE(CLASS &I) { \
158
146k
      if (NUM == Instruction::Call) \
159
146k
        
return delegateCallInst(I)0
; \
160
146k
      else \
161
146k
        DELEGATE(CLASS); \
162
146k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitInsertElement(llvm::InsertElementInst&)
Line
Count
Source
157
116k
    RetTy visit##OPCODE(CLASS &I) { \
158
116k
      if (NUM == Instruction::Call) \
159
116k
        
return delegateCallInst(I)0
; \
160
116k
      else \
161
116k
        DELEGATE(CLASS); \
162
116k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitShuffleVector(llvm::ShuffleVectorInst&)
Line
Count
Source
157
160k
    RetTy visit##OPCODE(CLASS &I) { \
158
160k
      if (NUM == Instruction::Call) \
159
160k
        
return delegateCallInst(I)0
; \
160
160k
      else \
161
160k
        DELEGATE(CLASS); \
162
160k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitExtractValue(llvm::ExtractValueInst&)
Line
Count
Source
157
53.9k
    RetTy visit##OPCODE(CLASS &I) { \
158
53.9k
      if (NUM == Instruction::Call) \
159
53.9k
        
return delegateCallInst(I)0
; \
160
53.9k
      else \
161
53.9k
        DELEGATE(CLASS); \
162
53.9k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitInsertValue(llvm::InsertValueInst&)
Line
Count
Source
157
8.71k
    RetTy visit##OPCODE(CLASS &I) { \
158
8.71k
      if (NUM == Instruction::Call) \
159
8.71k
        
return delegateCallInst(I)0
; \
160
8.71k
      else \
161
8.71k
        DELEGATE(CLASS); \
162
8.71k
    }
Verifier.cpp:llvm::InstVisitor<(anonymous namespace)::Verifier, void>::visitLandingPad(llvm::LandingPadInst&)
Line
Count
Source
157
4.54k
    RetTy visit##OPCODE(CLASS &I) { \
158
4.54k
      if (NUM == Instruction::Call) \
159
4.54k
        
return delegateCallInst(I)0
; \
160
4.54k
      else \
161
4.54k
        DELEGATE(CLASS); \
162
4.54k
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitRet(llvm::ReturnInst&)
Line
Count
Source
157
3.73M
    RetTy visit##OPCODE(CLASS &I) { \
158
3.73M
      if (NUM == Instruction::Call) \
159
3.73M
        
return delegateCallInst(I)0
; \
160
3.73M
      else \
161
3.73M
        DELEGATE(CLASS); \
162
3.73M
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitBr(llvm::BranchInst&)
Line
Count
Source
157
24.1M
    RetTy visit##OPCODE(CLASS &I) { \
158
24.1M
      if (NUM == Instruction::Call) \
159
24.1M
        
return delegateCallInst(I)0
; \
160
24.1M
      else \
161
24.1M
        DELEGATE(CLASS); \
162
24.1M
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitSwitch(llvm::SwitchInst&)
Line
Count
Source
157
233k
    RetTy visit##OPCODE(CLASS &I) { \
158
233k
      if (NUM == Instruction::Call) \
159
233k
        
return delegateCallInst(I)0
; \
160
233k
      else \
161
233k
        DELEGATE(CLASS); \
162
233k
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitIndirectBr(llvm::IndirectBrInst&)
Line
Count
Source
157
22
    RetTy visit##OPCODE(CLASS &I) { \
158
22
      if (NUM == Instruction::Call) \
159
22
        
return delegateCallInst(I)0
; \
160
22
      else \
161
22
        DELEGATE(CLASS); \
162
22
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitInvoke(llvm::InvokeInst&)
Line
Count
Source
157
431k
    RetTy visit##OPCODE(CLASS &I) { \
158
431k
      if (NUM == Instruction::Call) \
159
431k
        
return delegateCallInst(I)0
; \
160
431k
      else \
161
431k
        DELEGATE(CLASS); \
162
431k
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitResume(llvm::ResumeInst&)
Line
Count
Source
157
51.7k
    RetTy visit##OPCODE(CLASS &I) { \
158
51.7k
      if (NUM == Instruction::Call) \
159
51.7k
        
return delegateCallInst(I)0
; \
160
51.7k
      else \
161
51.7k
        DELEGATE(CLASS); \
162
51.7k
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitUnreachable(llvm::UnreachableInst&)
Line
Count
Source
157
450k
    RetTy visit##OPCODE(CLASS &I) { \
158
450k
      if (NUM == Instruction::Call) \
159
450k
        
return delegateCallInst(I)0
; \
160
450k
      else \
161
450k
        DELEGATE(CLASS); \
162
450k
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitCleanupRet(llvm::CleanupReturnInst&)
Line
Count
Source
157
17
    RetTy visit##OPCODE(CLASS &I) { \
158
17
      if (NUM == Instruction::Call) \
159
17
        
return delegateCallInst(I)0
; \
160
17
      else \
161
17
        DELEGATE(CLASS); \
162
17
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitCatchRet(llvm::CatchReturnInst&)
Line
Count
Source
157
12
    RetTy visit##OPCODE(CLASS &I) { \
158
12
      if (NUM == Instruction::Call) \
159
12
        
return delegateCallInst(I)0
; \
160
12
      else \
161
12
        DELEGATE(CLASS); \
162
12
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitCatchSwitch(llvm::CatchSwitchInst&)
Line
Count
Source
157
15
    RetTy visit##OPCODE(CLASS &I) { \
158
15
      if (NUM == Instruction::Call) \
159
15
        
return delegateCallInst(I)0
; \
160
15
      else \
161
15
        DELEGATE(CLASS); \
162
15
    }
Unexecuted instantiation: llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitCallBr(llvm::CallBrInst&)
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitAlloca(llvm::AllocaInst&)
Line
Count
Source
157
1.07M
    RetTy visit##OPCODE(CLASS &I) { \
158
1.07M
      if (NUM == Instruction::Call) \
159
1.07M
        
return delegateCallInst(I)0
; \
160
1.07M
      else \
161
1.07M
        DELEGATE(CLASS); \
162
1.07M
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitLoad(llvm::LoadInst&)
Line
Count
Source
157
18.7M
    RetTy visit##OPCODE(CLASS &I) { \
158
18.7M
      if (NUM == Instruction::Call) \
159
18.7M
        
return delegateCallInst(I)0
; \
160
18.7M
      else \
161
18.7M
        DELEGATE(CLASS); \
162
18.7M
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitStore(llvm::StoreInst&)
Line
Count
Source
157
12.9M
    RetTy visit##OPCODE(CLASS &I) { \
158
12.9M
      if (NUM == Instruction::Call) \
159
12.9M
        
return delegateCallInst(I)0
; \
160
12.9M
      else \
161
12.9M
        DELEGATE(CLASS); \
162
12.9M
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitGetElementPtr(llvm::GetElementPtrInst&)
Line
Count
Source
157
24.7M
    RetTy visit##OPCODE(CLASS &I) { \
158
24.7M
      if (NUM == Instruction::Call) \
159
24.7M
        
return delegateCallInst(I)0
; \
160
24.7M
      else \
161
24.7M
        DELEGATE(CLASS); \
162
24.7M
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitFence(llvm::FenceInst&)
Line
Count
Source
157
52.3k
    RetTy visit##OPCODE(CLASS &I) { \
158
52.3k
      if (NUM == Instruction::Call) \
159
52.3k
        
return delegateCallInst(I)0
; \
160
52.3k
      else \
161
52.3k
        DELEGATE(CLASS); \
162
52.3k
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitAtomicCmpXchg(llvm::AtomicCmpXchgInst&)
Line
Count
Source
157
44.9k
    RetTy visit##OPCODE(CLASS &I) { \
158
44.9k
      if (NUM == Instruction::Call) \
159
44.9k
        
return delegateCallInst(I)0
; \
160
44.9k
      else \
161
44.9k
        DELEGATE(CLASS); \
162
44.9k
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitAtomicRMW(llvm::AtomicRMWInst&)
Line
Count
Source
157
231k
    RetTy visit##OPCODE(CLASS &I) { \
158
231k
      if (NUM == Instruction::Call) \
159
231k
        
return delegateCallInst(I)0
; \
160
231k
      else \
161
231k
        DELEGATE(CLASS); \
162
231k
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitCleanupPad(llvm::CleanupPadInst&)
Line
Count
Source
157
17
    RetTy visit##OPCODE(CLASS &I) { \
158
17
      if (NUM == Instruction::Call) \
159
17
        
return delegateCallInst(I)0
; \
160
17
      else \
161
17
        DELEGATE(CLASS); \
162
17
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitCatchPad(llvm::CatchPadInst&)
Line
Count
Source
157
16
    RetTy visit##OPCODE(CLASS &I) { \
158
16
      if (NUM == Instruction::Call) \
159
16
        
return delegateCallInst(I)0
; \
160
16
      else \
161
16
        DELEGATE(CLASS); \
162
16
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitICmp(llvm::ICmpInst&)
Line
Count
Source
157
15.1M
    RetTy visit##OPCODE(CLASS &I) { \
158
15.1M
      if (NUM == Instruction::Call) \
159
15.1M
        
return delegateCallInst(I)0
; \
160
15.1M
      else \
161
15.1M
        DELEGATE(CLASS); \
162
15.1M
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitFCmp(llvm::FCmpInst&)
Line
Count
Source
157
260k
    RetTy visit##OPCODE(CLASS &I) { \
158
260k
      if (NUM == Instruction::Call) \
159
260k
        
return delegateCallInst(I)0
; \
160
260k
      else \
161
260k
        DELEGATE(CLASS); \
162
260k
    }
llvm::InstVisitor<llvm::InstCombiner, llvm::Instruction*>::visitPHI(llvm::PHINode&)
Line
Count
Source
157
8.44M
    RetTy visit##OPCODE(CLASS &I) { \
158
8.44M
      if (NUM == Instruction::Call) \
159
8.44M
        
return delegateCallInst(I)0
; \
160