Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Support/Recycler.h
Line
Count
Source
1
//==- llvm/Support/Recycler.h - Recycling Allocator --------------*- 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
// This file defines the Recycler class template.  See the doxygen comment for
10
// Recycler for more details.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#ifndef LLVM_SUPPORT_RECYCLER_H
15
#define LLVM_SUPPORT_RECYCLER_H
16
17
#include "llvm/ADT/ilist.h"
18
#include "llvm/Support/Allocator.h"
19
#include "llvm/Support/ErrorHandling.h"
20
#include <cassert>
21
22
namespace llvm {
23
24
/// PrintRecyclingAllocatorStats - Helper for RecyclingAllocator for
25
/// printing statistics.
26
///
27
void PrintRecyclerStats(size_t Size, size_t Align, size_t FreeListSize);
28
29
/// Recycler - This class manages a linked-list of deallocated nodes
30
/// and facilitates reusing deallocated memory in place of allocating
31
/// new memory.
32
///
33
template <class T, size_t Size = sizeof(T), size_t Align = alignof(T)>
34
class Recycler {
35
  struct FreeNode {
36
    FreeNode *Next;
37
  };
38
39
  /// List of nodes that have deleted contents and are not in active use.
40
  FreeNode *FreeList = nullptr;
41
42
88.2M
  FreeNode *pop_val() {
43
88.2M
    auto *Val = FreeList;
44
88.2M
    __asan_unpoison_memory_region(Val, Size);
45
88.2M
    FreeList = FreeList->Next;
46
88.2M
    __msan_allocated_memory(Val, Size);
47
88.2M
    return Val;
48
88.2M
  }
llvm::Recycler<llvm::ScopedHashTableVal<llvm::PointerUnion<llvm::Value const*, llvm::PseudoSourceValue const*>, std::__1::pair<unsigned int, unsigned int> >, 32ul, 8ul>::pop_val()
Line
Count
Source
42
786
  FreeNode *pop_val() {
43
786
    auto *Val = FreeList;
44
786
    __asan_unpoison_memory_region(Val, Size);
45
786
    FreeList = FreeList->Next;
46
786
    __msan_allocated_memory(Val, Size);
47
786
    return Val;
48
786
  }
llvm::Recycler<llvm::SDNode, 104ul, 8ul>::pop_val()
Line
Count
Source
42
44.3M
  FreeNode *pop_val() {
43
44.3M
    auto *Val = FreeList;
44
44.3M
    __asan_unpoison_memory_region(Val, Size);
45
44.3M
    FreeList = FreeList->Next;
46
44.3M
    __msan_allocated_memory(Val, Size);
47
44.3M
    return Val;
48
44.3M
  }
llvm::Recycler<char, 192ul, 64ul>::pop_val()
Line
Count
Source
42
621k
  FreeNode *pop_val() {
43
621k
    auto *Val = FreeList;
44
621k
    __asan_unpoison_memory_region(Val, Size);
45
621k
    FreeList = FreeList->Next;
46
621k
    __msan_allocated_memory(Val, Size);
47
621k
    return Val;
48
621k
  }
llvm::Recycler<llvm::ScopedHashTableVal<llvm::MachineInstr*, unsigned int>, 32ul, 8ul>::pop_val()
Line
Count
Source
42
5.78M
  FreeNode *pop_val() {
43
5.78M
    auto *Val = FreeList;
44
5.78M
    __asan_unpoison_memory_region(Val, Size);
45
5.78M
    FreeList = FreeList->Next;
46
5.78M
    __msan_allocated_memory(Val, Size);
47
5.78M
    return Val;
48
5.78M
  }
llvm::Recycler<llvm::MachineInstr, 72ul, 8ul>::pop_val()
Line
Count
Source
42
30.6M
  FreeNode *pop_val() {
43
30.6M
    auto *Val = FreeList;
44
30.6M
    __asan_unpoison_memory_region(Val, Size);
45
30.6M
    FreeList = FreeList->Next;
46
30.6M
    __msan_allocated_memory(Val, Size);
47
30.6M
    return Val;
48
30.6M
  }
llvm::Recycler<llvm::MachineBasicBlock, 200ul, 8ul>::pop_val()
Line
Count
Source
42
103k
  FreeNode *pop_val() {
43
103k
    auto *Val = FreeList;
44
103k
    __asan_unpoison_memory_region(Val, Size);
45
103k
    FreeList = FreeList->Next;
46
103k
    __msan_allocated_memory(Val, Size);
47
103k
    return Val;
48
103k
  }
EarlyCSE.cpp:llvm::Recycler<llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>, 32ul, 8ul>::pop_val()
Line
Count
Source
42
5.10M
  FreeNode *pop_val() {
43
5.10M
    auto *Val = FreeList;
44
5.10M
    __asan_unpoison_memory_region(Val, Size);
45
5.10M
    FreeList = FreeList->Next;
46
5.10M
    __msan_allocated_memory(Val, Size);
47
5.10M
    return Val;
48
5.10M
  }
llvm::Recycler<llvm::ScopedHashTableVal<llvm::MemoryLocation, unsigned int>, 64ul, 8ul>::pop_val()
Line
Count
Source
42
28
  FreeNode *pop_val() {
43
28
    auto *Val = FreeList;
44
28
    __asan_unpoison_memory_region(Val, Size);
45
28
    FreeList = FreeList->Next;
46
28
    __msan_allocated_memory(Val, Size);
47
28
    return Val;
48
28
  }
EarlyCSE.cpp:llvm::Recycler<llvm::ScopedHashTableVal<llvm::Value*, (anonymous namespace)::EarlyCSE::LoadValue>, 48ul, 8ul>::pop_val()
Line
Count
Source
42
1.71M
  FreeNode *pop_val() {
43
1.71M
    auto *Val = FreeList;
44
1.71M
    __asan_unpoison_memory_region(Val, Size);
45
1.71M
    FreeList = FreeList->Next;
46
1.71M
    __msan_allocated_memory(Val, Size);
47
1.71M
    return Val;
48
1.71M
  }
49
50
120M
  void push(FreeNode *N) {
51
120M
    N->Next = FreeList;
52
120M
    FreeList = N;
53
120M
    __asan_poison_memory_region(N, Size);
54
120M
  }
llvm::Recycler<char, 192ul, 64ul>::push(llvm::Recycler<char, 192ul, 64ul>::FreeNode*)
Line
Count
Source
50
1.04M
  void push(FreeNode *N) {
51
1.04M
    N->Next = FreeList;
52
1.04M
    FreeList = N;
53
1.04M
    __asan_poison_memory_region(N, Size);
54
1.04M
  }
llvm::Recycler<llvm::ScopedHashTableVal<llvm::PointerUnion<llvm::Value const*, llvm::PseudoSourceValue const*>, std::__1::pair<unsigned int, unsigned int> >, 32ul, 8ul>::push(llvm::Recycler<llvm::ScopedHashTableVal<llvm::PointerUnion<llvm::Value const*, llvm::PseudoSourceValue const*>, std::__1::pair<unsigned int, unsigned int> >, 32ul, 8ul>::FreeNode*)
Line
Count
Source
50
1.10k
  void push(FreeNode *N) {
51
1.10k
    N->Next = FreeList;
52
1.10k
    FreeList = N;
53
1.10k
    __asan_poison_memory_region(N, Size);
54
1.10k
  }
llvm::Recycler<llvm::ScopedHashTableVal<llvm::MachineInstr*, unsigned int>, 32ul, 8ul>::push(llvm::Recycler<llvm::ScopedHashTableVal<llvm::MachineInstr*, unsigned int>, 32ul, 8ul>::FreeNode*)
Line
Count
Source
50
6.86M
  void push(FreeNode *N) {
51
6.86M
    N->Next = FreeList;
52
6.86M
    FreeList = N;
53
6.86M
    __asan_poison_memory_region(N, Size);
54
6.86M
  }
llvm::Recycler<llvm::MachineInstr, 72ul, 8ul>::push(llvm::Recycler<llvm::MachineInstr, 72ul, 8ul>::FreeNode*)
Line
Count
Source
50
41.6M
  void push(FreeNode *N) {
51
41.6M
    N->Next = FreeList;
52
41.6M
    FreeList = N;
53
41.6M
    __asan_poison_memory_region(N, Size);
54
41.6M
  }
llvm::Recycler<llvm::MachineBasicBlock, 200ul, 8ul>::push(llvm::Recycler<llvm::MachineBasicBlock, 200ul, 8ul>::FreeNode*)
Line
Count
Source
50
3.78M
  void push(FreeNode *N) {
51
3.78M
    N->Next = FreeList;
52
3.78M
    FreeList = N;
53
3.78M
    __asan_poison_memory_region(N, Size);
54
3.78M
  }
llvm::Recycler<llvm::ScopedHashTableVal<llvm::MemoryLocation, unsigned int>, 64ul, 8ul>::push(llvm::Recycler<llvm::ScopedHashTableVal<llvm::MemoryLocation, unsigned int>, 64ul, 8ul>::FreeNode*)
Line
Count
Source
50
946
  void push(FreeNode *N) {
51
946
    N->Next = FreeList;
52
946
    FreeList = N;
53
946
    __asan_poison_memory_region(N, Size);
54
946
  }
EarlyCSE.cpp:llvm::Recycler<llvm::ScopedHashTableVal<llvm::Value*, (anonymous namespace)::EarlyCSE::LoadValue>, 48ul, 8ul>::push(llvm::Recycler<llvm::ScopedHashTableVal<llvm::Value*, (anonymous namespace)::EarlyCSE::LoadValue>, 48ul, 8ul>::FreeNode*)
Line
Count
Source
50
5.15M
  void push(FreeNode *N) {
51
5.15M
    N->Next = FreeList;
52
5.15M
    FreeList = N;
53
5.15M
    __asan_poison_memory_region(N, Size);
54
5.15M
  }
EarlyCSE.cpp:llvm::Recycler<llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>, 32ul, 8ul>::push(llvm::Recycler<llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>, 32ul, 8ul>::FreeNode*)
Line
Count
Source
50
15.0M
  void push(FreeNode *N) {
51
15.0M
    N->Next = FreeList;
52
15.0M
    FreeList = N;
53
15.0M
    __asan_poison_memory_region(N, Size);
54
15.0M
  }
llvm::Recycler<llvm::SDNode, 104ul, 8ul>::push(llvm::Recycler<llvm::SDNode, 104ul, 8ul>::FreeNode*)
Line
Count
Source
50
46.6M
  void push(FreeNode *N) {
51
46.6M
    N->Next = FreeList;
52
46.6M
    FreeList = N;
53
46.6M
    __asan_poison_memory_region(N, Size);
54
46.6M
  }
55
56
public:
57
8.23M
  ~Recycler() {
58
8.23M
    // If this fails, either the callee has lost track of some allocation,
59
8.23M
    // or the callee isn't tracking allocations and should just call
60
8.23M
    // clear() before deleting the Recycler.
61
8.23M
    assert(!FreeList && "Non-empty recycler deleted!");
62
8.23M
  }
llvm::Recycler<llvm::ScopedHashTableVal<llvm::PointerUnion<llvm::Value const*, llvm::PseudoSourceValue const*>, std::__1::pair<unsigned int, unsigned int> >, 32ul, 8ul>::~Recycler()
Line
Count
Source
57
2.08k
  ~Recycler() {
58
2.08k
    // If this fails, either the callee has lost track of some allocation,
59
2.08k
    // or the callee isn't tracking allocations and should just call
60
2.08k
    // clear() before deleting the Recycler.
61
2.08k
    assert(!FreeList && "Non-empty recycler deleted!");
62
2.08k
  }
llvm::Recycler<char, 192ul, 64ul>::~Recycler()
Line
Count
Source
57
3.68M
  ~Recycler() {
58
3.68M
    // If this fails, either the callee has lost track of some allocation,
59
3.68M
    // or the callee isn't tracking allocations and should just call
60
3.68M
    // clear() before deleting the Recycler.
61
3.68M
    assert(!FreeList && "Non-empty recycler deleted!");
62
3.68M
  }
llvm::Recycler<llvm::ScopedHashTableVal<llvm::MachineInstr*, unsigned int>, 32ul, 8ul>::~Recycler()
Line
Count
Source
57
36.7k
  ~Recycler() {
58
36.7k
    // If this fails, either the callee has lost track of some allocation,
59
36.7k
    // or the callee isn't tracking allocations and should just call
60
36.7k
    // clear() before deleting the Recycler.
61
36.7k
    assert(!FreeList && "Non-empty recycler deleted!");
62
36.7k
  }
llvm::Recycler<llvm::MachineInstr, 72ul, 8ul>::~Recycler()
Line
Count
Source
57
510k
  ~Recycler() {
58
510k
    // If this fails, either the callee has lost track of some allocation,
59
510k
    // or the callee isn't tracking allocations and should just call
60
510k
    // clear() before deleting the Recycler.
61
510k
    assert(!FreeList && "Non-empty recycler deleted!");
62
510k
  }
llvm::Recycler<llvm::MachineBasicBlock, 200ul, 8ul>::~Recycler()
Line
Count
Source
57
510k
  ~Recycler() {
58
510k
    // If this fails, either the callee has lost track of some allocation,
59
510k
    // or the callee isn't tracking allocations and should just call
60
510k
    // clear() before deleting the Recycler.
61
510k
    assert(!FreeList && "Non-empty recycler deleted!");
62
510k
  }
llvm::Recycler<llvm::ScopedHashTableVal<llvm::MemoryLocation, unsigned int>, 64ul, 8ul>::~Recycler()
Line
Count
Source
57
1.15M
  ~Recycler() {
58
1.15M
    // If this fails, either the callee has lost track of some allocation,
59
1.15M
    // or the callee isn't tracking allocations and should just call
60
1.15M
    // clear() before deleting the Recycler.
61
1.15M
    assert(!FreeList && "Non-empty recycler deleted!");
62
1.15M
  }
EarlyCSE.cpp:llvm::Recycler<llvm::ScopedHashTableVal<llvm::Value*, (anonymous namespace)::EarlyCSE::LoadValue>, 48ul, 8ul>::~Recycler()
Line
Count
Source
57
1.15M
  ~Recycler() {
58
1.15M
    // If this fails, either the callee has lost track of some allocation,
59
1.15M
    // or the callee isn't tracking allocations and should just call
60
1.15M
    // clear() before deleting the Recycler.
61
1.15M
    assert(!FreeList && "Non-empty recycler deleted!");
62
1.15M
  }
EarlyCSE.cpp:llvm::Recycler<llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>, 32ul, 8ul>::~Recycler()
Line
Count
Source
57
1.15M
  ~Recycler() {
58
1.15M
    // If this fails, either the callee has lost track of some allocation,
59
1.15M
    // or the callee isn't tracking allocations and should just call
60
1.15M
    // clear() before deleting the Recycler.
61
1.15M
    assert(!FreeList && "Non-empty recycler deleted!");
62
1.15M
  }
llvm::Recycler<llvm::SDNode, 104ul, 8ul>::~Recycler()
Line
Count
Source
57
37.9k
  ~Recycler() {
58
37.9k
    // If this fails, either the callee has lost track of some allocation,
59
37.9k
    // or the callee isn't tracking allocations and should just call
60
37.9k
    // clear() before deleting the Recycler.
61
37.9k
    assert(!FreeList && "Non-empty recycler deleted!");
62
37.9k
  }
63
64
  /// clear - Release all the tracked allocations to the allocator. The
65
  /// recycler must be free of any tracked allocations before being
66
  /// deleted; calling clear is one way to ensure this.
67
  template<class AllocatorType>
68
  void clear(AllocatorType &Allocator) {
69
    while (FreeList) {
70
      T *t = reinterpret_cast<T *>(pop_val());
71
      Allocator.Deallocate(t);
72
    }
73
  }
74
75
  /// Special case for BumpPtrAllocator which has an empty Deallocate()
76
  /// function.
77
  ///
78
  /// There is no need to traverse the free list, pulling all the objects into
79
  /// cache.
80
8.26M
  void clear(BumpPtrAllocator &) { FreeList = nullptr; }
llvm::Recycler<llvm::ScopedHashTableVal<llvm::PointerUnion<llvm::Value const*, llvm::PseudoSourceValue const*>, std::__1::pair<unsigned int, unsigned int> >, 32ul, 8ul>::clear(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
80
2.08k
  void clear(BumpPtrAllocator &) { FreeList = nullptr; }
llvm::Recycler<char, 192ul, 64ul>::clear(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
80
3.68M
  void clear(BumpPtrAllocator &) { FreeList = nullptr; }
llvm::Recycler<llvm::ScopedHashTableVal<llvm::MachineInstr*, unsigned int>, 32ul, 8ul>::clear(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
80
36.7k
  void clear(BumpPtrAllocator &) { FreeList = nullptr; }
llvm::Recycler<llvm::MachineInstr, 72ul, 8ul>::clear(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
80
527k
  void clear(BumpPtrAllocator &) { FreeList = nullptr; }
llvm::Recycler<llvm::MachineBasicBlock, 200ul, 8ul>::clear(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
80
527k
  void clear(BumpPtrAllocator &) { FreeList = nullptr; }
llvm::Recycler<llvm::ScopedHashTableVal<llvm::MemoryLocation, unsigned int>, 64ul, 8ul>::clear(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
80
1.15M
  void clear(BumpPtrAllocator &) { FreeList = nullptr; }
EarlyCSE.cpp:llvm::Recycler<llvm::ScopedHashTableVal<llvm::Value*, (anonymous namespace)::EarlyCSE::LoadValue>, 48ul, 8ul>::clear(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
80
1.15M
  void clear(BumpPtrAllocator &) { FreeList = nullptr; }
EarlyCSE.cpp:llvm::Recycler<llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>, 32ul, 8ul>::clear(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
80
1.15M
  void clear(BumpPtrAllocator &) { FreeList = nullptr; }
llvm::Recycler<llvm::SDNode, 104ul, 8ul>::clear(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
80
37.9k
  void clear(BumpPtrAllocator &) { FreeList = nullptr; }
81
82
  template<class SubClass, class AllocatorType>
83
145M
  SubClass *Allocate(AllocatorType &Allocator) {
84
145M
    static_assert(alignof(SubClass) <= Align,
85
145M
                  "Recycler allocation alignment is less than object align!");
86
145M
    static_assert(sizeof(SubClass) <= Size,
87
145M
                  "Recycler allocation size is less than object size!");
88
145M
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())88.2M
89
145M
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))56.7M
;
90
145M
  }
llvm::ScopedHashTableVal<llvm::PointerUnion<llvm::Value const*, llvm::PseudoSourceValue const*>, std::__1::pair<unsigned int, unsigned int> >* llvm::Recycler<llvm::ScopedHashTableVal<llvm::PointerUnion<llvm::Value const*, llvm::PseudoSourceValue const*>, std::__1::pair<unsigned int, unsigned int> >, 32ul, 8ul>::Allocate<llvm::ScopedHashTableVal<llvm::PointerUnion<llvm::Value const*, llvm::PseudoSourceValue const*>, std::__1::pair<unsigned int, unsigned int> >, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
1.10k
  SubClass *Allocate(AllocatorType &Allocator) {
84
1.10k
    static_assert(alignof(SubClass) <= Align,
85
1.10k
                  "Recycler allocation alignment is less than object align!");
86
1.10k
    static_assert(sizeof(SubClass) <= Size,
87
1.10k
                  "Recycler allocation size is less than object size!");
88
1.10k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())786
89
1.10k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))316
;
90
1.10k
  }
llvm::X86MaskedScatterSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::X86MaskedScatterSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
222
  SubClass *Allocate(AllocatorType &Allocator) {
84
222
    static_assert(alignof(SubClass) <= Align,
85
222
                  "Recycler allocation alignment is less than object align!");
86
222
    static_assert(sizeof(SubClass) <= Size,
87
222
                  "Recycler allocation size is less than object size!");
88
222
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())220
89
222
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))2
;
90
222
  }
llvm::TruncSStoreSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::TruncSStoreSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
48
  SubClass *Allocate(AllocatorType &Allocator) {
84
48
    static_assert(alignof(SubClass) <= Align,
85
48
                  "Recycler allocation alignment is less than object align!");
86
48
    static_assert(sizeof(SubClass) <= Size,
87
48
                  "Recycler allocation size is less than object size!");
88
48
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
89
48
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))0
;
90
48
  }
