Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/Support/Recycler.h
Line
Count
Source
1
//==- llvm/Support/Recycler.h - Recycling Allocator --------------*- C++ -*-==//
2
//
3
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
//
10
// This file defines the Recycler class template.  See the doxygen comment for
11
// Recycler for more details.
12
//
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_SUPPORT_RECYCLER_H
16
#define LLVM_SUPPORT_RECYCLER_H
17
18
#include "llvm/ADT/ilist.h"
19
#include "llvm/Support/Allocator.h"
20
#include "llvm/Support/ErrorHandling.h"
21
#include <cassert>
22
23
namespace llvm {
24
25
/// PrintRecyclingAllocatorStats - Helper for RecyclingAllocator for
26
/// printing statistics.
27
///
28
void PrintRecyclerStats(size_t Size, size_t Align, size_t FreeListSize);
29
30
/// Recycler - This class manages a linked-list of deallocated nodes
31
/// and facilitates reusing deallocated memory in place of allocating
32
/// new memory.
33
///
34
template <class T, size_t Size = sizeof(T), size_t Align = alignof(T)>
35
class Recycler {
36
  struct FreeNode {
37
    FreeNode *Next;
38
  };
39
40
  /// List of nodes that have deleted contents and are not in active use.
41
  FreeNode *FreeList = nullptr;
42
43
166M
  FreeNode *pop_val() {
44
166M
    auto *Val = FreeList;
45
166M
    __asan_unpoison_memory_region(Val, Size);
46
166M
    FreeList = FreeList->Next;
47
166M
    __msan_allocated_memory(Val, Size);
48
166M
    return Val;
49
166M
  }
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
43
771
  FreeNode *pop_val() {
44
771
    auto *Val = FreeList;
45
771
    __asan_unpoison_memory_region(Val, Size);
46
771
    FreeList = FreeList->Next;
47
771
    __msan_allocated_memory(Val, Size);
48
771
    return Val;
49
771
  }
llvm::Recycler<llvm::SDNode, 104ul, 8ul>::pop_val()
Line
Count
Source
43
112M
  FreeNode *pop_val() {
44
112M
    auto *Val = FreeList;
45
112M
    __asan_unpoison_memory_region(Val, Size);
46
112M
    FreeList = FreeList->Next;
47
112M
    __msan_allocated_memory(Val, Size);
48
112M
    return Val;
49
112M
  }
llvm::Recycler<char, 192ul, 64ul>::pop_val()
Line
Count
Source
43
706k
  FreeNode *pop_val() {
44
706k
    auto *Val = FreeList;
45
706k
    __asan_unpoison_memory_region(Val, Size);
46
706k
    FreeList = FreeList->Next;
47
706k
    __msan_allocated_memory(Val, Size);
48
706k
    return Val;
49
706k
  }
llvm::Recycler<llvm::ScopedHashTableVal<llvm::MachineInstr*, unsigned int>, 32ul, 8ul>::pop_val()
Line
Count
Source
43
6.64M
  FreeNode *pop_val() {
44
6.64M
    auto *Val = FreeList;
45
6.64M
    __asan_unpoison_memory_region(Val, Size);
46
6.64M
    FreeList = FreeList->Next;
47
6.64M
    __msan_allocated_memory(Val, Size);
48
6.64M
    return Val;
49
6.64M
  }
llvm::Recycler<llvm::MachineInstr, 64ul, 8ul>::pop_val()
Line
Count
Source
43
36.6M
  FreeNode *pop_val() {
44
36.6M
    auto *Val = FreeList;
45
36.6M
    __asan_unpoison_memory_region(Val, Size);
46
36.6M
    FreeList = FreeList->Next;
47
36.6M
    __msan_allocated_memory(Val, Size);
48
36.6M
    return Val;
49
36.6M
  }
llvm::Recycler<llvm::MachineBasicBlock, 176ul, 8ul>::pop_val()
Line
Count
Source
43
85.8k
  FreeNode *pop_val() {
44
85.8k
    auto *Val = FreeList;
45
85.8k
    __asan_unpoison_memory_region(Val, Size);
46
85.8k
    FreeList = FreeList->Next;
47
85.8k
    __msan_allocated_memory(Val, Size);
48
85.8k
    return Val;
49
85.8k
  }
EarlyCSE.cpp:llvm::Recycler<llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>, 32ul, 8ul>::pop_val()
Line
Count
Source
43
7.33M
  FreeNode *pop_val() {
44
7.33M
    auto *Val = FreeList;
45
7.33M
    __asan_unpoison_memory_region(Val, Size);
46
7.33M
    FreeList = FreeList->Next;
47
7.33M
    __msan_allocated_memory(Val, Size);
48
7.33M
    return Val;
49
7.33M
  }
EarlyCSE.cpp:llvm::Recycler<llvm::ScopedHashTableVal<llvm::Value*, (anonymous namespace)::EarlyCSE::LoadValue>, 48ul, 8ul>::pop_val()
Line
Count
Source
43
2.54M
  FreeNode *pop_val() {
44
2.54M
    auto *Val = FreeList;
45
2.54M
    __asan_unpoison_memory_region(Val, Size);
46
2.54M
    FreeList = FreeList->Next;
47
2.54M
    __msan_allocated_memory(Val, Size);
48
2.54M
    return Val;
49
2.54M
  }
50
51
211M
  void push(FreeNode *N) {
52
211M
    N->Next = FreeList;
53
211M
    FreeList = N;
54
211M
    __asan_poison_memory_region(N, Size);
55
211M
  }
llvm::Recycler<llvm::SDNode, 104ul, 8ul>::push(llvm::Recycler<llvm::SDNode, 104ul, 8ul>::FreeNode*)
Line
Count
Source
51
115M
  void push(FreeNode *N) {
52
115M
    N->Next = FreeList;
53
115M
    FreeList = N;
54
115M
    __asan_poison_memory_region(N, Size);
55
115M
  }
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
51
21.3M
  void push(FreeNode *N) {
52
21.3M
    N->Next = FreeList;
53
21.3M
    FreeList = N;
54
21.3M
    __asan_poison_memory_region(N, Size);
55
21.3M
  }
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
51
7.22M
  void push(FreeNode *N) {
52
7.22M
    N->Next = FreeList;
53
7.22M
    FreeList = N;
54
7.22M
    __asan_poison_memory_region(N, Size);
55
7.22M
  }
llvm::Recycler<llvm::MachineBasicBlock, 176ul, 8ul>::push(llvm::Recycler<llvm::MachineBasicBlock, 176ul, 8ul>::FreeNode*)
Line
Count
Source
51
5.99M
  void push(FreeNode *N) {
52
5.99M
    N->Next = FreeList;
53
5.99M
    FreeList = N;
54
5.99M
    __asan_poison_memory_region(N, Size);
55
5.99M
  }
llvm::Recycler<llvm::MachineInstr, 64ul, 8ul>::push(llvm::Recycler<llvm::MachineInstr, 64ul, 8ul>::FreeNode*)
Line
Count
Source
51
51.9M
  void push(FreeNode *N) {
52
51.9M
    N->Next = FreeList;
53
51.9M
    FreeList = N;
54
51.9M
    __asan_poison_memory_region(N, Size);
55
51.9M
  }
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
51
7.87M
  void push(FreeNode *N) {
52
7.87M
    N->Next = FreeList;
53
7.87M
    FreeList = N;
54
7.87M
    __asan_poison_memory_region(N, Size);
55
7.87M
  }
llvm::Recycler<char, 192ul, 64ul>::push(llvm::Recycler<char, 192ul, 64ul>::FreeNode*)
Line
Count
Source
51
1.31M
  void push(FreeNode *N) {
52
1.31M
    N->Next = FreeList;
53
1.31M
    FreeList = N;
54
1.31M
    __asan_poison_memory_region(N, Size);
55
1.31M
  }
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
51
1.04k
  void push(FreeNode *N) {
52
1.04k
    N->Next = FreeList;
53
1.04k
    FreeList = N;
54
1.04k
    __asan_poison_memory_region(N, Size);
55
1.04k
  }
56
57
public:
58
4.56M
  ~Recycler() {
59
4.56M
    // If this fails, either the callee has lost track of some allocation,
60
4.56M
    // or the callee isn't tracking allocations and should just call
61
4.56M
    // clear() before deleting the Recycler.
62
4.56M
    assert(!FreeList && "Non-empty recycler deleted!");
63
4.56M
  }
llvm::Recycler<llvm::SDNode, 104ul, 8ul>::~Recycler()
Line
Count
Source
58
35.0k
  ~Recycler() {
59
35.0k
    // If this fails, either the callee has lost track of some allocation,
60
35.0k
    // or the callee isn't tracking allocations and should just call
61
35.0k
    // clear() before deleting the Recycler.
62
35.0k
    assert(!FreeList && "Non-empty recycler deleted!");
63
35.0k
  }
EarlyCSE.cpp:llvm::Recycler<llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>, 32ul, 8ul>::~Recycler()
Line
Count
Source
58
1.33M
  ~Recycler() {
59
1.33M
    // If this fails, either the callee has lost track of some allocation,
60
1.33M
    // or the callee isn't tracking allocations and should just call
61
1.33M
    // clear() before deleting the Recycler.
62
1.33M
    assert(!FreeList && "Non-empty recycler deleted!");
63
1.33M
  }
EarlyCSE.cpp:llvm::Recycler<llvm::ScopedHashTableVal<llvm::Value*, (anonymous namespace)::EarlyCSE::LoadValue>, 48ul, 8ul>::~Recycler()
Line
Count
Source
58
1.33M
  ~Recycler() {
59
1.33M
    // If this fails, either the callee has lost track of some allocation,
60
1.33M
    // or the callee isn't tracking allocations and should just call
61
1.33M
    // clear() before deleting the Recycler.
62
1.33M
    assert(!FreeList && "Non-empty recycler deleted!");
63
1.33M
  }
llvm::Recycler<llvm::MachineBasicBlock, 176ul, 8ul>::~Recycler()
Line
Count
Source
58
598k
  ~Recycler() {
59
598k
    // If this fails, either the callee has lost track of some allocation,
60
598k
    // or the callee isn't tracking allocations and should just call
61
598k
    // clear() before deleting the Recycler.
62
598k
    assert(!FreeList && "Non-empty recycler deleted!");
63
598k
  }
llvm::Recycler<llvm::MachineInstr, 64ul, 8ul>::~Recycler()
Line
Count
Source
58
598k
  ~Recycler() {
59
598k
    // If this fails, either the callee has lost track of some allocation,
60
598k
    // or the callee isn't tracking allocations and should just call
61
598k
    // clear() before deleting the Recycler.
62
598k
    assert(!FreeList && "Non-empty recycler deleted!");
63
598k
  }
llvm::Recycler<llvm::ScopedHashTableVal<llvm::MachineInstr*, unsigned int>, 32ul, 8ul>::~Recycler()
Line
Count
Source
58
33.4k
  ~Recycler() {
59
33.4k
    // If this fails, either the callee has lost track of some allocation,
60
33.4k
    // or the callee isn't tracking allocations and should just call
61
33.4k
    // clear() before deleting the Recycler.
62
33.4k
    assert(!FreeList && "Non-empty recycler deleted!");
63
33.4k
  }
llvm::Recycler<char, 192ul, 64ul>::~Recycler()
Line
Count
Source
58
619k
  ~Recycler() {
59
619k
    // If this fails, either the callee has lost track of some allocation,
60
619k
    // or the callee isn't tracking allocations and should just call
61
619k
    // clear() before deleting the Recycler.
62
619k
    assert(!FreeList && "Non-empty recycler deleted!");
63
619k
  }
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
58
1.72k
  ~Recycler() {
59
1.72k
    // If this fails, either the callee has lost track of some allocation,
60
1.72k
    // or the callee isn't tracking allocations and should just call
61
1.72k
    // clear() before deleting the Recycler.
62
1.72k
    assert(!FreeList && "Non-empty recycler deleted!");
63
1.72k
  }
64
65
  /// clear - Release all the tracked allocations to the allocator. The
66
  /// recycler must be free of any tracked allocations before being
67
  /// deleted; calling clear is one way to ensure this.
68
  template<class AllocatorType>
69
  void clear(AllocatorType &Allocator) {
70
    while (FreeList) {
71
      T *t = reinterpret_cast<T *>(pop_val());
72
      Allocator.Deallocate(t);
73
    }
74
  }
75
76
  /// Special case for BumpPtrAllocator which has an empty Deallocate()
77
  /// function.
78
  ///
79
  /// There is no need to traverse the free list, pulling all the objects into
80
  /// cache.
81
4.69M
  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
81
1.72k
  void clear(BumpPtrAllocator &) { FreeList = nullptr; }
llvm::Recycler<char, 192ul, 64ul>::clear(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
81
619k
  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
81
33.4k
  void clear(BumpPtrAllocator &) { FreeList = nullptr; }
llvm::Recycler<llvm::SDNode, 104ul, 8ul>::clear(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
81
35.0k
  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
81
1.33M
  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
81
1.33M
  void clear(BumpPtrAllocator &) { FreeList = nullptr; }
llvm::Recycler<llvm::MachineBasicBlock, 176ul, 8ul>::clear(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
81
661k
  void clear(BumpPtrAllocator &) { FreeList = nullptr; }
llvm::Recycler<llvm::MachineInstr, 64ul, 8ul>::clear(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
81
661k
  void clear(BumpPtrAllocator &) { FreeList = nullptr; }
82
83
  template<class SubClass, class AllocatorType>
84
250M
  SubClass *Allocate(AllocatorType &Allocator) {
85
250M
    static_assert(alignof(SubClass) <= Align,
86
250M
                  "Recycler allocation alignment is less than object align!");
87
250M
    static_assert(sizeof(SubClass) <= Size,
88
250M
                  "Recycler allocation size is less than object size!");
89
166M
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
84.6M
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
250M
  }
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
84
19.5k
  SubClass *Allocate(AllocatorType &Allocator) {
85
19.5k
    static_assert(alignof(SubClass) <= Align,
86
19.5k
                  "Recycler allocation alignment is less than object align!");
87
19.5k
    static_assert(sizeof(SubClass) <= Size,
88
19.5k
                  "Recycler allocation size is less than object size!");
89
3.60k
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
15.9k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
19.5k
  }
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
84
49
  SubClass *Allocate(AllocatorType &Allocator) {
85
49
    static_assert(alignof(SubClass) <= Align,
86
49
                  "Recycler allocation alignment is less than object align!");
87
49
    static_assert(sizeof(SubClass) <= Size,
88
49
                  "Recycler allocation size is less than object size!");
89
45
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
4
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
49
  }
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
84
6.00M
  SubClass *Allocate(AllocatorType &Allocator) {
85
6.00M
    static_assert(alignof(SubClass) <= Align,
86
6.00M
                  "Recycler allocation alignment is less than object align!");
87
6.00M
    static_assert(sizeof(SubClass) <= Size,
88
6.00M
                  "Recycler allocation size is less than object size!");
89
5.92M
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
79.8k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
6.00M
  }
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
84
1.04k
  SubClass *Allocate(AllocatorType &Allocator) {
85
1.04k
    static_assert(alignof(SubClass) <= Align,
86
1.04k
                  "Recycler allocation alignment is less than object align!");
87
1.04k
    static_assert(sizeof(SubClass) <= Size,
88
1.04k
                  "Recycler allocation size is less than object size!");
89
771
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
275
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
1.04k
  }
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
84
19
  SubClass *Allocate(AllocatorType &Allocator) {
85
19
    static_assert(alignof(SubClass) <= Align,
86
19
                  "Recycler allocation alignment is less than object align!");
87
19
    static_assert(sizeof(SubClass) <= Size,
88
19
                  "Recycler allocation size is less than object size!");
89
19
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
0
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
19
  }
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
84
29
  SubClass *Allocate(AllocatorType &Allocator) {
85
29
    static_assert(alignof(SubClass) <= Align,
86
29
                  "Recycler allocation alignment is less than object align!");
87
29
    static_assert(sizeof(SubClass) <= Size,
88
29
                  "Recycler allocation size is less than object size!");
89
29
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
0
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
29
  }
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
84
19
  SubClass *Allocate(AllocatorType &Allocator) {
85
19
    static_assert(alignof(SubClass) <= Align,
86
19
                  "Recycler allocation alignment is less than object align!");
87
19
    static_assert(sizeof(SubClass) <= Size,
88
19
                  "Recycler allocation size is less than object size!");
89
19
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
0
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
19
  }
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
84
19
  SubClass *Allocate(AllocatorType &Allocator) {
85
19
    static_assert(alignof(SubClass) <= Align,
86
19
                  "Recycler allocation alignment is less than object align!");
87
19
    static_assert(sizeof(SubClass) <= Size,
88
19
                  "Recycler allocation size is less than object size!");
89
19
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
0
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
19
  }
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
84
9
  SubClass *Allocate(AllocatorType &Allocator) {
85
9
    static_assert(alignof(SubClass) <= Align,
86
9
                  "Recycler allocation alignment is less than object align!");
87
9
    static_assert(sizeof(SubClass) <= Size,
88
9
                  "Recycler allocation size is less than object size!");
89
9
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
0
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
9
  }
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
84
46.3k
  SubClass *Allocate(AllocatorType &Allocator) {
85
46.3k
    static_assert(alignof(SubClass) <= Align,
86
46.3k
                  "Recycler allocation alignment is less than object align!");
87
46.3k
    static_assert(sizeof(SubClass) <= Size,
88
46.3k
                  "Recycler allocation size is less than object size!");
89
17.7k
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
28.5k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
46.3k
  }
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
84
178
  SubClass *Allocate(AllocatorType &Allocator) {
85
178
    static_assert(alignof(SubClass) <= Align,
86
178
                  "Recycler allocation alignment is less than object align!");
87
178
    static_assert(sizeof(SubClass) <= Size,
88
178
                  "Recycler allocation size is less than object size!");
89
100
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
78
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
178
  }
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
84
1.24M
  SubClass *Allocate(AllocatorType &Allocator) {
85
1.24M
    static_assert(alignof(SubClass) <= Align,
86
1.24M
                  "Recycler allocation alignment is less than object align!");
87
1.24M
    static_assert(sizeof(SubClass) <= Size,
88
1.24M
                  "Recycler allocation size is less than object size!");
89
685k
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
562k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
1.24M
  }
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
84
1.18M
  SubClass *Allocate(AllocatorType &Allocator) {
85
1.18M
    static_assert(alignof(SubClass) <= Align,
86
1.18M
                  "Recycler allocation alignment is less than object align!");
87
1.18M
    static_assert(sizeof(SubClass) <= Size,
88
1.18M
                  "Recycler allocation size is less than object size!");
89
1.15M
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
27.5k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
1.18M
  }
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
84
7.87M
  SubClass *Allocate(AllocatorType &Allocator) {
85
7.87M
    static_assert(alignof(SubClass) <= Align,
86
7.87M
                  "Recycler allocation alignment is less than object align!");
87
7.87M
    static_assert(sizeof(SubClass) <= Size,
88
7.87M
                  "Recycler allocation size is less than object size!");
89
6.64M
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
1.23M
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
7.87M
  }
llvm::MachineInstr* llvm::Recycler<llvm::MachineInstr, 64ul, 8ul>::Allocate<llvm::MachineInstr, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
84
91.2M
  SubClass *Allocate(AllocatorType &Allocator) {
85
91.2M
    static_assert(alignof(SubClass) <= Align,
86
91.2M
                  "Recycler allocation alignment is less than object align!");
87
91.2M
    static_assert(sizeof(SubClass) <= Size,
88
91.2M
                  "Recycler allocation size is less than object size!");
89
36.6M
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
54.6M
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
91.2M
  }
llvm::MachineBasicBlock* llvm::Recycler<llvm::MachineBasicBlock, 176ul, 8ul>::Allocate<llvm::MachineBasicBlock, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&)
Line
Count
Source
84
5.99M
  SubClass *Allocate(AllocatorType &Allocator) {
85
5.99M
    static_assert(alignof(SubClass) <= Align,
86
5.99M
                  "Recycler allocation alignment is less than object align!");
87
5.99M
    static_assert(sizeof(SubClass) <= Size,
88
5.99M
                  "Recycler allocation size is less than object size!");
89
85.8k
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
5.90M
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
5.99M
  }
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
84
21.3M
  SubClass *Allocate(AllocatorType &Allocator) {
85
21.3M
    static_assert(alignof(SubClass) <= Align,
86
21.3M
                  "Recycler allocation alignment is less than object align!");
87
21.3M
    static_assert(sizeof(SubClass) <= Size,
88
21.3M
                  "Recycler allocation size is less than object size!");
89
7.33M
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
14.0M
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
21.3M
  }
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
84
7.22M
  SubClass *Allocate(AllocatorType &Allocator) {
85
7.22M
    static_assert(alignof(SubClass) <= Align,
86
7.22M
                  "Recycler allocation alignment is less than object align!");
87
7.22M
    static_assert(sizeof(SubClass) <= Size,
88
7.22M
                  "Recycler allocation size is less than object size!");
89
2.54M
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
4.67M
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
7.22M
  }
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
84
21.9M
  SubClass *Allocate(AllocatorType &Allocator) {
85
21.9M
    static_assert(alignof(SubClass) <= Align,
86
21.9M
                  "Recycler allocation alignment is less than object align!");
87
21.9M
    static_assert(sizeof(SubClass) <= Size,
88
21.9M
                  "Recycler allocation size is less than object size!");
89
21.5M
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
381k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
21.9M
  }
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
84
158k
  SubClass *Allocate(AllocatorType &Allocator) {
85
158k
    static_assert(alignof(SubClass) <= Align,
86
158k
                  "Recycler allocation alignment is less than object align!");
87
158k
    static_assert(sizeof(SubClass) <= Size,
88
158k
                  "Recycler allocation size is less than object size!");
89
142k
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
16.3k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
158k
  }
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
84
178
  SubClass *Allocate(AllocatorType &Allocator) {
85
178
    static_assert(alignof(SubClass) <= Align,
86
178
                  "Recycler allocation alignment is less than object align!");
87
178
    static_assert(sizeof(SubClass) <= Size,
88
178
                  "Recycler allocation size is less than object size!");
89
175
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
3
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
178
  }
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
84
1.00M
  SubClass *Allocate(AllocatorType &Allocator) {
85
1.00M
    static_assert(alignof(SubClass) <= Align,
86
1.00M
                  "Recycler allocation alignment is less than object align!");
87
1.00M
    static_assert(sizeof(SubClass) <= Size,
88
1.00M
                  "Recycler allocation size is less than object size!");
89
969k
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
33.3k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
1.00M
  }
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
84
14.8k
  SubClass *Allocate(AllocatorType &Allocator) {
85
14.8k
    static_assert(alignof(SubClass) <= Align,
86
14.8k
                  "Recycler allocation alignment is less than object align!");
87
14.8k
    static_assert(sizeof(SubClass) <= Size,
88
14.8k
                  "Recycler allocation size is less than object size!");
89
14.8k
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
1
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
14.8k
  }
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
84
285k
  SubClass *Allocate(AllocatorType &Allocator) {
85
285k
    static_assert(alignof(SubClass) <= Align,
86
285k
                  "Recycler allocation alignment is less than object align!");
87
285k
    static_assert(sizeof(SubClass) <= Size,
88
285k
                  "Recycler allocation size is less than object size!");
89
281k
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
3.36k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
285k
  }
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
84
3.91M
  SubClass *Allocate(AllocatorType &Allocator) {
85
3.91M
    static_assert(alignof(SubClass) <= Align,
86
3.91M
                  "Recycler allocation alignment is less than object align!");
87
3.91M
    static_assert(sizeof(SubClass) <= Size,
88
3.91M
                  "Recycler allocation size is less than object size!");
89
3.82M
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
92.0k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
3.91M
  }
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
84
876k
  SubClass *Allocate(AllocatorType &Allocator) {
85
876k
    static_assert(alignof(SubClass) <= Align,
86
876k
                  "Recycler allocation alignment is less than object align!");
87
876k
    static_assert(sizeof(SubClass) <= Size,
88
876k
                  "Recycler allocation size is less than object size!");
89
869k
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
7.40k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
876k
  }
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
84
67.6k
  SubClass *Allocate(AllocatorType &Allocator) {
85
67.6k
    static_assert(alignof(SubClass) <= Align,
86
67.6k
                  "Recycler allocation alignment is less than object align!");
87
67.6k
    static_assert(sizeof(SubClass) <= Size,
88
67.6k
                  "Recycler allocation size is less than object size!");
89
63.3k
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
4.35k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
67.6k
  }
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
84
290
  SubClass *Allocate(AllocatorType &Allocator) {
85
290
    static_assert(alignof(SubClass) <= Align,
86
290
                  "Recycler allocation alignment is less than object align!");
87
290
    static_assert(sizeof(SubClass) <= Size,
88
290
                  "Recycler allocation size is less than object size!");
89
275
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
15
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
290
  }
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
84
2.91M
  SubClass *Allocate(AllocatorType &Allocator) {
85
2.91M
    static_assert(alignof(SubClass) <= Align,
86
2.91M
                  "Recycler allocation alignment is less than object align!");
87
2.91M
    static_assert(sizeof(SubClass) <= Size,
88
2.91M
                  "Recycler allocation size is less than object size!");
89
2.85M
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
56.6k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
2.91M
  }
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
84
70.7k
  SubClass *Allocate(AllocatorType &Allocator) {
85
70.7k
    static_assert(alignof(SubClass) <= Align,
86
70.7k
                  "Recycler allocation alignment is less than object align!");
87
70.7k
    static_assert(sizeof(SubClass) <= Size,
88
70.7k
                  "Recycler allocation size is less than object size!");
89
66.6k
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
4.13k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
70.7k
  }
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
84
14.1M
  SubClass *Allocate(AllocatorType &Allocator) {
85
14.1M
    static_assert(alignof(SubClass) <= Align,
86
14.1M
                  "Recycler allocation alignment is less than object align!");
87
14.1M
    static_assert(sizeof(SubClass) <= Size,
88
14.1M
                  "Recycler allocation size is less than object size!");
89
13.8M
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
254k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
14.1M
  }
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
84
1.09M
  SubClass *Allocate(AllocatorType &Allocator) {
85
1.09M
    static_assert(alignof(SubClass) <= Align,
86
1.09M
                  "Recycler allocation alignment is less than object align!");
87
1.09M
    static_assert(sizeof(SubClass) <= Size,
88
1.09M
                  "Recycler allocation size is less than object size!");
89
1.08M
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
14.3k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
1.09M
  }
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
84
37.0k
  SubClass *Allocate(AllocatorType &Allocator) {
85
37.0k
    static_assert(alignof(SubClass) <= Align,
86
37.0k
                  "Recycler allocation alignment is less than object align!");
87
37.0k
    static_assert(sizeof(SubClass) <= Size,
88
37.0k
                  "Recycler allocation size is less than object size!");
89
36.1k
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
895
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
37.0k
  }
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
84
244
  SubClass *Allocate(AllocatorType &Allocator) {
85
244
    static_assert(alignof(SubClass) <= Align,
86
244
                  "Recycler allocation alignment is less than object align!");
87
244
    static_assert(sizeof(SubClass) <= Size,
88
244
                  "Recycler allocation size is less than object size!");
89
174
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
70
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
244
  }
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
84
849
  SubClass *Allocate(AllocatorType &Allocator) {
85
849
    static_assert(alignof(SubClass) <= Align,
86
849
                  "Recycler allocation alignment is less than object align!");
87
849
    static_assert(sizeof(SubClass) <= Size,
88
849
                  "Recycler allocation size is less than object size!");
89
712
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
137
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
849
  }
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
84
11.8k
  SubClass *Allocate(AllocatorType &Allocator) {
85
11.8k
    static_assert(alignof(SubClass) <= Align,
86
11.8k
                  "Recycler allocation alignment is less than object align!");
87
11.8k
    static_assert(sizeof(SubClass) <= Size,
88
11.8k
                  "Recycler allocation size is less than object size!");
89
7.33k
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
4.52k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
11.8k
  }
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
84
199
  SubClass *Allocate(AllocatorType &Allocator) {
85
199
    static_assert(alignof(SubClass) <= Align,
86
199
                  "Recycler allocation alignment is less than object align!");
87
199
    static_assert(sizeof(SubClass) <= Size,
88
199
                  "Recycler allocation size is less than object size!");
89
160
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
39
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
199
  }
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
84
54.9M
  SubClass *Allocate(AllocatorType &Allocator) {
85
54.9M
    static_assert(alignof(SubClass) <= Align,
86
54.9M
                  "Recycler allocation alignment is less than object align!");
87
54.9M
    static_assert(sizeof(SubClass) <= Size,
88
54.9M
                  "Recycler allocation size is less than object size!");
89
52.7M
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
2.20M
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
54.9M
  }
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
84
26.5k
  SubClass *Allocate(AllocatorType &Allocator) {
85
26.5k
    static_assert(alignof(SubClass) <= Align,
86
26.5k
                  "Recycler allocation alignment is less than object align!");
87
26.5k
    static_assert(sizeof(SubClass) <= Size,
88
26.5k
                  "Recycler allocation size is less than object size!");
89
25.8k
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
720
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
26.5k
  }
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
84
134k
  SubClass *Allocate(AllocatorType &Allocator) {
85
134k
    static_assert(alignof(SubClass) <= Align,
86
134k
                  "Recycler allocation alignment is less than object align!");
87
134k
    static_assert(sizeof(SubClass) <= Size,
88
134k
                  "Recycler allocation size is less than object size!");
89
109k
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
25.3k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
134k
  }
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
84
3.33M
  SubClass *Allocate(AllocatorType &Allocator) {
85
3.33M
    static_assert(alignof(SubClass) <= Align,
86
3.33M
                  "Recycler allocation alignment is less than object align!");
87
3.33M
    static_assert(sizeof(SubClass) <= Size,
88
3.33M
                  "Recycler allocation size is less than object size!");
89
3.20M
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
125k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
3.33M
  }
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
84
3.51M
  SubClass *Allocate(AllocatorType &Allocator) {
85
3.51M
    static_assert(alignof(SubClass) <= Align,
86
3.51M
                  "Recycler allocation alignment is less than object align!");
87
3.51M
    static_assert(sizeof(SubClass) <= Size,
88
3.51M
                  "Recycler allocation size is less than object size!");
89
3.32M
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
188k
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
3.51M
  }
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
84
316
  SubClass *Allocate(AllocatorType &Allocator) {
85
316
    static_assert(alignof(SubClass) <= Align,
86
316
                  "Recycler allocation alignment is less than object align!");
87
316
    static_assert(sizeof(SubClass) <= Size,
88
316
                  "Recycler allocation size is less than object size!");
89
277
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
39
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
316
  }
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
84
199
  SubClass *Allocate(AllocatorType &Allocator) {
85
199
    static_assert(alignof(SubClass) <= Align,
86
199
                  "Recycler allocation alignment is less than object align!");
87
199
    static_assert(sizeof(SubClass) <= Size,
88
199
                  "Recycler allocation size is less than object size!");
89
194
    return FreeList ? reinterpret_cast<SubClass *>(pop_val())
90
5
                    : static_cast<SubClass *>(Allocator.Allocate(Size, Align));
91
199
  }
92
93
  template<class AllocatorType>
94
  T *Allocate(AllocatorType &Allocator) {
95
    return Allocate<T>(Allocator);
96
  }
97
98
  template<class SubClass, class AllocatorType>
99
211M
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
100
211M
    push(reinterpret_cast<FreeNode *>(Element));
101
211M
  }
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
99
21.3M
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
100
21.3M
    push(reinterpret_cast<FreeNode *>(Element));
101
21.3M
  }
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
99
115M
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
100
115M
    push(reinterpret_cast<FreeNode *>(Element));
101
115M
  }
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
99
1.04k
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
100
1.04k
    push(reinterpret_cast<FreeNode *>(Element));
101
1.04k
  }
void llvm::Recycler<llvm::MachineBasicBlock, 176ul, 8ul>::Deallocate<llvm::MachineBasicBlock, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&, llvm::MachineBasicBlock*)
Line
Count
Source
99
5.99M
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
100
5.99M
    push(reinterpret_cast<FreeNode *>(Element));