llvm::TruncUSStoreSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::TruncUSStoreSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
102
  SubClass *Allocate(AllocatorType &Allocator) {
84
102
    static_assert(alignof(SubClass) <= Align,
85
102
                  "Recycler allocation alignment is less than object align!");
86
102
    static_assert(sizeof(SubClass) <= Size,
87
102
                  "Recycler allocation size is less than object size!");
88
102
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
89
102
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))0
;
90
102
  }
llvm::MaskedTruncSStoreSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::MaskedTruncSStoreSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
36
  SubClass *Allocate(AllocatorType &Allocator) {
84
36
    static_assert(alignof(SubClass) <= Align,
85
36
                  "Recycler allocation alignment is less than object align!");
86
36
    static_assert(sizeof(SubClass) <= Size,
87
36
                  "Recycler allocation size is less than object size!");
88
36
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
89
36
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))0
;
90
36
  }
llvm::MaskedTruncUSStoreSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::MaskedTruncUSStoreSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
36
  SubClass *Allocate(AllocatorType &Allocator) {
84
36
    static_assert(alignof(SubClass) <= Align,
85
36
                  "Recycler allocation alignment is less than object align!");
86
36
    static_assert(sizeof(SubClass) <= Size,
87
36
                  "Recycler allocation size is less than object size!");
88
36
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
89
36
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))0
;
90
36
  }
llvm::X86MaskedGatherSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::X86MaskedGatherSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
642
  SubClass *Allocate(AllocatorType &Allocator) {
84
642
    static_assert(alignof(SubClass) <= Align,
85
642
                  "Recycler allocation alignment is less than object align!");
86
642
    static_assert(sizeof(SubClass) <= Size,
87
642
                  "Recycler allocation size is less than object size!");
88
642
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())630
89
642
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))12
;
90
642
  }
llvm::IntervalMapImpl::LeafNode<llvm::SlotIndex, DbgValueLocation, 9u, llvm::IntervalMapInfo<llvm::SlotIndex> >* llvm::Recycler<char, 192ul, 64ul>::Allocate<llvm::IntervalMapImpl::LeafNode<llvm::SlotIndex, DbgValueLocation, 9u, llvm::IntervalMapInfo<llvm::SlotIndex> >, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
5
  SubClass *Allocate(AllocatorType &Allocator) {
84
5
    static_assert(alignof(SubClass) <= Align,
85
5
                  "Recycler allocation alignment is less than object align!");
86
5
    static_assert(sizeof(SubClass) <= Size,
87
5
                  "Recycler allocation size is less than object size!");
88
5
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())0
89
5
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
90
5
  }
Unexecuted instantiation: llvm::IntervalMapImpl::BranchNode<llvm::SlotIndex, DbgValueLocation, 12u, llvm::IntervalMapInfo<llvm::SlotIndex> >* llvm::Recycler<char, 192ul, 64ul>::Allocate<llvm::IntervalMapImpl::BranchNode<llvm::SlotIndex, DbgValueLocation, 12u, llvm::IntervalMapInfo<llvm::SlotIndex> >, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
llvm::IntervalMapImpl::LeafNode<llvm::SlotIndex, llvm::LiveInterval*, 8u, llvm::IntervalMapInfo<llvm::SlotIndex> >* llvm::Recycler<char, 192ul, 64ul>::Allocate<llvm::IntervalMapImpl::LeafNode<llvm::SlotIndex, llvm::LiveInterval*, 8u, llvm::IntervalMapInfo<llvm::SlotIndex> >, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
992k
  SubClass *Allocate(AllocatorType &Allocator) {
84
992k
    static_assert(alignof(SubClass) <= Align,
85
992k
                  "Recycler allocation alignment is less than object align!");
86
992k
    static_assert(sizeof(SubClass) <= Size,
87
992k
                  "Recycler allocation size is less than object size!");
88
992k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())593k
89
992k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))398k
;
90
992k
  }