101
5.99M
  }
void llvm::Recycler<llvm::MachineInstr, 64ul, 8ul>::Deallocate<llvm::MachineInstr, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>&, llvm::MachineInstr*)
Line
Count
Source
99
51.9M
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
100
51.9M
    push(reinterpret_cast<FreeNode *>(Element));
101
51.9M
  }
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
99
7.87M
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
100
7.87M
    push(reinterpret_cast<FreeNode *>(Element));
101
7.87M
  }
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
99
46.3k
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
100
46.3k
    push(reinterpret_cast<FreeNode *>(Element));
101
46.3k
  }
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
99
178
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
100
178
    push(reinterpret_cast<FreeNode *>(Element));
101
178
  }
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
99
19.5k
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
100
19.5k
    push(reinterpret_cast<FreeNode *>(Element));
101
19.5k
  }
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
99
7.22M
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
100
7.22M
    push(reinterpret_cast<FreeNode *>(Element));
101
7.22M
  }
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
99
1.24M
  void Deallocate(AllocatorType & /*Allocator*/, SubClass* Element) {
100
1.24M
    push(reinterpret_cast<FreeNode *>(Element));
101
1.24M
  }
102
103
  void PrintStats();
104
};
105
106
template <class T, size_t Size, size_t Align>
107
void Recycler<T, Size, Align>::PrintStats() {
108
  size_t S = 0;
109
  for (auto *I = FreeList; I; I = I->Next)
110
    ++S;
111
  PrintRecyclerStats(Size, Align, S);
112
}
113
114
}
115
116
#endif