llvm::IntervalMapImpl::BranchNode<llvm::SlotIndex, llvm::LiveInterval*, 12u, llvm::IntervalMapInfo<llvm::SlotIndex> >* llvm::Recycler<char, 192ul, 64ul>::Allocate<llvm::IntervalMapImpl::BranchNode<llvm::SlotIndex, llvm::LiveInterval*, 12u, llvm::IntervalMapInfo<llvm::SlotIndex> >, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
18.4k
  SubClass *Allocate(AllocatorType &Allocator) {
84
18.4k
    static_assert(alignof(SubClass) <= Align,
85
18.4k
                  "Recycler allocation alignment is less than object align!");
86
18.4k
    static_assert(sizeof(SubClass) <= Size,
87
18.4k
                  "Recycler allocation size is less than object size!");
88
18.4k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())5.24k
89
18.4k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))13.1k
;
90
18.4k
  }
llvm::ScopedHashTableVal<llvm::MachineInstr*, unsigned int>* llvm::Recycler<llvm::ScopedHashTableVal<llvm::MachineInstr*, unsigned int>, 32ul, 8ul>::Allocate<llvm::ScopedHashTableVal<llvm::MachineInstr*, unsigned int>, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
6.86M
  SubClass *Allocate(AllocatorType &Allocator) {
84
6.86M
    static_assert(alignof(SubClass) <= Align,
85
6.86M
                  "Recycler allocation alignment is less than object align!");
86
6.86M
    static_assert(sizeof(SubClass) <= Size,
87
6.86M
                  "Recycler allocation size is less than object size!");
88
6.86M
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())5.78M
89
6.86M
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))1.07M
;
90
6.86M
  }
llvm::MachineInstr* llvm::Recycler<llvm::MachineInstr, 72ul, 8ul>::Allocate<llvm::MachineInstr, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
66.5M
  SubClass *Allocate(AllocatorType &Allocator) {
84
66.5M
    static_assert(alignof(SubClass) <= Align,
85
66.5M
                  "Recycler allocation alignment is less than object align!");
86
66.5M
    static_assert(sizeof(SubClass) <= Size,
87
66.5M
                  "Recycler allocation size is less than object size!");
88
66.5M
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())30.6M
89
66.5M
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))35.9M
;
90
66.5M
  }
llvm::MachineBasicBlock* llvm::Recycler<llvm::MachineBasicBlock, 200ul, 8ul>::Allocate<llvm::MachineBasicBlock, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
3.78M
  SubClass *Allocate(AllocatorType &Allocator) {
84
3.78M
    static_assert(alignof(SubClass) <= Align,
85
3.78M
                  "Recycler allocation alignment is less than object align!");
86
3.78M
    static_assert(sizeof(SubClass) <= Size,
87
3.78M
                  "Recycler allocation size is less than object size!");
88
3.78M
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())103k
89
3.78M
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))3.68M
;
90
3.78M
  }
llvm::IntervalMapImpl::LeafNode<llvm::SlotIndex, unsigned int, 9u, llvm::IntervalMapInfo<llvm::SlotIndex> >* llvm::Recycler<char, 192ul, 64ul>::Allocate<llvm::IntervalMapImpl::LeafNode<llvm::SlotIndex, unsigned int, 9u, llvm::IntervalMapInfo<llvm::SlotIndex> >, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
33.2k
  SubClass *Allocate(AllocatorType &Allocator) {
84
33.2k
    static_assert(alignof(SubClass) <= Align,
85
33.2k
                  "Recycler allocation alignment is less than object align!");
86
33.2k
    static_assert(sizeof(SubClass) <= Size,
87
33.2k
                  "Recycler allocation size is less than object size!");
88
33.2k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())22.6k
89
33.2k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))10.6k
;
90
33.2k
  }
llvm::IntervalMapImpl::BranchNode<llvm::SlotIndex, unsigned int, 12u, llvm::IntervalMapInfo<llvm::SlotIndex> >* llvm::Recycler<char, 192ul, 64ul>::Allocate<llvm::IntervalMapImpl::BranchNode<llvm::SlotIndex, unsigned int, 12u, llvm::IntervalMapInfo<llvm::SlotIndex> >, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
337
  SubClass *Allocate(AllocatorType &Allocator) {
84
337
    static_assert(alignof(SubClass) <= Align,
85
337
                  "Recycler allocation alignment is less than object align!");
86
337
    static_assert(sizeof(SubClass) <= Size,
87
337
                  "Recycler allocation size is less than object size!");
88
337
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())258
89
337
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))79
;
90
337
  }
EarlyCSE.cpp:llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>* llvm::Recycler<llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>, 32ul, 8ul>::Allocate<llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
15.0M
  SubClass *Allocate(AllocatorType &Allocator) {
84
15.0M
    static_assert(alignof(SubClass) <= Align,
85
15.0M
                  "Recycler allocation alignment is less than object align!");
86
15.0M
    static_assert(sizeof(SubClass) <= Size,
87
15.0M
                  "Recycler allocation size is less than object size!");
88
15.0M
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())5.10M
89
15.0M
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))9.91M
;
90
15.0M
  }
llvm::ScopedHashTableVal<llvm::MemoryLocation, unsigned int>* llvm::Recycler<llvm::ScopedHashTableVal<llvm::MemoryLocation, unsigned int>, 64ul, 8ul>::Allocate<llvm::ScopedHashTableVal<llvm::MemoryLocation, unsigned int>, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
946
  SubClass *Allocate(AllocatorType &Allocator) {
84
946
    static_assert(alignof(SubClass) <= Align,
85
946
                  "Recycler allocation alignment is less than object align!");
86
946
    static_assert(sizeof(SubClass) <= Size,
87
946
                  "Recycler allocation size is less than object size!");
88
946
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())28
89
946
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))918
;
90
946
  }
EarlyCSE.cpp:llvm::ScopedHashTableVal<llvm::Value*, (anonymous namespace)::EarlyCSE::LoadValue>* llvm::Recycler<llvm::ScopedHashTableVal<llvm::Value*, (anonymous namespace)::EarlyCSE::LoadValue>, 48ul, 8ul>::Allocate<llvm::ScopedHashTableVal<llvm::Value*, (anonymous namespace)::EarlyCSE::LoadValue>, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
5.15M
  SubClass *Allocate(AllocatorType &Allocator) {
84
5.15M
    static_assert(alignof(SubClass) <= Align,
85
5.15M
                  "Recycler allocation alignment is less than object align!");
86
5.15M
    static_assert(sizeof(SubClass) <= Size,
87
5.15M
                  "Recycler allocation size is less than object size!");
88
5.15M
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())1.71M
89
5.15M
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))3.43M
;
90
5.15M
  }
DAGCombiner.cpp:llvm::IntervalMapImpl::LeafNode<long long, (anonymous namespace)::UnitT, 11u, llvm::IntervalMapHalfOpenInfo<long long> >* llvm::Recycler<char, 192ul, 64ul>::Allocate<llvm::IntervalMapImpl::LeafNode<long long, (anonymous namespace)::UnitT, 11u, llvm::IntervalMapHalfOpenInfo<long long> >, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
170
  SubClass *Allocate(AllocatorType &Allocator) {
84
170
    static_assert(alignof(SubClass) <= Align,
85
170
                  "Recycler allocation alignment is less than object align!");
86
170
    static_assert(sizeof(SubClass) <= Size,
87
170
                  "Recycler allocation size is less than object size!");
88
170
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())0
89
170
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
90
170
  }
Unexecuted instantiation: DAGCombiner.cpp:llvm::IntervalMapImpl::BranchNode<long long, (anonymous namespace)::UnitT, 12u, llvm::IntervalMapHalfOpenInfo<long long> >* llvm::Recycler<char, 192ul, 64ul>::Allocate<llvm::IntervalMapImpl::BranchNode<long long, (anonymous namespace)::UnitT, 12u, llvm::IntervalMapHalfOpenInfo<long long> >, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
llvm::ConstantSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::ConstantSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
9.72M
  SubClass *Allocate(AllocatorType &Allocator) {
84
9.72M
    static_assert(alignof(SubClass) <= Align,
85
9.72M
                  "Recycler allocation alignment is less than object align!");
86
9.72M
    static_assert(sizeof(SubClass) <= Size,
87
9.72M
                  "Recycler allocation size is less than object size!");
88
9.72M
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())9.43M
89
9.72M
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))290k
;
90
9.72M
  }
llvm::ConstantFPSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::ConstantFPSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
70.7k
  SubClass *Allocate(AllocatorType &Allocator) {
84
70.7k
    static_assert(alignof(SubClass) <= Align,
85
70.7k
                  "Recycler allocation alignment is less than object align!");
86
70.7k
    static_assert(sizeof(SubClass) <= Size,
87
70.7k
                  "Recycler allocation size is less than object size!");
88
70.7k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())65.6k
89
70.7k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))5.04k
;
90
70.7k
  }
llvm::GlobalAddressSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::GlobalAddressSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
1.79M
  SubClass *Allocate(AllocatorType &Allocator) {
84
1.79M
    static_assert(alignof(SubClass) <= Align,
85
1.79M
                  "Recycler allocation alignment is less than object align!");
86
1.79M
    static_assert(sizeof(SubClass) <= Size,
87
1.79M
                  "Recycler allocation size is less than object size!");
88
1.79M
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())1.74M
89
1.79M
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))43.5k
;
90
1.79M
  }
llvm::FrameIndexSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::FrameIndexSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
487k
  SubClass *Allocate(AllocatorType &Allocator) {
84
487k
    static_assert(alignof(SubClass) <= Align,
85
487k
                  "Recycler allocation alignment is less than object align!");
86
487k
    static_assert(sizeof(SubClass) <= Size,
87
487k
                  "Recycler allocation size is less than object size!");
88
487k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())465k
89
487k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))21.9k
;
90
487k
  }
llvm::JumpTableSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::JumpTableSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
8.11k
  SubClass *Allocate(AllocatorType &Allocator) {
84
8.11k
    static_assert(alignof(SubClass) <= Align,
85
8.11k
                  "Recycler allocation alignment is less than object align!");
86
8.11k
    static_assert(sizeof(SubClass) <= Size,
87
8.11k
                  "Recycler allocation size is less than object size!");
88
8.11k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())8.11k
89
8.11k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))4
;
90
8.11k
  }
llvm::ConstantPoolSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::ConstantPoolSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
203k
  SubClass *Allocate(AllocatorType &Allocator) {
84
203k
    static_assert(alignof(SubClass) <= Align,
85
203k
                  "Recycler allocation alignment is less than object align!");
86
203k
    static_assert(sizeof(SubClass) <= Size,
87
203k
                  "Recycler allocation size is less than object size!");
88
203k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())201k
89
203k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))1.77k
;
90
203k
  }
Unexecuted instantiation: llvm::TargetIndexSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::TargetIndexSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
llvm::BasicBlockSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::BasicBlockSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
1.23M
  SubClass *Allocate(AllocatorType &Allocator) {
84
1.23M
    static_assert(alignof(SubClass) <= Align,
85
1.23M
                  "Recycler allocation alignment is less than object align!");
86
1.23M
    static_assert(sizeof(SubClass) <= Size,
87
1.23M
                  "Recycler allocation size is less than object size!");
88
1.23M
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())1.19M
89
1.23M
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))39.6k
;
90
1.23M
  }
llvm::VTSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::VTSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
213k
  SubClass *Allocate(AllocatorType &Allocator) {
84
213k
    static_assert(alignof(SubClass) <= Align,
85
213k
                  "Recycler allocation alignment is less than object align!");
86
213k
    static_assert(sizeof(SubClass) <= Size,
87
213k
                  "Recycler allocation size is less than object size!");
88
213k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())208k
89
213k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))4.77k
;
90
213k
  }
llvm::ExternalSymbolSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::ExternalSymbolSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
42.7k
  SubClass *Allocate(AllocatorType &Allocator) {
84
42.7k
    static_assert(alignof(SubClass) <= Align,
85
42.7k
                  "Recycler allocation alignment is less than object align!");
86
42.7k
    static_assert(sizeof(SubClass) <= Size,
87
42.7k
                  "Recycler allocation size is less than object size!");
88
42.7k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())37.9k
89
42.7k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))4.79k
;
90
42.7k
  }
llvm::MCSymbolSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::MCSymbolSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
98
  SubClass *Allocate(AllocatorType &Allocator) {
84
98
    static_assert(alignof(SubClass) <= Align,
85
98
                  "Recycler allocation alignment is less than object align!");
86
98
    static_assert(sizeof(SubClass) <= Size,
87
98
                  "Recycler allocation size is less than object size!");
88
98
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())86
89
98
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))12
;
90
98
  }
llvm::CondCodeSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::CondCodeSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
952k
  SubClass *Allocate(AllocatorType &Allocator) {
84
952k
    static_assert(alignof(SubClass) <= Align,
85
952k
                  "Recycler allocation alignment is less than object align!");
86
952k
    static_assert(sizeof(SubClass) <= Size,
87
952k
                  "Recycler allocation size is less than object size!");
88
952k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())930k
89
952k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))22.4k
;
90
952k
  }
llvm::ShuffleVectorSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::ShuffleVectorSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
155k
  SubClass *Allocate(AllocatorType &Allocator) {
84
155k
    static_assert(alignof(SubClass) <= Align,
85
155k
                  "Recycler allocation alignment is less than object align!");
86
155k
    static_assert(sizeof(SubClass) <= Size,
87
155k
                  "Recycler allocation size is less than object size!");
88
155k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())147k
89
155k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))8.52k
;
90
155k
  }
llvm::RegisterSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::RegisterSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
5.45M
  SubClass *Allocate(AllocatorType &Allocator) {
84
5.45M
    static_assert(alignof(SubClass) <= Align,
85
5.45M
                  "Recycler allocation alignment is less than object align!");
86
5.45M
    static_assert(sizeof(SubClass) <= Size,
87
5.45M
                  "Recycler allocation size is less than object size!");
88
5.45M
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())5.28M
89
5.45M
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))174k
;
90
5.45M
  }
llvm::RegisterMaskSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::RegisterMaskSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
327k
  SubClass *Allocate(AllocatorType &Allocator) {
84
327k
    static_assert(alignof(SubClass) <= Align,
85
327k
                  "Recycler allocation alignment is less than object align!");
86
327k
    static_assert(sizeof(SubClass) <= Size,
87
327k
                  "Recycler allocation size is less than object size!");
88
327k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())319k
89
327k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))8.56k
;
90
327k
  }
llvm::LabelSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::LabelSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
12.7k
  SubClass *Allocate(AllocatorType &Allocator) {
84
12.7k
    static_assert(alignof(SubClass) <= Align,
85
12.7k
                  "Recycler allocation alignment is less than object align!");
86
12.7k
    static_assert(sizeof(SubClass) <= Size,
87
12.7k
                  "Recycler allocation size is less than object size!");
88
12.7k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())12.0k
89
12.7k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))698
;
90
12.7k
  }
llvm::BlockAddressSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::BlockAddressSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
303
  SubClass *Allocate(AllocatorType &Allocator) {
84
303
    static_assert(alignof(SubClass) <= Align,
85
303
                  "Recycler allocation alignment is less than object align!");
86
303
    static_assert(sizeof(SubClass) <= Size,
87
303
                  "Recycler allocation size is less than object size!");
88
303
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())215
89
303
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))88
;
90
303
  }
llvm::SrcValueSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::SrcValueSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
1.64k
  SubClass *Allocate(AllocatorType &Allocator) {
84
1.64k
    static_assert(alignof(SubClass) <= Align,
85
1.64k
                  "Recycler allocation alignment is less than object align!");
86
1.64k
    static_assert(sizeof(SubClass) <= Size,
87
1.64k
                  "Recycler allocation size is less than object size!");
88
1.64k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())1.50k
89
1.64k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))141
;
90
1.64k
  }
llvm::MDNodeSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::MDNodeSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
20.9k
  SubClass *Allocate(AllocatorType &Allocator) {
84
20.9k
    static_assert(alignof(SubClass) <= Align,
85
20.9k
                  "Recycler allocation alignment is less than object align!");
86
20.9k
    static_assert(sizeof(SubClass) <= Size,
87
20.9k
                  "Recycler allocation size is less than object size!");
88
20.9k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())15.6k
89
20.9k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))5.31k
;
90
20.9k
  }
llvm::AddrSpaceCastSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::AddrSpaceCastSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
228
  SubClass *Allocate(AllocatorType &Allocator) {
84
228
    static_assert(alignof(SubClass) <= Align,
85
228
                  "Recycler allocation alignment is less than object align!");
86
228
    static_assert(sizeof(SubClass) <= Size,
87
228
                  "Recycler allocation size is less than object size!");
88
228
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())171
89
228
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))57
;
90
228
  }
llvm::SDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::SDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
22.4M
  SubClass *Allocate(AllocatorType &Allocator) {
84
22.4M
    static_assert(alignof(SubClass) <= Align,
85
22.4M
                  "Recycler allocation alignment is less than object align!");
86
22.4M
    static_assert(sizeof(SubClass) <= Size,
87
22.4M
                  "Recycler allocation size is less than object size!");
88
22.4M
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())20.9M
89
22.4M
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))1.45M
;
90
22.4M
  }
llvm::AtomicSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::AtomicSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
24.1k
  SubClass *Allocate(AllocatorType &Allocator) {
84
24.1k
    static_assert(alignof(SubClass) <= Align,
85
24.1k
                  "Recycler allocation alignment is less than object align!");
86
24.1k
    static_assert(sizeof(SubClass) <= Size,
87
24.1k
                  "Recycler allocation size is less than object size!");
88
24.1k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())23.1k
89
24.1k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))947
;
90
24.1k
  }
llvm::MemIntrinsicSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::MemIntrinsicSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
88.0k
  SubClass *Allocate(AllocatorType &Allocator) {
84
88.0k
    static_assert(alignof(SubClass) <= Align,
85
88.0k
                  "Recycler allocation alignment is less than object align!");
86
88.0k
    static_assert(sizeof(SubClass) <= Size,
87
88.0k
                  "Recycler allocation size is less than object size!");
88
88.0k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())73.6k
89
88.0k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))14.4k
;
90
88.0k
  }
llvm::LifetimeSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::LifetimeSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
68.1k
  SubClass *Allocate(AllocatorType &Allocator) {
84
68.1k
    static_assert(alignof(SubClass) <= Align,
85
68.1k
                  "Recycler allocation alignment is less than object align!");
86
68.1k
    static_assert(sizeof(SubClass) <= Size,
87
68.1k
                  "Recycler allocation size is less than object size!");
88
68.1k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())65.2k
89
68.1k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))2.91k
;
90
68.1k
  }
llvm::LoadSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::LoadSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
1.39M
  SubClass *Allocate(AllocatorType &Allocator) {
84
1.39M
    static_assert(alignof(SubClass) <= Align,
85
1.39M
                  "Recycler allocation alignment is less than object align!");
86
1.39M
    static_assert(sizeof(SubClass) <= Size,
87
1.39M
                  "Recycler allocation size is less than object size!");
88
1.39M
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())1.30M
89
1.39M
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))87.8k
;
90
1.39M
  }
llvm::StoreSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::StoreSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
1.26M
  SubClass *Allocate(AllocatorType &Allocator) {
84
1.26M
    static_assert(alignof(SubClass) <= Align,
85
1.26M
                  "Recycler allocation alignment is less than object align!");
86
1.26M
    static_assert(sizeof(SubClass) <= Size,
87
1.26M
                  "Recycler allocation size is less than object size!");
88
1.26M
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())1.18M
89
1.26M
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))83.2k
;
90
1.26M
  }
llvm::MaskedLoadSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::MaskedLoadSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
814
  SubClass *Allocate(AllocatorType &Allocator) {
84
814
    static_assert(alignof(SubClass) <= Align,
85
814
                  "Recycler allocation alignment is less than object align!");
86
814
    static_assert(sizeof(SubClass) <= Size,
87
814
                  "Recycler allocation size is less than object size!");
88
814
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())762
89
814
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))52
;
90
814
  }
llvm::MaskedStoreSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::MaskedStoreSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
872
  SubClass *Allocate(AllocatorType &Allocator) {
84
872
    static_assert(alignof(SubClass) <= Align,
85
872
                  "Recycler allocation alignment is less than object align!");
86
872
    static_assert(sizeof(SubClass) <= Size,
87
872
                  "Recycler allocation size is less than object size!");
88
872
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())841
89
872
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))31
;
90
872
  }
llvm::MaskedGatherSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::MaskedGatherSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
469
  SubClass *Allocate(AllocatorType &Allocator) {
84
469
    static_assert(alignof(SubClass) <= Align,
85
469
                  "Recycler allocation alignment is less than object align!");
86
469
    static_assert(sizeof(SubClass) <= Size,
87
469
                  "Recycler allocation size is less than object size!");
88
469
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())443
89
469
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))26
;
90
469
  }
llvm::MaskedScatterSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::MaskedScatterSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
174
  SubClass *Allocate(AllocatorType &Allocator) {
84
174
    static_assert(alignof(SubClass) <= Align,
85
174
                  "Recycler allocation alignment is less than object align!");
86
174
    static_assert(sizeof(SubClass) <= Size,
87
174
                  "Recycler allocation size is less than object size!");
88
174
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())171
89
174
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))3
;
90
174
  }
llvm::MachineSDNode* llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Allocate<llvm::MachineSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
83
671k
  SubClass *Allocate(AllocatorType &Allocator) {
84
671k
    static_assert(alignof(SubClass) <= Align,
85
671k
                  "Recycler allocation alignment is less than object align!");
86
671k
    static_assert(sizeof(SubClass) <= Size,
87
671k
                  "Recycler allocation size is less than object size!");
88
671k
    return FreeList ? 
reinterpret_cast<SubClass *>(pop_val())646k
89
671k
                    : 
static_cast<SubClass *>(Allocator.Allocate(Size, Align))25.4k
;
90
671k
  }
91
92
  template<class AllocatorType>
93
  T *Allocate(AllocatorType &Allocator) {
94
    return Allocate<T>(Allocator);
95
  }
96
97
  template<class SubClass, class AllocatorType>
98
120M
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
99
120M
    push(reinterpret_cast<FreeNode *>(Element));
100
120M
  }
void llvm::Recycler<char, 192ul, 64ul>::Deallocate<llvm::IntervalMapImpl::BranchNode<llvm::SlotIndex, llvm::LiveInterval*, 12u, llvm::IntervalMapInfo<llvm::SlotIndex> >, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&, llvm::IntervalMapImpl::BranchNode<llvm::SlotIndex, llvm::LiveInterval*, 12u, llvm::IntervalMapInfo<llvm::SlotIndex> >*)
Line
Count
Source
98
18.4k
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
99
18.4k
    push(reinterpret_cast<FreeNode *>(Element));
100
18.4k
  }
void llvm::Recycler<char, 192ul, 64ul>::Deallocate<llvm::IntervalMapImpl::LeafNode<llvm::SlotIndex, llvm::LiveInterval*, 8u, llvm::IntervalMapInfo<llvm::SlotIndex> >, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&, llvm::IntervalMapImpl::LeafNode<llvm::SlotIndex, llvm::LiveInterval*, 8u, llvm::IntervalMapInfo<llvm::SlotIndex> >*)
Line
Count
Source
98
992k
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
99
992k
    push(reinterpret_cast<FreeNode *>(Element));
100
992k
  }
void llvm::Recycler<llvm::ScopedHashTableVal<llvm::PointerUnion<llvm::Value const*, llvm::PseudoSourceValue const*>, std::__1::pair<unsigned int, unsigned int> >, 32ul, 8ul>::Deallocate<llvm::ScopedHashTableVal<llvm::PointerUnion<llvm::Value const*, llvm::PseudoSourceValue const*>, std::__1::pair<unsigned int, unsigned int> >, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&, llvm::ScopedHashTableVal<llvm::PointerUnion<llvm::Value const*, llvm::PseudoSourceValue const*>, std::__1::pair<unsigned int, unsigned int> >*)
Line
Count
Source
98
1.10k
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
99
1.10k
    push(reinterpret_cast<FreeNode *>(Element));
100
1.10k
  }
Unexecuted instantiation: void llvm::Recycler<char, 192ul, 64ul>::Deallocate<llvm::IntervalMapImpl::BranchNode<llvm::SlotIndex, DbgValueLocation, 12u, llvm::IntervalMapInfo<llvm::SlotIndex> >, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&, llvm::IntervalMapImpl::BranchNode<llvm::SlotIndex, DbgValueLocation, 12u, llvm::IntervalMapInfo<llvm::SlotIndex> >*)
void llvm::Recycler<char, 192ul, 64ul>::Deallocate<llvm::IntervalMapImpl::LeafNode<llvm::SlotIndex, DbgValueLocation, 9u, llvm::IntervalMapInfo<llvm::SlotIndex> >, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&, llvm::IntervalMapImpl::LeafNode<llvm::SlotIndex, DbgValueLocation, 9u, llvm::IntervalMapInfo<llvm::SlotIndex> >*)
Line
Count
Source
98
5
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
99
5
    push(reinterpret_cast<FreeNode *>(Element));
100
5
  }
void llvm::Recycler<llvm::ScopedHashTableVal<llvm::MachineInstr*, unsigned int>, 32ul, 8ul>::Deallocate<llvm::ScopedHashTableVal<llvm::MachineInstr*, unsigned int>, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&, llvm::ScopedHashTableVal<llvm::MachineInstr*, unsigned int>*)
Line
Count
Source
98
6.86M
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
99
6.86M
    push(reinterpret_cast<FreeNode *>(Element));
100
6.86M
  }
void llvm::Recycler<llvm::MachineInstr, 72ul, 8ul>::Deallocate<llvm::MachineInstr, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&, llvm::MachineInstr*)
Line
Count
Source
98
41.6M
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
99
41.6M
    push(reinterpret_cast<FreeNode *>(Element));
100
41.6M
  }
void llvm::Recycler<llvm::MachineBasicBlock, 200ul, 8ul>::Deallocate<llvm::MachineBasicBlock, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&, llvm::MachineBasicBlock*)
Line
Count
Source
98
3.78M
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
99
3.78M
    push(reinterpret_cast<FreeNode *>(Element));
100
3.78M
  }
void llvm::Recycler<char, 192ul, 64ul>::Deallocate<llvm::IntervalMapImpl::BranchNode<llvm::SlotIndex, unsigned int, 12u, llvm::IntervalMapInfo<llvm::SlotIndex> >, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&, llvm::IntervalMapImpl::BranchNode<llvm::SlotIndex, unsigned int, 12u, llvm::IntervalMapInfo<llvm::SlotIndex> >*)
Line
Count
Source
98
337
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
99
337
    push(reinterpret_cast<FreeNode *>(Element));
100
337
  }
void llvm::Recycler<char, 192ul, 64ul>::Deallocate<llvm::IntervalMapImpl::LeafNode<llvm::SlotIndex, unsigned int, 9u, llvm::IntervalMapInfo<llvm::SlotIndex> >, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&, llvm::IntervalMapImpl::LeafNode<llvm::SlotIndex, unsigned int, 9u, llvm::IntervalMapInfo<llvm::SlotIndex> >*)
Line
Count
Source
98
33.2k
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
99
33.2k
    push(reinterpret_cast<FreeNode *>(Element));
100
33.2k
  }
void llvm::Recycler<llvm::ScopedHashTableVal<llvm::MemoryLocation, unsigned int>, 64ul, 8ul>::Deallocate<llvm::ScopedHashTableVal<llvm::MemoryLocation, unsigned int>, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&, llvm::ScopedHashTableVal<llvm::MemoryLocation, unsigned int>*)
Line
Count
Source
98
946
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
99
946
    push(reinterpret_cast<FreeNode *>(Element));
100
946
  }
EarlyCSE.cpp:void llvm::Recycler<llvm::ScopedHashTableVal<llvm::Value*, (anonymous namespace)::EarlyCSE::LoadValue>, 48ul, 8ul>::Deallocate<llvm::ScopedHashTableVal<llvm::Value*, (anonymous namespace)::EarlyCSE::LoadValue>, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&, llvm::ScopedHashTableVal<llvm::Value*, (anonymous namespace)::EarlyCSE::LoadValue>*)
Line
Count
Source
98
5.15M
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
99
5.15M
    push(reinterpret_cast<FreeNode *>(Element));
100
5.15M
  }
EarlyCSE.cpp:void llvm::Recycler<llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>, 32ul, 8ul>::Deallocate<llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>*)
Line
Count
Source
98
15.0M
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
99
15.0M
    push(reinterpret_cast<FreeNode *>(Element));
100
15.0M
  }
DAGCombiner.cpp:void llvm::Recycler<char, 192ul, 64ul>::Deallocate<llvm::IntervalMapImpl::LeafNode<long long, (anonymous namespace)::UnitT, 11u, llvm::IntervalMapHalfOpenInfo<long long> >, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&, llvm::IntervalMapImpl::LeafNode<long long, (anonymous namespace)::UnitT, 11u, llvm::IntervalMapHalfOpenInfo<long long> >*)
Line
Count
Source
98
170
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
99
170
    push(reinterpret_cast<FreeNode *>(Element));
100
170
  }
Unexecuted instantiation: DAGCombiner.cpp:void llvm::Recycler<char, 192ul, 64ul>::Deallocate<llvm::IntervalMapImpl::BranchNode<long long, (anonymous namespace)::UnitT, 12u, llvm::IntervalMapHalfOpenInfo<long long> >, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&, llvm::IntervalMapImpl::BranchNode<long long, (anonymous namespace)::UnitT, 12u, llvm::IntervalMapHalfOpenInfo<long long> >*)
void llvm::Recycler<llvm::SDNode, 104ul, 8ul>::Deallocate<llvm::SDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&, llvm::SDNode*)
Line
Count
Source
98
46.6M
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
99
46.6M
    push(reinterpret_cast<FreeNode *>(Element));
100
46.6M
  }
101
102
  void PrintStats();
103
};
104
105
template <class T, size_t Size, size_t Align>
106
void Recycler<T, Size, Align>::PrintStats() {
107
  size_t S = 0;
108
  for (auto *I = FreeList; I; I = I->Next)
109
    ++S;
110
  PrintRecyclerStats(Size, Align, S);
111
}
112
113
}
114
115
#endif