Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Support/Allocator.h
Line
Count
Source (jump to first uncovered line)
1
//===- Allocator.h - Simple memory allocation abstraction -------*- 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
/// \file
9
///
10
/// This file defines the MallocAllocator and BumpPtrAllocator interfaces. Both
11
/// of these conform to an LLVM "Allocator" concept which consists of an
12
/// Allocate method accepting a size and alignment, and a Deallocate accepting
13
/// a pointer and size. Further, the LLVM "Allocator" concept has overloads of
14
/// Allocate and Deallocate for setting size and alignment based on the final
15
/// type. These overloads are typically provided by a base class template \c
16
/// AllocatorBase.
17
///
18
//===----------------------------------------------------------------------===//
19
20
#ifndef LLVM_SUPPORT_ALLOCATOR_H
21
#define LLVM_SUPPORT_ALLOCATOR_H
22
23
#include "llvm/ADT/Optional.h"
24
#include "llvm/ADT/SmallVector.h"
25
#include "llvm/Support/Compiler.h"
26
#include "llvm/Support/ErrorHandling.h"
27
#include "llvm/Support/MathExtras.h"
28
#include "llvm/Support/MemAlloc.h"
29
#include <algorithm>
30
#include <cassert>
31
#include <cstddef>
32
#include <cstdint>
33
#include <cstdlib>
34
#include <iterator>
35
#include <type_traits>
36
#include <utility>
37
38
namespace llvm {
39
40
/// CRTP base class providing obvious overloads for the core \c
41
/// Allocate() methods of LLVM-style allocators.
42
///
43
/// This base class both documents the full public interface exposed by all
44
/// LLVM-style allocators, and redirects all of the overloads to a single core
45
/// set of methods which the derived class must define.
46
template <typename DerivedT> class AllocatorBase {
47
public:
48
  /// Allocate \a Size bytes of \a Alignment aligned memory. This method
49
  /// must be implemented by \c DerivedT.
50
283M
  void *Allocate(size_t Size, size_t Alignment) {
51
283M
#ifdef __clang__
52
283M
    static_assert(static_cast<void *(AllocatorBase::*)(size_t, size_t)>(
53
283M
                      &AllocatorBase::Allocate) !=
54
283M
                      static_cast<void *(DerivedT::*)(size_t, size_t)>(
55
283M
                          &DerivedT::Allocate),
56
283M
                  "Class derives from AllocatorBase without implementing the "
57
283M
                  "core Allocate(size_t, size_t) overload!");
58
283M
#endif
59
283M
    return static_cast<DerivedT *>(this)->Allocate(Size, Alignment);
60
283M
  }
llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate(unsigned long, unsigned long)
Line
Count
Source
50
283M
  void *Allocate(size_t Size, size_t Alignment) {
51
283M
#ifdef __clang__
52
283M
    static_assert(static_cast<void *(AllocatorBase::*)(size_t, size_t)>(
53
283M
                      &AllocatorBase::Allocate) !=
54
283M
                      static_cast<void *(DerivedT::*)(size_t, size_t)>(
55
283M
                          &DerivedT::Allocate),
56
283M
                  "Class derives from AllocatorBase without implementing the "
57
283M
                  "core Allocate(size_t, size_t) overload!");
58
283M
#endif
59
283M
    return static_cast<DerivedT *>(this)->Allocate(Size, Alignment);
60
283M
  }
llvm::AllocatorBase<llvm::MallocAllocator>::Allocate(unsigned long, unsigned long)
Line
Count
Source
50
46.2k
  void *Allocate(size_t Size, size_t Alignment) {
51
46.2k
#ifdef __clang__
52
46.2k
    static_assert(static_cast<void *(AllocatorBase::*)(size_t, size_t)>(
53
46.2k
                      &AllocatorBase::Allocate) !=
54
46.2k
                      static_cast<void *(DerivedT::*)(size_t, size_t)>(
55
46.2k
                          &DerivedT::Allocate),
56
46.2k
                  "Class derives from AllocatorBase without implementing the "
57
46.2k
                  "core Allocate(size_t, size_t) overload!");
58
46.2k
#endif
59
46.2k
    return static_cast<DerivedT *>(this)->Allocate(Size, Alignment);
60
46.2k
  }
61
62
  /// Deallocate \a Ptr to \a Size bytes of memory allocated by this
63
  /// allocator.
64
3.81M
  void Deallocate(const void *Ptr, size_t Size) {
65
3.81M
#ifdef __clang__
66
3.81M
    static_assert(static_cast<void (AllocatorBase::*)(const void *, size_t)>(
67
3.81M
                      &AllocatorBase::Deallocate) !=
68
3.81M
                      static_cast<void (DerivedT::*)(const void *, size_t)>(
69
3.81M
                          &DerivedT::Deallocate),
70
3.81M
                  "Class derives from AllocatorBase without implementing the "
71
3.81M
                  "core Deallocate(void *) overload!");
72
3.81M
#endif
73
3.81M
    return static_cast<DerivedT *>(this)->Deallocate(Ptr, Size);
74
3.81M
  }
llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Deallocate(void const*, unsigned long)
Line
Count
Source
64
3.76M
  void Deallocate(const void *Ptr, size_t Size) {
65
3.76M
#ifdef __clang__
66
3.76M
    static_assert(static_cast<void (AllocatorBase::*)(const void *, size_t)>(
67
3.76M
                      &AllocatorBase::Deallocate) !=
68
3.76M
                      static_cast<void (DerivedT::*)(const void *, size_t)>(
69
3.76M
                          &DerivedT::Deallocate),
70
3.76M
                  "Class derives from AllocatorBase without implementing the "
71
3.76M
                  "core Deallocate(void *) overload!");
72
3.76M
#endif
73
3.76M
    return static_cast<DerivedT *>(this)->Deallocate(Ptr, Size);
74
3.76M
  }
llvm::AllocatorBase<llvm::MallocAllocator>::Deallocate(void const*, unsigned long)
Line
Count
Source
64
46.2k
  void Deallocate(const void *Ptr, size_t Size) {
65
46.2k
#ifdef __clang__
66
46.2k
    static_assert(static_cast<void (AllocatorBase::*)(const void *, size_t)>(
67
46.2k
                      &AllocatorBase::Deallocate) !=
68
46.2k
                      static_cast<void (DerivedT::*)(const void *, size_t)>(
69
46.2k
                          &DerivedT::Deallocate),
70
46.2k
                  "Class derives from AllocatorBase without implementing the "
71
46.2k
                  "core Deallocate(void *) overload!");
72
46.2k
#endif
73
46.2k
    return static_cast<DerivedT *>(this)->Deallocate(Ptr, Size);
74
46.2k
  }
75
76
  // The rest of these methods are helpers that redirect to one of the above
77
  // core methods.
78
79
  /// Allocate space for a sequence of objects without constructing them.
80
280M
  template <typename T> T *Allocate(size_t Num = 1) {
81
280M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
280M
  }
llvm::BasicBlock** llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::BasicBlock*>(unsigned long)
Line
Count
Source
80
2.03M
  template <typename T> T *Allocate(size_t Num = 1) {
81
2.03M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
2.03M
  }
llvm::GVN::LeaderTableEntry* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::GVN::LeaderTableEntry>(unsigned long)
Line
Count
Source
80
4.31M
  template <typename T> T *Allocate(size_t Num = 1) {
81
4.31M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
4.31M
  }
llvm::AArch64FunctionInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::AArch64FunctionInfo>(unsigned long)
Line
Count
Source
80
257k
  template <typename T> T *Allocate(size_t Num = 1) {
81
257k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
257k
  }
llvm::SmallVector<llvm::Register, 1u>* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::SmallVector<llvm::Register, 1u> >(unsigned long)
Line
Count
Source
80
11.4M
  template <typename T> T *Allocate(size_t Num = 1) {
81
11.4M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
11.4M
  }
llvm::SmallVector<unsigned long long, 1u>* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::SmallVector<unsigned long long, 1u> >(unsigned long)
Line
Count
Source
80
1.77M
  template <typename T> T *Allocate(size_t Num = 1) {
81
1.77M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
1.77M
  }
llvm::SIMachineFunctionInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::SIMachineFunctionInfo>(unsigned long)
Line
Count
Source
80
31.2k
  template <typename T> T *Allocate(size_t Num = 1) {
81
31.2k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
31.2k
  }
Unexecuted instantiation: llvm::AMDGPUMachineFunction* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::AMDGPUMachineFunction>(unsigned long)
llvm::GCNIterativeScheduler::Region* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::GCNIterativeScheduler::Region>(unsigned long)
Line
Count
Source
80
8
  template <typename T> T *Allocate(size_t Num = 1) {
81
8
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
8
  }
GCNMinRegStrategy.cpp:(anonymous namespace)::GCNMinRegScheduler::Candidate* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<(anonymous namespace)::GCNMinRegScheduler::Candidate>(unsigned long)
Line
Count
Source
80
1.97k
  template <typename T> T *Allocate(size_t Num = 1) {
81
1.97k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
1.97k
  }
llvm::R600MachineFunctionInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::R600MachineFunctionInfo>(unsigned long)
Line
Count
Source
80
2.29k
  template <typename T> T *Allocate(size_t Num = 1) {
81
2.29k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
2.29k
  }
GCNILPSched.cpp:(anonymous namespace)::GCNILPScheduler::Candidate* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<(anonymous namespace)::GCNILPScheduler::Candidate>(unsigned long)
Line
Count
Source
80
454
  template <typename T> T *Allocate(size_t Num = 1) {
81
454
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
454
  }
llvm::ARMFunctionInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ARMFunctionInfo>(unsigned long)
Line
Count
Source
80
27.8k
  template <typename T> T *Allocate(size_t Num = 1) {
81
27.8k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
27.8k
  }
ARMLoadStoreOptimizer.cpp:(anonymous namespace)::ARMLoadStoreOpt::MergeCandidate* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<(anonymous namespace)::ARMLoadStoreOpt::MergeCandidate>(unsigned long)
Line
Count
Source
80
88.0k
  template <typename T> T *Allocate(size_t Num = 1) {
81
88.0k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
88.0k
  }
HexagonCommonGEP.cpp:(anonymous namespace)::GepNode* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<(anonymous namespace)::GepNode>(unsigned long)
Line
Count
Source
80
3.03k
  template <typename T> T *Allocate(size_t Num = 1) {
81
3.03k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
3.03k
  }
llvm::HexagonMachineFunctionInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::HexagonMachineFunctionInfo>(unsigned long)
Line
Count
Source
80
4.98k
  template <typename T> T *Allocate(size_t Num = 1) {
81
4.98k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
4.98k
  }
llvm::LanaiMachineFunctionInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::LanaiMachineFunctionInfo>(unsigned long)
Line
Count
Source
80
92
  template <typename T> T *Allocate(size_t Num = 1) {
81
92
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
92
  }
llvm::MipsFunctionInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::MipsFunctionInfo>(unsigned long)
Line
Count
Source
80
13.3k
  template <typename T> T *Allocate(size_t Num = 1) {
81
13.3k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
13.3k
  }
llvm::MSP430MachineFunctionInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::MSP430MachineFunctionInfo>(unsigned long)
Line
Count
Source
80
318
  template <typename T> T *Allocate(size_t Num = 1) {
81
318
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
318
  }
llvm::NVPTXMachineFunctionInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::NVPTXMachineFunctionInfo>(unsigned long)
Line
Count
Source
80
17
  template <typename T> T *Allocate(size_t Num = 1) {
81
17
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
17
  }
llvm::PPCFunctionInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::PPCFunctionInfo>(unsigned long)
Line
Count
Source
80
11.4k
  template <typename T> T *Allocate(size_t Num = 1) {
81
11.4k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
11.4k
  }
llvm::RISCVMachineFunctionInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::RISCVMachineFunctionInfo>(unsigned long)
Line
Count
Source
80
3.35k
  template <typename T> T *Allocate(size_t Num = 1) {
81
3.35k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
3.35k
  }
llvm::SparcMachineFunctionInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::SparcMachineFunctionInfo>(unsigned long)
Line
Count
Source
80
694
  template <typename T> T *Allocate(size_t Num = 1) {
81
694
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
694
  }
llvm::SystemZMachineFunctionInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::SystemZMachineFunctionInfo>(unsigned long)
Line
Count
Source
80
8.14k
  template <typename T> T *Allocate(size_t Num = 1) {
81
8.14k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
8.14k
  }
llvm::WebAssemblyFunctionInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::WebAssemblyFunctionInfo>(unsigned long)
Line
Count
Source
80
4.47k
  template <typename T> T *Allocate(size_t Num = 1) {
81
4.47k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
4.47k
  }
llvm::X86MachineFunctionInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::X86MachineFunctionInfo>(unsigned long)
Line
Count
Source
80
139k
  template <typename T> T *Allocate(size_t Num = 1) {
81
139k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
139k
  }
llvm::XCoreFunctionInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::XCoreFunctionInfo>(unsigned long)
Line
Count
Source
80
280
  template <typename T> T *Allocate(size_t Num = 1) {
81
280
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
280
  }
llvm::LazyCallGraph::SCC* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::LazyCallGraph::SCC>(unsigned long)
Line
Count
Source
80
2.28k
  template <typename T> T *Allocate(size_t Num = 1) {
81
2.28k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
2.28k
  }
llvm::LazyCallGraph::RefSCC* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::LazyCallGraph::RefSCC>(unsigned long)
Line
Count
Source
80
2.21k
  template <typename T> T *Allocate(size_t Num = 1) {
81
2.21k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
2.21k
  }
llvm::LazyCallGraph::Node* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::LazyCallGraph::Node>(unsigned long)
Line
Count
Source
80
2.38k
  template <typename T> T *Allocate(size_t Num = 1) {
81
2.38k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
2.38k
  }
llvm::Loop* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::Loop>(unsigned long)
Line
Count
Source
80
3.28M
  template <typename T> T *Allocate(size_t Num = 1) {
81
3.28M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
3.28M
  }
llvm::SCEV const** llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::SCEV const*>(unsigned long)
Line
Count
Source
80
12.2M
  template <typename T> T *Allocate(size_t Num = 1) {
81
12.2M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
12.2M
  }
llvm::DomainValue* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::DomainValue>(unsigned long)
Line
Count
Source
80
230k
  template <typename T> T *Allocate(size_t Num = 1) {
81
230k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
230k
  }
MachineBlockPlacement.cpp:(anonymous namespace)::BlockChain* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<(anonymous namespace)::BlockChain>(unsigned long)
Line
Count
Source
80
2.71M
  template <typename T> T *Allocate(size_t Num = 1) {
81
2.71M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
2.71M
  }
char* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<char>(unsigned long)
Line
Count
Source
80
3.03M
  template <typename T> T *Allocate(size_t Num = 1) {
81
3.03M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
3.03M
  }
unsigned int* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<unsigned int>(unsigned long)
Line
Count
Source
80
23.9M
  template <typename T> T *Allocate(size_t Num = 1) {
81
23.9M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
23.9M
  }
llvm::MachineLoop* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::MachineLoop>(unsigned long)
Line
Count
Source
80
863k
  template <typename T> T *Allocate(size_t Num = 1) {
81
863k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
863k
  }
MachineOutliner.cpp:(anonymous namespace)::SuffixTreeNode* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<(anonymous namespace)::SuffixTreeNode>(unsigned long)
Line
Count
Source
80
10.5k
  template <typename T> T *Allocate(size_t Num = 1) {
81
10.5k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
10.5k
  }
llvm::PMTopLevelManager::AUFoldingSetNode* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::PMTopLevelManager::AUFoldingSetNode>(unsigned long)
Line
Count
Source
80
3.99M
  template <typename T> T *Allocate(size_t Num = 1) {
81
3.99M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
3.99M
  }
BasicBlockState* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<BasicBlockState>(unsigned long)
Line
Count
Source
80
75
  template <typename T> T *Allocate(size_t Num = 1) {
81
75
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
75
  }
llvm::Type** llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::Type*>(unsigned long)
Line
Count
Source
80
252k
  template <typename T> T *Allocate(size_t Num = 1) {
81
252k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
252k
  }
llvm::MCSectionMachO* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::MCSectionMachO>(unsigned long)
Line
Count
Source
80
890k
  template <typename T> T *Allocate(size_t Num = 1) {
81
890k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
890k
  }
llvm::MCSectionELF* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::MCSectionELF>(unsigned long)
Line
Count
Source
80
2.16M
  template <typename T> T *Allocate(size_t Num = 1) {
81
2.16M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
2.16M
  }
llvm::MCSectionCOFF* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::MCSectionCOFF>(unsigned long)
Line
Count
Source
80
62.2k
  template <typename T> T *Allocate(size_t Num = 1) {
81
62.2k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
62.2k
  }
llvm::MCSectionWasm* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::MCSectionWasm>(unsigned long)
Line
Count
Source
80
13.3k
  template <typename T> T *Allocate(size_t Num = 1) {
81
13.3k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
13.3k
  }
llvm::MCSectionXCOFF* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::MCSectionXCOFF>(unsigned long)
Line
Count
Source
80
17
  template <typename T> T *Allocate(size_t Num = 1) {
81
17
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
17
  }
llvm::MCSubtargetInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::MCSubtargetInfo>(unsigned long)
Line
Count
Source
80
2.70k
  template <typename T> T *Allocate(size_t Num = 1) {
81
2.70k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
2.70k
  }
EarlyCSE.cpp:llvm::ScopedHashTableVal<(anonymous namespace)::CallValue, std::__1::pair<llvm::Instruction*, unsigned int> >* llvm::AllocatorBase<llvm::MallocAllocator>::Allocate<llvm::ScopedHashTableVal<(anonymous namespace)::CallValue, std::__1::pair<llvm::Instruction*, unsigned int> > >(unsigned long)
Line
Count
Source
80
46.2k
  template <typename T> T *Allocate(size_t Num = 1) {
81
46.2k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
46.2k
  }
llvm::VPLoop* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::VPLoop>(unsigned long)
Line
Count
Source
80
34
  template <typename T> T *Allocate(size_t Num = 1) {
81
34
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
34
  }
clang::IdentifierInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::IdentifierInfo>(unsigned long)
Line
Count
Source
80
160M
  template <typename T> T *Allocate(size_t Num = 1) {
81
160M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
160M
  }
clang::SrcMgr::ContentCache* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::SrcMgr::ContentCache>(unsigned long)
Line
Count
Source
80
624k
  template <typename T> T *Allocate(size_t Num = 1) {
81
624k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
624k
  }
clang::IdentifierInfo** llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::IdentifierInfo*>(unsigned long)
Line
Count
Source
80
3.56M
  template <typename T> T *Allocate(size_t Num = 1) {
81
3.56M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
3.56M
  }
ASTWriter.cpp:llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::HeaderFileInfoTrait>::Item* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::HeaderFileInfoTrait>::Item>(unsigned long)
Line
Count
Source
80
5.69k
  template <typename T> T *Allocate(size_t Num = 1) {
81
5.69k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
5.69k
  }
ASTWriter.cpp:llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTMethodPoolTrait>::Item* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTMethodPoolTrait>::Item>(unsigned long)
Line
Count
Source
80
550
  template <typename T> T *Allocate(size_t Num = 1) {
81
550
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
550
  }
ASTWriter.cpp:llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTIdentifierTableTrait>::Item* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTIdentifierTableTrait>::Item>(unsigned long)
Line
Count
Source
80
5.65M
  template <typename T> T *Allocate(size_t Num = 1) {
81
5.65M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
5.65M
  }
ASTWriter.cpp:llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTDeclContextNameLookupTrait>::Item* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTDeclContextNameLookupTrait>::Item>(unsigned long)
Line
Count
Source
80
50.4k
  template <typename T> T *Allocate(size_t Num = 1) {
81
50.4k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
50.4k
  }
GlobalModuleIndex.cpp:llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::IdentifierIndexWriterTrait>::Item* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::IdentifierIndexWriterTrait>::Item>(unsigned long)
Line
Count
Source
80
89.8k
  template <typename T> T *Allocate(size_t Num = 1) {
81
89.8k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
89.8k
  }
int* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<int>(unsigned long)
Line
Count
Source
80
155k
  template <typename T> T *Allocate(size_t Num = 1) {
81
155k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
155k
  }
llvm::EVT* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::EVT>(unsigned long)
Line
Count
Source
80
257k
  template <typename T> T *Allocate(size_t Num = 1) {
81
257k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
257k
  }
llvm::MachineMemOperand** llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::MachineMemOperand*>(unsigned long)
Line
Count
Source
80
5.40k
  template <typename T> T *Allocate(size_t Num = 1) {
81
5.40k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
5.40k
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<unsigned int, clang::ento::ArgEffect> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<unsigned int, clang::ento::ArgEffect> > >(unsigned long)
Line
Count
Source
80
588
  template <typename T> T *Allocate(size_t Num = 1) {
81
588
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
588
  }
clang::CFGElement* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::CFGElement>(unsigned long)
Line
Count
Source
80
3.23M
  template <typename T> T *Allocate(size_t Num = 1) {
81
3.23M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
3.23M
  }
clang::CFGBlock::AdjacentBlock* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::CFGBlock::AdjacentBlock>(unsigned long)
Line
Count
Source
80
5.00M
  template <typename T> T *Allocate(size_t Num = 1) {
81
5.00M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
5.00M
  }
clang::CFGBlock** llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::CFGBlock*>(unsigned long)
Line
Count
Source
80
461k
  template <typename T> T *Allocate(size_t Num = 1) {
81
461k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
461k
  }
llvm::ImmutableListImpl<clang::ento::SVal>* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImmutableListImpl<clang::ento::SVal> >(unsigned long)
Line
Count
Source
80
1.83k
  template <typename T> T *Allocate(size_t Num = 1) {
81
1.83k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
1.83k
  }
llvm::ImmutableListImpl<clang::CXXBaseSpecifier const*>* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImmutableListImpl<clang::CXXBaseSpecifier const*> >(unsigned long)
Line
Count
Source
80
22
  template <typename T> T *Allocate(size_t Num = 1) {
81
22
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
22
  }
llvm::ImutAVLTree<clang::ento::RangeTrait>* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<clang::ento::RangeTrait> >(unsigned long)
Line
Count
Source
80
30.2k
  template <typename T> T *Allocate(size_t Num = 1) {
81
30.2k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
30.2k
  }
clang::ento::SimpleFunctionCall* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::SimpleFunctionCall>(unsigned long)
Line
Count
Source
80
17.1k
  template <typename T> T *Allocate(size_t Num = 1) {
81
17.1k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
17.1k
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, bool> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, bool> > >(unsigned long)
Line
Count
Source
80
233
  template <typename T> T *Allocate(size_t Num = 1) {
81
233
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
233
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, clang::ento::SymExpr const*> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, clang::ento::SymExpr const*> > >(unsigned long)
Line
Count
Source
80
46
  template <typename T> T *Allocate(size_t Num = 1) {
81
46
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
46
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, clang::ento::SVal> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, clang::ento::SVal> > >(unsigned long)
Line
Count
Source
80
1.15k
  template <typename T> T *Allocate(size_t Num = 1) {
81
1.15k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
1.15k
  }
llvm::ImutAVLTree<llvm::ImutContainerInfo<clang::ento::SymExpr const*> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutContainerInfo<clang::ento::SymExpr const*> > >(unsigned long)
Line
Count
Source
80
248
  template <typename T> T *Allocate(size_t Num = 1) {
81
248
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
248
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, llvm::ImmutableSet<clang::ento::SymExpr const*, llvm::ImutContainerInfo<clang::ento::SymExpr const*> > > >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, llvm::ImmutableSet<clang::ento::SymExpr const*, llvm::ImutContainerInfo<clang::ento::SymExpr const*> > > > >(unsigned long)
Line
Count
Source
80
117
  template <typename T> T *Allocate(size_t Num = 1) {
81
117
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
117
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, clang::ento::DynamicTypeInfo> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, clang::ento::DynamicTypeInfo> > >(unsigned long)
Line
Count
Source
80
4.96k
  template <typename T> T *Allocate(size_t Num = 1) {
81
4.96k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
4.96k
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, clang::ObjCObjectPointerType const*> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, clang::ObjCObjectPointerType const*> > >(unsigned long)
Line
Count
Source
80
128
  template <typename T> T *Allocate(size_t Num = 1) {
81
128
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
128
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, clang::StringLiteral const*> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, clang::StringLiteral const*> > >(unsigned long)
Line
Count
Source
80
230
  template <typename T> T *Allocate(size_t Num = 1) {
81
230
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
230
  }
llvm::ImutAVLTree<llvm::ImutContainerInfo<unsigned int> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutContainerInfo<unsigned int> > >(unsigned long)
Line
Count
Source
80
159
  template <typename T> T *Allocate(size_t Num = 1) {
81
159
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
159
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, llvm::ImmutableSet<clang::ento::SymExpr const*, llvm::ImutContainerInfo<clang::ento::SymExpr const*> > > >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, llvm::ImmutableSet<clang::ento::SymExpr const*, llvm::ImutContainerInfo<clang::ento::SymExpr const*> > > > >(unsigned long)
Line
Count
Source
80
73
  template <typename T> T *Allocate(size_t Num = 1) {
81
73
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
73
  }
IteratorChecker.cpp:llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, (anonymous namespace)::IteratorPosition> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, (anonymous namespace)::IteratorPosition> > >(unsigned long)
Line
Count
Source
80
3.44k
  template <typename T> T *Allocate(size_t Num = 1) {
81
3.44k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
3.44k
  }
IteratorChecker.cpp:llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, (anonymous namespace)::IteratorPosition> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, (anonymous namespace)::IteratorPosition> > >(unsigned long)
Line
Count
Source
80
58
  template <typename T> T *Allocate(size_t Num = 1) {
81
58
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
58
  }
IteratorChecker.cpp:llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, (anonymous namespace)::ContainerData> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, (anonymous namespace)::ContainerData> > >(unsigned long)
Line
Count
Source
80
558
  template <typename T> T *Allocate(size_t Num = 1) {
81
558
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
558
  }
LocalizationChecker.cpp:llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, (anonymous namespace)::LocalizedState> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, (anonymous namespace)::LocalizedState> > >(unsigned long)
Line
Count
Source
80
542
  template <typename T> T *Allocate(size_t Num = 1) {
81
542
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
542
  }
MacOSKeychainAPIChecker.cpp:llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, (anonymous namespace)::MacOSKeychainAPIChecker::AllocationState> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, (anonymous namespace)::MacOSKeychainAPIChecker::AllocationState> > >(unsigned long)
Line
Count
Source
80
30
  template <typename T> T *Allocate(size_t Num = 1) {
81
30
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
30
  }
MallocChecker.cpp:llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, (anonymous namespace)::RefState> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, (anonymous namespace)::RefState> > >(unsigned long)
Line
Count
Source
80
3.37k
  template <typename T> T *Allocate(size_t Num = 1) {
81
3.37k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
3.37k
  }
MallocChecker.cpp:llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, (anonymous namespace)::ReallocPair> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, (anonymous namespace)::ReallocPair> > >(unsigned long)
Line
Count
Source
80
102
  template <typename T> T *Allocate(size_t Num = 1) {
81
102
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
102
  }
llvm::ImutAVLTree<llvm::ImutContainerInfo<clang::ParmVarDecl const*> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutContainerInfo<clang::ParmVarDecl const*> > >(unsigned long)
Line
Count
Source
80
1
  template <typename T> T *Allocate(size_t Num = 1) {
81
1
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
1
  }
MoveChecker.cpp:llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, (anonymous namespace)::RegionState> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, (anonymous namespace)::RegionState> > >(unsigned long)
Line
Count
Source
80
1.90k
  template <typename T> T *Allocate(size_t Num = 1) {
81
1.90k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
1.90k
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, clang::ento::mpi::Request> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, clang::ento::mpi::Request> > >(unsigned long)
Line
Count
Source
80
149
  template <typename T> T *Allocate(size_t Num = 1) {
81
149
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
149
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, unsigned int> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, unsigned int> > >(unsigned long)
Line
Count
Source
80
761
  template <typename T> T *Allocate(size_t Num = 1) {
81
761
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
761
  }
NullabilityChecker.cpp:llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, (anonymous namespace)::NullabilityState> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, (anonymous namespace)::NullabilityState> > >(unsigned long)
Line
Count
Source
80
110
  template <typename T> T *Allocate(size_t Num = 1) {
81
110
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
110
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, clang::ento::DefinedSVal> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, clang::ento::DefinedSVal> > >(unsigned long)
Line
Count
Source
80
55
  template <typename T> T *Allocate(size_t Num = 1) {
81
55
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
55
  }
PointerArithChecker.cpp:llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, (anonymous namespace)::AllocKind> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, (anonymous namespace)::AllocKind> > >(unsigned long)
Line
Count
Source
80
1.90k
  template <typename T> T *Allocate(size_t Num = 1) {
81
1.90k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
1.90k
  }
PthreadLockChecker.cpp:llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, (anonymous namespace)::LockState> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, (anonymous namespace)::LockState> > >(unsigned long)
Line
Count
Source
80
181
  template <typename T> T *Allocate(size_t Num = 1) {
81
181
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
181
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, clang::ento::SymExpr const*> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, clang::ento::SymExpr const*> > >(unsigned long)
Line
Count
Source
80
28
  template <typename T> T *Allocate(size_t Num = 1) {
81
28
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
28
  }
llvm::ImmutableListImpl<clang::ento::MemRegion const*>* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImmutableListImpl<clang::ento::MemRegion const*> >(unsigned long)
Line
Count
Source
80
46
  template <typename T> T *Allocate(size_t Num = 1) {
81
46
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
46
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, clang::ento::retaincountchecker::RefVal> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, clang::ento::retaincountchecker::RefVal> > >(unsigned long)
Line
Count
Source
80
5.30k
  template <typename T> T *Allocate(size_t Num = 1) {
81
5.30k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
5.30k
  }
SimpleStreamChecker.cpp:llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, (anonymous namespace)::StreamState> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, (anonymous namespace)::StreamState> > >(unsigned long)
Line
Count
Source
80
23
  template <typename T> T *Allocate(size_t Num = 1) {
81
23
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
23
  }
StreamChecker.cpp:llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, (anonymous namespace)::StreamState> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, (anonymous namespace)::StreamState> > >(unsigned long)
Line
Count
Source
80
26
  template <typename T> T *Allocate(size_t Num = 1) {
81
26
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
26
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SubRegion const*, unsigned int> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SubRegion const*, unsigned int> > >(unsigned long)
Line
Count
Source
80
6
  template <typename T> T *Allocate(size_t Num = 1) {
81
6
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
6
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, llvm::ImmutableMap<clang::ento::SubRegion const*, unsigned int, llvm::ImutKeyValueInfo<clang::ento::SubRegion const*, unsigned int> > > >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, llvm::ImmutableMap<clang::ento::SubRegion const*, unsigned int, llvm::ImutKeyValueInfo<clang::ento::SubRegion const*, unsigned int> > > > >(unsigned long)
Line
Count
Source
80
8
  template <typename T> T *Allocate(size_t Num = 1) {
81
8
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
8
  }
TestAfterDivZeroChecker.cpp:llvm::ImutAVLTree<llvm::ImutContainerInfo<(anonymous namespace)::ZeroState> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutContainerInfo<(anonymous namespace)::ZeroState> > >(unsigned long)
Line
Count
Source
80
74
  template <typename T> T *Allocate(size_t Num = 1) {
81
74
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
74
  }
llvm::ImutAVLTree<llvm::ImutContainerInfo<clang::ento::MemRegion const*> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutContainerInfo<clang::ento::MemRegion const*> > >(unsigned long)
Line
Count
Source
80
419
  template <typename T> T *Allocate(size_t Num = 1) {
81
419
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
419
  }
llvm::ImmutableListImpl<clang::ento::FieldNode const&>* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImmutableListImpl<clang::ento::FieldNode const&> >(unsigned long)
Line
Count
Source
80
260
  template <typename T> T *Allocate(size_t Num = 1) {
81
260
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
260
  }
VirtualCallChecker.cpp:llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, (anonymous namespace)::ObjectState> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, (anonymous namespace)::ObjectState> > >(unsigned long)
Line
Count
Source
80
124
  template <typename T> T *Allocate(size_t Num = 1) {
81
124
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
124
  }
llvm::FoldingSetNodeWrapper<llvm::APSInt>* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::FoldingSetNodeWrapper<llvm::APSInt> >(unsigned long)
Line
Count
Source
80
77.9k
  template <typename T> T *Allocate(size_t Num = 1) {
81
77.9k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
77.9k
  }
clang::ento::CompoundValData* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::CompoundValData>(unsigned long)
Line
Count
Source
80
866
  template <typename T> T *Allocate(size_t Num = 1) {
81
866
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
866
  }
clang::ento::LazyCompoundValData* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::LazyCompoundValData>(unsigned long)
Line
Count
Source
80
10.9k
  template <typename T> T *Allocate(size_t Num = 1) {
81
10.9k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
10.9k
  }
clang::ento::PointerToMemberData* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::PointerToMemberData>(unsigned long)
Line
Count
Source
80
20
  template <typename T> T *Allocate(size_t Num = 1) {
81
20
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
20
  }
llvm::FoldingSetNodeWrapper<std::__1::pair<clang::ento::SVal, unsigned long> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::FoldingSetNodeWrapper<std::__1::pair<clang::ento::SVal, unsigned long> > >(unsigned long)
Line
Count
Source
80
119
  template <typename T> T *Allocate(size_t Num = 1) {
81
119
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
119
  }
Unexecuted instantiation: llvm::FoldingSetNodeWrapper<std::__1::pair<clang::ento::SVal, clang::ento::SVal> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::FoldingSetNodeWrapper<std::__1::pair<clang::ento::SVal, clang::ento::SVal> > >(unsigned long)
BlockCounter.cpp:llvm::ImutAVLTree<llvm::ImutKeyValueInfo<(anonymous namespace)::CountKey, unsigned int> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<(anonymous namespace)::CountKey, unsigned int> > >(unsigned long)
Line
Count
Source
80
288k
  template <typename T> T *Allocate(size_t Num = 1) {
81
288k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
288k
  }
llvm::ImutAVLTree<llvm::ImutContainerInfo<clang::ento::BugType*> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutContainerInfo<clang::ento::BugType*> > >(unsigned long)
Line
Count
Source
80
8.71k
  template <typename T> T *Allocate(size_t Num = 1) {
81
8.71k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
8.71k
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, clang::ento::RangeSet> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::SymExpr const*, clang::ento::RangeSet> > >(unsigned long)
Line
Count
Source
80
359k
  template <typename T> T *Allocate(size_t Num = 1) {
81
359k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
359k
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::EnvironmentEntry, clang::ento::SVal> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::EnvironmentEntry, clang::ento::SVal> > >(unsigned long)
Line
Count
Source
80
1.38M
  template <typename T> T *Allocate(size_t Num = 1) {
81
1.38M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
1.38M
  }
clang::BumpVector<clang::ento::ExplodedNode*>* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::BumpVector<clang::ento::ExplodedNode*> >(unsigned long)
Line
Count
Source
80
37.8k
  template <typename T> T *Allocate(size_t Num = 1) {
81
37.8k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
37.8k
  }
clang::ento::ExplodedNode** llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::ExplodedNode*>(unsigned long)
Line
Count
Source
80
38.0k
  template <typename T> T *Allocate(size_t Num = 1) {
81
38.0k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
38.0k
  }
clang::ento::ExplodedNode* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::ExplodedNode>(unsigned long)
Line
Count
Source
80
4.00M
  template <typename T> T *Allocate(size_t Num = 1) {
81
4.00M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
4.00M
  }
ExprEngine.cpp:llvm::ImutAVLTree<llvm::ImutKeyValueInfo<(anonymous namespace)::ConstructedObjectKey, clang::ento::SVal> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<(anonymous namespace)::ConstructedObjectKey, clang::ento::SVal> > >(unsigned long)
Line
Count
Source
80
26.4k
  template <typename T> T *Allocate(size_t Num = 1) {
81
26.4k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
26.4k
  }
llvm::ImutAVLTree<llvm::ImutContainerInfo<clang::VarDecl const*> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutContainerInfo<clang::VarDecl const*> > >(unsigned long)
Line
Count
Source
80
69.0k
  template <typename T> T *Allocate(size_t Num = 1) {
81
69.0k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
69.0k
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, unsigned int> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, unsigned int> > >(unsigned long)
Line
Count
Source
80
22
  template <typename T> T *Allocate(size_t Num = 1) {
81
22
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
22
  }
llvm::ImmutableListImpl<LoopState>* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImmutableListImpl<LoopState> >(unsigned long)
Line
Count
Source
80
130
  template <typename T> T *Allocate(size_t Num = 1) {
81
130
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
130
  }
clang::ento::StackLocalsSpaceRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::StackLocalsSpaceRegion>(unsigned long)
Line
Count
Source
80
9.52k
  template <typename T> T *Allocate(size_t Num = 1) {
81
9.52k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
9.52k
  }
clang::ento::StackArgumentsSpaceRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::StackArgumentsSpaceRegion>(unsigned long)
Line
Count
Source
80
21.0k
  template <typename T> T *Allocate(size_t Num = 1) {
81
21.0k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
21.0k
  }
clang::ento::GlobalSystemSpaceRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::GlobalSystemSpaceRegion>(unsigned long)
Line
Count
Source
80
5.46k
  template <typename T> T *Allocate(size_t Num = 1) {
81
5.46k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
5.46k
  }
clang::ento::GlobalImmutableSpaceRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::GlobalImmutableSpaceRegion>(unsigned long)
Line
Count
Source
80
216
  template <typename T> T *Allocate(size_t Num = 1) {
81
216
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
216
  }
clang::ento::GlobalInternalSpaceRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::GlobalInternalSpaceRegion>(unsigned long)
Line
Count
Source
80
5.59k
  template <typename T> T *Allocate(size_t Num = 1) {
81
5.59k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
5.59k
  }
clang::ento::StaticGlobalSpaceRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::StaticGlobalSpaceRegion>(unsigned long)
Line
Count
Source
80
165
  template <typename T> T *Allocate(size_t Num = 1) {
81
165
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
165
  }
clang::ento::HeapSpaceRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::HeapSpaceRegion>(unsigned long)
Line
Count
Source
80
1.12k
  template <typename T> T *Allocate(size_t Num = 1) {
81
1.12k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
1.12k
  }
clang::ento::UnknownSpaceRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::UnknownSpaceRegion>(unsigned long)
Line
Count
Source
80
6.05k
  template <typename T> T *Allocate(size_t Num = 1) {
81
6.05k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
6.05k
  }
clang::ento::CodeSpaceRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::CodeSpaceRegion>(unsigned long)
Line
Count
Source
80
7.38k
  template <typename T> T *Allocate(size_t Num = 1) {
81
7.38k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
7.38k
  }
clang::ento::StringRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::StringRegion>(unsigned long)
Line
Count
Source
80
2.22k
  template <typename T> T *Allocate(size_t Num = 1) {
81
2.22k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
2.22k
  }
clang::ento::ObjCStringRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::ObjCStringRegion>(unsigned long)
Line
Count
Source
80
281
  template <typename T> T *Allocate(size_t Num = 1) {
81
281
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
281
  }
clang::ento::VarRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::VarRegion>(unsigned long)
Line
Count
Source
80
36.2k
  template <typename T> T *Allocate(size_t Num = 1) {
81
36.2k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
36.2k
  }
clang::ento::BlockDataRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::BlockDataRegion>(unsigned long)
Line
Count
Source
80
359
  template <typename T> T *Allocate(size_t Num = 1) {
81
359
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
359
  }
clang::ento::CXXTempObjectRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::CXXTempObjectRegion>(unsigned long)
Line
Count
Source
80
2.34k
  template <typename T> T *Allocate(size_t Num = 1) {
81
2.34k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
2.34k
  }
clang::ento::CompoundLiteralRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::CompoundLiteralRegion>(unsigned long)
Line
Count
Source
80
48
  template <typename T> T *Allocate(size_t Num = 1) {
81
48
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
48
  }
clang::ento::ElementRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::ElementRegion>(unsigned long)
Line
Count
Source
80
10.3k
  template <typename T> T *Allocate(size_t Num = 1) {
81
10.3k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
10.3k
  }
clang::ento::FunctionCodeRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::FunctionCodeRegion>(unsigned long)
Line
Count
Source
80
15.9k
  template <typename T> T *Allocate(size_t Num = 1) {
81
15.9k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
15.9k
  }
clang::ento::BlockCodeRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::BlockCodeRegion>(unsigned long)
Line
Count
Source
80
352
  template <typename T> T *Allocate(size_t Num = 1) {
81
352
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
352
  }
clang::ento::SymbolicRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::SymbolicRegion>(unsigned long)
Line
Count
Source
80
12.7k
  template <typename T> T *Allocate(size_t Num = 1) {
81
12.7k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
12.7k
  }
clang::ento::FieldRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::FieldRegion>(unsigned long)
Line
Count
Source
80
11.8k
  template <typename T> T *Allocate(size_t Num = 1) {
81
11.8k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
11.8k
  }
clang::ento::ObjCIvarRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::ObjCIvarRegion>(unsigned long)
Line
Count
Source
80
626
  template <typename T> T *Allocate(size_t Num = 1) {
81
626
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
626
  }
clang::ento::CXXBaseObjectRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::CXXBaseObjectRegion>(unsigned long)
Line
Count
Source
80
968
  template <typename T> T *Allocate(size_t Num = 1) {
81
968
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
968
  }
clang::ento::CXXDerivedObjectRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::CXXDerivedObjectRegion>(unsigned long)
Line
Count
Source
80
32
  template <typename T> T *Allocate(size_t Num = 1) {
81
32
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
32
  }
clang::ento::CXXThisRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::CXXThisRegion>(unsigned long)
Line
Count
Source
80
9.64k
  template <typename T> T *Allocate(size_t Num = 1) {
81
9.64k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
9.64k
  }
clang::ento::AllocaRegion* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::AllocaRegion>(unsigned long)
Line
Count
Source
80
91
  template <typename T> T *Allocate(size_t Num = 1) {
81
91
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
91
  }
clang::BumpVector<clang::ento::MemRegion const*>* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::BumpVector<clang::ento::MemRegion const*> >(unsigned long)
Line
Count
Source
80
462
  template <typename T> T *Allocate(size_t Num = 1) {
81
462
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
462
  }
clang::ento::MemRegion const** llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::MemRegion const*>(unsigned long)
Line
Count
Source
80
462
  template <typename T> T *Allocate(size_t Num = 1) {
81
462
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
462
  }
clang::ento::PathDiagnosticConsumer::PDFileEntry* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::PathDiagnosticConsumer::PDFileEntry>(unsigned long)
Line
Count
Source
80
78
  template <typename T> T *Allocate(size_t Num = 1) {
81
78
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
78
  }
clang::ento::ProgramState* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::ProgramState>(unsigned long)
Line
Count
Source
80
992k
  template <typename T> T *Allocate(size_t Num = 1) {
81
992k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
992k
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<void*, void*> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<void*, void*> > >(unsigned long)
Line
Count
Source
80
219k
  template <typename T> T *Allocate(size_t Num = 1) {
81
219k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
219k
  }
RegionStore.cpp:llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, llvm::ImmutableMap<(anonymous namespace)::BindingKey, clang::ento::SVal, llvm::ImutKeyValueInfo<(anonymous namespace)::BindingKey, clang::ento::SVal> > > >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::ento::MemRegion const*, llvm::ImmutableMap<(anonymous namespace)::BindingKey, clang::ento::SVal, llvm::ImutKeyValueInfo<(anonymous namespace)::BindingKey, clang::ento::SVal> > > > >(unsigned long)
Line
Count
Source
80
258k
  template <typename T> T *Allocate(size_t Num = 1) {
81
258k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
258k
  }
RegionStore.cpp:llvm::ImutAVLTree<llvm::ImutKeyValueInfo<(anonymous namespace)::BindingKey, clang::ento::SVal> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<(anonymous namespace)::BindingKey, clang::ento::SVal> > >(unsigned long)
Line
Count
Source
80
103k
  template <typename T> T *Allocate(size_t Num = 1) {
81
103k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
103k
  }
Unexecuted instantiation: llvm::ImutAVLTree<llvm::ImutContainerInfo<std::__1::pair<clang::ento::SymExpr const*, llvm::SMTExpr const*> > >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutContainerInfo<std::__1::pair<clang::ento::SymExpr const*, llvm::SMTExpr const*> > > >(unsigned long)
clang::ento::SymbolRegionValue* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::SymbolRegionValue>(unsigned long)
Line
Count
Source
80
8.77k
  template <typename T> T *Allocate(size_t Num = 1) {
81
8.77k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
8.77k
  }
clang::ento::SymbolConjured* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::SymbolConjured>(unsigned long)
Line
Count
Source
80
45.6k
  template <typename T> T *Allocate(size_t Num = 1) {
81
45.6k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
45.6k
  }
clang::ento::SymbolDerived* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::SymbolDerived>(unsigned long)
Line
Count
Source
80
1.37k
  template <typename T> T *Allocate(size_t Num = 1) {
81
1.37k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
1.37k
  }
clang::ento::SymbolExtent* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::SymbolExtent>(unsigned long)
Line
Count
Source
80
1.58k
  template <typename T> T *Allocate(size_t Num = 1) {
81
1.58k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
1.58k
  }
clang::ento::SymbolMetadata* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::SymbolMetadata>(unsigned long)
Line
Count
Source
80
456
  template <typename T> T *Allocate(size_t Num = 1) {
81
456
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
456
  }
clang::ento::SymbolCast* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::SymbolCast>(unsigned long)
Line
Count
Source
80
29
  template <typename T> T *Allocate(size_t Num = 1) {
81
29
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
29
  }
clang::ento::SymIntExpr* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::SymIntExpr>(unsigned long)
Line
Count
Source
80
18.3k
  template <typename T> T *Allocate(size_t Num = 1) {
81
18.3k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
18.3k
  }
clang::ento::IntSymExpr* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::IntSymExpr>(unsigned long)
Line
Count
Source
80
126
  template <typename T> T *Allocate(size_t Num = 1) {
81
126
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
126
  }
clang::ento::SymSymExpr* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::SymSymExpr>(unsigned long)
Line
Count
Source
80
1.53k
  template <typename T> T *Allocate(size_t Num = 1) {
81
1.53k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
1.53k
  }
clang::Token* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::Token>(unsigned long)
Line
Count
Source
80
78.2k
  template <typename T> T *Allocate(size_t Num = 1) {
81
78.2k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
78.2k
  }
ParsePragma.cpp:(anonymous namespace)::PragmaPackInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<(anonymous namespace)::PragmaPackInfo>(unsigned long)
Line
Count
Source
80
74.5k
  template <typename T> T *Allocate(size_t Num = 1) {
81
74.5k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
74.5k
  }
ParsePragma.cpp:std::__1::pair<clang::IdentifierInfo const*, (anonymous namespace)::OpenCLExtState>* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<std::__1::pair<clang::IdentifierInfo const*, (anonymous namespace)::OpenCLExtState> >(unsigned long)
Line
Count
Source
80
2.30k
  template <typename T> T *Allocate(size_t Num = 1) {
81
2.30k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
2.30k
  }
clang::ImplicitConversionSequence* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ImplicitConversionSequence>(unsigned long)
Line
Count
Source
80
14.1M
  template <typename T> T *Allocate(size_t Num = 1) {
81
14.1M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
14.1M
  }
clang::ObjCMethodList* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ObjCMethodList>(unsigned long)
Line
Count
Source
80
13.3k
  template <typename T> T *Allocate(size_t Num = 1) {
81
13.3k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
13.3k
  }
clang::Sema::SpecialMemberOverloadResultEntry* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::Sema::SpecialMemberOverloadResultEntry>(unsigned long)
Line
Count
Source
80
399k
  template <typename T> T *Allocate(size_t Num = 1) {
81
399k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
399k
  }
clang::BumpVector<clang::VarDecl const*>* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::BumpVector<clang::VarDecl const*> >(unsigned long)
Line
Count
Source
80
389
  template <typename T> T *Allocate(size_t Num = 1) {
81
389
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
389
  }
clang::VarDecl const** llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::VarDecl const*>(unsigned long)
Line
Count
Source
80
389
  template <typename T> T *Allocate(size_t Num = 1) {
81
389
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
389
  }
CFG.cpp:(anonymous namespace)::LocalScope* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<(anonymous namespace)::LocalScope>(unsigned long)
Line
Count
Source
80
14.3k
  template <typename T> T *Allocate(size_t Num = 1) {
81
14.3k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
14.3k
  }
clang::VarDecl** llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::VarDecl*>(unsigned long)
Line
Count
Source
80
14.4k
  template <typename T> T *Allocate(size_t Num = 1) {
81
14.4k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
14.4k
  }
clang::CFGBlock* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::CFGBlock>(unsigned long)
Line
Count
Source
80
2.07M
  template <typename T> T *Allocate(size_t Num = 1) {
81
2.07M
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
2.07M
  }
clang::ConstructionContextLayer* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ConstructionContextLayer>(unsigned long)
Line
Count
Source
80
823k
  template <typename T> T *Allocate(size_t Num = 1) {
81
823k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
823k
  }
clang::SimpleTemporaryObjectConstructionContext* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::SimpleTemporaryObjectConstructionContext>(unsigned long)
Line
Count
Source
80
2.58k
  template <typename T> T *Allocate(size_t Num = 1) {
81
2.58k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
2.58k
  }
clang::ElidedTemporaryObjectConstructionContext* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ElidedTemporaryObjectConstructionContext>(unsigned long)
Line
Count
Source
80
2.59k
  template <typename T> T *Allocate(size_t Num = 1) {
81
2.59k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
2.59k
  }
clang::CXX17ElidedCopyVariableConstructionContext* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::CXX17ElidedCopyVariableConstructionContext>(unsigned long)
Line
Count
Source
80
60
  template <typename T> T *Allocate(size_t Num = 1) {
81
60
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
60
  }
clang::CXX17ElidedCopyReturnedValueConstructionContext* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::CXX17ElidedCopyReturnedValueConstructionContext>(unsigned long)
Line
Count
Source
80
70
  template <typename T> T *Allocate(size_t Num = 1) {
81
70
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
70
  }
clang::ArgumentConstructionContext* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ArgumentConstructionContext>(unsigned long)
Line
Count
Source
80
1.73k
  template <typename T> T *Allocate(size_t Num = 1) {
81
1.73k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
1.73k
  }
clang::CXX17ElidedCopyConstructorInitializerConstructionContext* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::CXX17ElidedCopyConstructorInitializerConstructionContext>(unsigned long)
Line
Count
Source
80
12
  template <typename T> T *Allocate(size_t Num = 1) {
81
12
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
12
  }
clang::SimpleVariableConstructionContext* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::SimpleVariableConstructionContext>(unsigned long)
Line
Count
Source
80
7.70k
  template <typename T> T *Allocate(size_t Num = 1) {
81
7.70k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
7.70k
  }
clang::NewAllocatedObjectConstructionContext* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::NewAllocatedObjectConstructionContext>(unsigned long)
Line
Count
Source
80
759
  template <typename T> T *Allocate(size_t Num = 1) {
81
759
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
759
  }
clang::SimpleReturnedValueConstructionContext* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::SimpleReturnedValueConstructionContext>(unsigned long)
Line
Count
Source
80
1.22k
  template <typename T> T *Allocate(size_t Num = 1) {
81
1.22k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
1.22k
  }
clang::SimpleConstructorInitializerConstructionContext* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::SimpleConstructorInitializerConstructionContext>(unsigned long)
Line
Count
Source
80
2.20k
  template <typename T> T *Allocate(size_t Num = 1) {
81
2.20k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
2.20k
  }
llvm::ImutAVLTree<llvm::ImutContainerInfo<clang::BindingDecl const*> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutContainerInfo<clang::BindingDecl const*> > >(unsigned long)
Line
Count
Source
80
53
  template <typename T> T *Allocate(size_t Num = 1) {
81
53
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
53
  }
llvm::ImutAVLTree<llvm::ImutContainerInfo<clang::Stmt const*> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutContainerInfo<clang::Stmt const*> > >(unsigned long)
Line
Count
Source
80
442k
  template <typename T> T *Allocate(size_t Num = 1) {
81
442k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
442k
  }
llvm::FoldingSetNodeWrapper<clang::ento::RetainSummary>* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::FoldingSetNodeWrapper<clang::ento::RetainSummary> >(unsigned long)
Line
Count
Source
80
898
  template <typename T> T *Allocate(size_t Num = 1) {
81
898
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
898
  }
clang::ento::RetainSummary* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::ento::RetainSummary>(unsigned long)
Line
Count
Source
80
1.26k
  template <typename T> T *Allocate(size_t Num = 1) {
81
1.26k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
1.26k
  }
llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::NamedDecl const*, unsigned int> >* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<llvm::ImutAVLTree<llvm::ImutKeyValueInfo<clang::NamedDecl const*, unsigned int> > >(unsigned long)
Line
Count
Source
80
1.15k
  template <typename T> T *Allocate(size_t Num = 1) {
81
1.15k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
1.15k
  }
Unexecuted instantiation: clang::threadSafety::til::SExpr** llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::threadSafety::til::SExpr*>(unsigned long)
Unexecuted instantiation: clang::threadSafety::til::BasicBlock** llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::threadSafety::til::BasicBlock*>(unsigned long)
Unexecuted instantiation: clang::comments::BlockCommandComment::Argument* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::comments::BlockCommandComment::Argument>(unsigned long)
clang::comments::HTMLStartTagComment::Attribute* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::comments::HTMLStartTagComment::Attribute>(unsigned long)
Line
Count
Source
80
32
  template <typename T> T *Allocate(size_t Num = 1) {
81
32
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
32
  }
clang::comments::InlineContentComment** llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::comments::InlineContentComment*>(unsigned long)
Line
Count
Source
80
2.46k
  template <typename T> T *Allocate(size_t Num = 1) {
81
2.46k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
2.46k
  }
clang::comments::VerbatimBlockLineComment** llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::comments::VerbatimBlockLineComment*>(unsigned long)
Line
Count
Source
80
28
  template <typename T> T *Allocate(size_t Num = 1) {
81
28
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
28
  }
clang::comments::BlockContentComment** llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<clang::comments::BlockContentComment*>(unsigned long)
Line
Count
Source
80
1.25k
  template <typename T> T *Allocate(size_t Num = 1) {
81
1.25k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
1.25k
  }
RecordLayoutBuilder.cpp:(anonymous namespace)::BaseSubobjectInfo* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<(anonymous namespace)::BaseSubobjectInfo>(unsigned long)
Line
Count
Source
80
572k
  template <typename T> T *Allocate(size_t Num = 1) {
81
572k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
572k
  }
std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, unsigned int>* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, unsigned int> >(unsigned long)
Line
Count
Source
80
240
  template <typename T> T *Allocate(size_t Num = 1) {
81
240
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
240
  }
unsigned char* llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Allocate<unsigned char>(unsigned long)
Line
Count
Source
80
13.6k
  template <typename T> T *Allocate(size_t Num = 1) {
81
13.6k
    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82
13.6k
  }
83
84
  /// Deallocate space for a sequence of objects without constructing them.
85
  template <typename T>
86
  typename std::enable_if<
87
      !std::is_same<typename std::remove_cv<T>::type, void>::value, void>::type
88
3.81M
  Deallocate(T *Ptr, size_t Num = 1) {
89
3.81M
    Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T));
90
3.81M
  }
std::__1::enable_if<!(std::is_same<std::__1::remove_cv<llvm::Loop>::type, void>::value), void>::type llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Deallocate<llvm::Loop>(llvm::Loop*, unsigned long)
Line
Count
Source
88
25.1k
  Deallocate(T *Ptr, size_t Num = 1) {
89
25.1k
    Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T));
90
25.1k
  }
std::__1::enable_if<!(std::is_same<std::__1::remove_cv<llvm::MachineRegisterInfo>::type, void>::value), void>::type llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Deallocate<llvm::MachineRegisterInfo>(llvm::MachineRegisterInfo*, unsigned long)
Line
Count
Source
88
527k
  Deallocate(T *Ptr, size_t Num = 1) {
89
527k
    Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T));
90
527k
  }
std::__1::enable_if<!(std::is_same<std::__1::remove_cv<llvm::MachineFunctionInfo>::type, void>::value), void>::type llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Deallocate<llvm::MachineFunctionInfo>(llvm::MachineFunctionInfo*, unsigned long)
Line
Count
Source
88
505k
  Deallocate(T *Ptr, size_t Num = 1) {
89
505k
    Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T));
90
505k
  }
std::__1::enable_if<!(std::is_same<std::__1::remove_cv<llvm::MachineFrameInfo>::type, void>::value), void>::type llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Deallocate<llvm::MachineFrameInfo>(llvm::MachineFrameInfo*, unsigned long)
Line
Count
Source
88
526k
  Deallocate(T *Ptr, size_t Num = 1) {
89
526k
    Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T));
90
526k
  }
std::__1::enable_if<!(std::is_same<std::__1::remove_cv<llvm::MachineConstantPool>::type, void>::value), void>::type llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Deallocate<llvm::MachineConstantPool>(llvm::MachineConstantPool*, unsigned long)
Line
Count
Source
88
526k
  Deallocate(T *Ptr, size_t Num = 1) {
89
526k
    Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T));
90
526k
  }
std::__1::enable_if<!(std::is_same<std::__1::remove_cv<llvm::MachineJumpTableInfo>::type, void>::value), void>::type llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Deallocate<llvm::MachineJumpTableInfo>(llvm::MachineJumpTableInfo*, unsigned long)
Line
Count
Source
88
4.31k
  Deallocate(T *Ptr, size_t Num = 1) {
89
4.31k
    Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T));
90
4.31k
  }
std::__1::enable_if<!(std::is_same<std::__1::remove_cv<llvm::WinEHFuncInfo>::type, void>::value), void>::type llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Deallocate<llvm::WinEHFuncInfo>(llvm::WinEHFuncInfo*, unsigned long)
Line
Count
Source
88
107
  Deallocate(T *Ptr, size_t Num = 1) {
89
107
    Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T));
90
107
  }
std::__1::enable_if<!(std::is_same<std::__1::remove_cv<llvm::WasmEHFuncInfo>::type, void>::value), void>::type llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Deallocate<llvm::WasmEHFuncInfo>(llvm::WasmEHFuncInfo*, unsigned long)
Line
Count
Source
88
151
  Deallocate(T *Ptr, size_t Num = 1) {
89
151
    Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T));
90
151
  }
Unexecuted instantiation: std::__1::enable_if<!(std::is_same<std::__1::remove_cv<llvm::MachineLoop>::type, void>::value), void>::type llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Deallocate<llvm::MachineLoop>(llvm::MachineLoop*, unsigned long)
EarlyCSE.cpp:std::__1::enable_if<!(std::is_same<std::__1::remove_cv<llvm::ScopedHashTableVal<(anonymous namespace)::CallValue, std::__1::pair<llvm::Instruction*, unsigned int> > >::type, void>::value), void>::type llvm::AllocatorBase<llvm::MallocAllocator>::Deallocate<llvm::ScopedHashTableVal<(anonymous namespace)::CallValue, std::__1::pair<llvm::Instruction*, unsigned int> > >(llvm::ScopedHashTableVal<(anonymous namespace)::CallValue, std::__1::pair<llvm::Instruction*, unsigned int> >*, unsigned long)
Line
Count
Source
88
46.2k
  Deallocate(T *Ptr, size_t Num = 1) {
89
46.2k
    Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T));
90
46.2k
  }
std::__1::enable_if<!(std::is_same<std::__1::remove_cv<llvm::GVNExpression::Expression const>::type, void>::value), void>::type llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Deallocate<llvm::GVNExpression::Expression const>(llvm::GVNExpression::Expression const*, unsigned long)
Line
Count
Source
88
861
  Deallocate(T *Ptr, size_t Num = 1) {
89
861
    Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T));
90
861
  }
std::__1::enable_if<!(std::is_same<std::__1::remove_cv<llvm::AllocatorList<llvm::yaml::Token, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Node>::type, void>::value), void>::type llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Deallocate<llvm::AllocatorList<llvm::yaml::Token, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Node>(llvm::AllocatorList<llvm::yaml::Token, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Node*, unsigned long)
Line
Count
Source
88
1.50M
  Deallocate(T *Ptr, size_t Num = 1) {
89
1.50M
    Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T));
90
1.50M
  }
std::__1::enable_if<!(std::is_same<std::__1::remove_cv<clang::SrcMgr::ContentCache>::type, void>::value), void>::type llvm::AllocatorBase<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul> >::Deallocate<clang::SrcMgr::ContentCache>(clang::SrcMgr::ContentCache*, unsigned long)
Line
Count
Source
88
147k
  Deallocate(T *Ptr, size_t Num = 1) {
89
147k
    Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T));
90
147k
  }
91
};
92
93
class MallocAllocator : public AllocatorBase<MallocAllocator> {
94
public:
95
0
  void Reset() {}
96
97
  LLVM_ATTRIBUTE_RETURNS_NONNULL void *Allocate(size_t Size,
98
277M
                                                size_t /*Alignment*/) {
99
277M
    return safe_malloc(Size);
100
277M
  }
101
102
  // Pull in base class overloads.
103
  using AllocatorBase<MallocAllocator>::Allocate;
104
105
260M
  void Deallocate(const void *Ptr, size_t /*Size*/) {
106
260M
    free(const_cast<void *>(Ptr));
107
260M
  }
108
109
  // Pull in base class overloads.
110
  using AllocatorBase<MallocAllocator>::Deallocate;
111
112
0
  void PrintStats() const {}
113
};
114
115
namespace detail {
116
117
// We call out to an external function to actually print the message as the
118
// printing code uses Allocator.h in its implementation.
119
void printBumpPtrAllocatorStats(unsigned NumSlabs, size_t BytesAllocated,
120
                                size_t TotalMemory);
121
122
} // end namespace detail
123
124
/// Allocate memory in an ever growing pool, as if by bump-pointer.
125
///
126
/// This isn't strictly a bump-pointer allocator as it uses backing slabs of
127
/// memory rather than relying on a boundless contiguous heap. However, it has
128
/// bump-pointer semantics in that it is a monotonically growing pool of memory
129
/// where every allocation is found by merely allocating the next N bytes in
130
/// the slab, or the next N bytes in the next slab.
131
///
132
/// Note that this also has a threshold for forcing allocations above a certain
133
/// size into their own slab.
134
///
135
/// The BumpPtrAllocatorImpl template defaults to using a MallocAllocator
136
/// object, which wraps malloc, to allocate memory, but it can be changed to
137
/// use a custom allocator.
138
template <typename AllocatorT = MallocAllocator, size_t SlabSize = 4096,
139
          size_t SizeThreshold = SlabSize>
140
class BumpPtrAllocatorImpl
141
    : public AllocatorBase<
142
          BumpPtrAllocatorImpl<AllocatorT, SlabSize, SizeThreshold>> {
143
public:
144
  static_assert(SizeThreshold <= SlabSize,
145
                "The SizeThreshold must be at most the SlabSize to ensure "
146
                "that objects larger than a slab go into their own memory "
147
                "allocation.");
148
149
40.9M
  BumpPtrAllocatorImpl() = default;
llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>::BumpPtrAllocatorImpl()
Line
Count
Source
149
40.9M
  BumpPtrAllocatorImpl() = default;
llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 65536ul, 65536ul>::BumpPtrAllocatorImpl()
Line
Count
Source
149
6.69k
  BumpPtrAllocatorImpl() = default;
150
151
  template <typename T>
152
  BumpPtrAllocatorImpl(T &&Allocator)
153
      : Allocator(std::forward<T &&>(Allocator)) {}
154
155
  // Manually implement a move constructor as we must clear the old allocator's
156
  // slabs as a matter of correctness.
157
  BumpPtrAllocatorImpl(BumpPtrAllocatorImpl &&Old)
158
      : CurPtr(Old.CurPtr), End(Old.End), Slabs(std::move(Old.Slabs)),
159
        CustomSizedSlabs(std::move(Old.CustomSizedSlabs)),
160
        BytesAllocated(Old.BytesAllocated), RedZoneSize(Old.RedZoneSize),
161
21.3k
        Allocator(std::move(Old.Allocator)) {
162
21.3k
    Old.CurPtr = Old.End = nullptr;
163
21.3k
    Old.BytesAllocated = 0;
164
21.3k
    Old.Slabs.clear();
165
21.3k
    Old.CustomSizedSlabs.clear();
166
21.3k
  }
167
168
40.7M
  ~BumpPtrAllocatorImpl() {
169
40.7M
    DeallocateSlabs(Slabs.begin(), Slabs.end());
170
40.7M
    DeallocateCustomSizedSlabs();
171
40.7M
  }
llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>::~BumpPtrAllocatorImpl()
Line
Count
Source
168
40.7M
  ~BumpPtrAllocatorImpl() {
169
40.7M
    DeallocateSlabs(Slabs.begin(), Slabs.end());
170
40.7M
    DeallocateCustomSizedSlabs();
171
40.7M
  }
llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 65536ul, 65536ul>::~BumpPtrAllocatorImpl()
Line
Count
Source
168
6.69k
  ~BumpPtrAllocatorImpl() {
169
6.69k
    DeallocateSlabs(Slabs.begin(), Slabs.end());
170
6.69k
    DeallocateCustomSizedSlabs();
171
6.69k
  }
172
173
5
  BumpPtrAllocatorImpl &operator=(BumpPtrAllocatorImpl &&RHS) {
174
5
    DeallocateSlabs(Slabs.begin(), Slabs.end());
175
5
    DeallocateCustomSizedSlabs();
176
5
177
5
    CurPtr = RHS.CurPtr;
178
5
    End = RHS.End;
179
5
    BytesAllocated = RHS.BytesAllocated;
180
5
    RedZoneSize = RHS.RedZoneSize;
181
5
    Slabs = std::move(RHS.Slabs);
182
5
    CustomSizedSlabs = std::move(RHS.CustomSizedSlabs);
183
5
    Allocator = std::move(RHS.Allocator);
184
5
185
5
    RHS.CurPtr = RHS.End = nullptr;
186
5
    RHS.BytesAllocated = 0;
187
5
    RHS.Slabs.clear();
188
5
    RHS.CustomSizedSlabs.clear();
189
5
    return *this;
190
5
  }
191
192
  /// Deallocate all but the current slab and reset the current pointer
193
  /// to the beginning of it, freeing all memory allocated so far.
194
31.3M
  void Reset() {
195
31.3M
    // Deallocate all but the first slab, and deallocate all custom-sized slabs.
196
31.3M
    DeallocateCustomSizedSlabs();
197
31.3M
    CustomSizedSlabs.clear();
198
31.3M
199
31.3M
    if (Slabs.empty())
200
12.4M
      return;
201
18.9M
202
18.9M
    // Reset the state.
203
18.9M
    BytesAllocated = 0;
204
18.9M
    CurPtr = (char *)Slabs.front();
205
18.9M
    End = CurPtr + SlabSize;
206
18.9M
207
18.9M
    __asan_poison_memory_region(*Slabs.begin(), computeSlabSize(0));
208
18.9M
    DeallocateSlabs(std::next(Slabs.begin()), Slabs.end());
209
18.9M
    Slabs.erase(std::next(Slabs.begin()), Slabs.end());
210
18.9M
  }
llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>::Reset()
Line
Count
Source
194
31.3M
  void Reset() {
195
31.3M
    // Deallocate all but the first slab, and deallocate all custom-sized slabs.
196
31.3M
    DeallocateCustomSizedSlabs();
197
31.3M
    CustomSizedSlabs.clear();
198
31.3M
199
31.3M
    if (Slabs.empty())
200
12.4M
      return;
201
18.9M
202
18.9M
    // Reset the state.
203
18.9M
    BytesAllocated = 0;
204
18.9M
    CurPtr = (char *)Slabs.front();
205
18.9M
    End = CurPtr + SlabSize;
206
18.9M
207
18.9M
    __asan_poison_memory_region(*Slabs.begin(), computeSlabSize(0));
208
18.9M
    DeallocateSlabs(std::next(Slabs.begin()), Slabs.end());
209
18.9M
    Slabs.erase(std::next(Slabs.begin()), Slabs.end());
210
18.9M
  }
llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 65536ul, 65536ul>::Reset()
Line
Count
Source
194
6.70k
  void Reset() {
195
6.70k
    // Deallocate all but the first slab, and deallocate all custom-sized slabs.
196
6.70k
    DeallocateCustomSizedSlabs();
197
6.70k
    CustomSizedSlabs.clear();
198
6.70k
199
6.70k
    if (Slabs.empty())
200
6.70k
      return;
201
0
202
0
    // Reset the state.
203
0
    BytesAllocated = 0;
204
0
    CurPtr = (char *)Slabs.front();
205
0
    End = CurPtr + SlabSize;
206
0
207
0
    __asan_poison_memory_region(*Slabs.begin(), computeSlabSize(0));
208
0
    DeallocateSlabs(std::next(Slabs.begin()), Slabs.end());
209
0
    Slabs.erase(std::next(Slabs.begin()), Slabs.end());
210
0
  }
211
212
  /// Allocate space at the specified alignment.
213
  LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void *
214
1.16G
  Allocate(size_t Size, size_t Alignment) {
215
1.16G
    assert(Alignment > 0 && "0-byte alignnment is not allowed. Use 1 instead.");
216
1.16G
217
1.16G
    // Keep track of how many bytes we've allocated.
218
1.16G
    BytesAllocated += Size;
219
1.16G
220
1.16G
    size_t Adjustment = alignmentAdjustment(CurPtr, Alignment);
221
1.16G
    assert(Adjustment + Size >= Size && "Adjustment + Size must not overflow");
222
1.16G
223
1.16G
    size_t SizeToAllocate = Size;
224
#if LLVM_ADDRESS_SANITIZER_BUILD
225
    // Add trailing bytes as a "red zone" under ASan.
226
    SizeToAllocate += RedZoneSize;
227
#endif
228
229
1.16G
    // Check if we have enough space.
230
1.16G
    if (Adjustment + SizeToAllocate <= size_t(End - CurPtr)) {
231
1.15G
      char *AlignedPtr = CurPtr + Adjustment;
232
1.15G
      CurPtr = AlignedPtr + SizeToAllocate;
233
1.15G
      // Update the allocation point of this memory block in MemorySanitizer.
234
1.15G
      // Without this, MemorySanitizer messages for values originated from here
235
1.15G
      // will point to the allocation of the entire slab.
236
1.15G
      __msan_allocated_memory(AlignedPtr, Size);
237
1.15G
      // Similarly, tell ASan about this space.
238
1.15G
      __asan_unpoison_memory_region(AlignedPtr, Size);
239
1.15G
      return AlignedPtr;
240
1.15G
    }
241
16.3M
242
16.3M
    // If Size is really big, allocate a separate slab for it.
243
16.3M
    size_t PaddedSize = SizeToAllocate + Alignment - 1;
244
16.3M
    if (PaddedSize > SizeThreshold) {
245
30.4k
      void *NewSlab = Allocator.Allocate(PaddedSize, 0);
246
30.4k
      // We own the new slab and don't want anyone reading anyting other than
247
30.4k
      // pieces returned from this method.  So poison the whole slab.
248
30.4k
      __asan_poison_memory_region(NewSlab, PaddedSize);
249
30.4k
      CustomSizedSlabs.push_back(std::make_pair(NewSlab, PaddedSize));
250
30.4k
251
30.4k
      uintptr_t AlignedAddr = alignAddr(NewSlab, Alignment);
252
30.4k
      assert(AlignedAddr + Size <= (uintptr_t)NewSlab + PaddedSize);
253
30.4k
      char *AlignedPtr = (char*)AlignedAddr;
254
30.4k
      __msan_allocated_memory(AlignedPtr, Size);
255
30.4k
      __asan_unpoison_memory_region(AlignedPtr, Size);
256
30.4k
      return AlignedPtr;
257
30.4k
    }
258
16.3M
259
16.3M
    // Otherwise, start a new slab and try again.
260
16.3M
    StartNewSlab();
261
16.3M
    uintptr_t AlignedAddr = alignAddr(CurPtr, Alignment);
262
16.3M
    assert(AlignedAddr + SizeToAllocate <= (uintptr_t)End &&
263
16.3M
           "Unable to allocate memory!");
264
16.3M
    char *AlignedPtr = (char*)AlignedAddr;
265
16.3M
    CurPtr = AlignedPtr + SizeToAllocate;
266
16.3M
    __msan_allocated_memory(AlignedPtr, Size);
267
16.3M
    __asan_unpoison_memory_region(AlignedPtr, Size);
268
16.3M
    return AlignedPtr;
269
16.3M
  }
llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>::Allocate(unsigned long, unsigned long)
Line
Count
Source
214
1.16G
  Allocate(size_t Size, size_t Alignment) {
215
1.16G
    assert(Alignment > 0 && "0-byte alignnment is not allowed. Use 1 instead.");
216
1.16G
217
1.16G
    // Keep track of how many bytes we've allocated.
218
1.16G
    BytesAllocated += Size;
219
1.16G
220
1.16G
    size_t Adjustment = alignmentAdjustment(CurPtr, Alignment);
221
1.16G
    assert(Adjustment + Size >= Size && "Adjustment + Size must not overflow");
222
1.16G
223
1.16G
    size_t SizeToAllocate = Size;
224
#if LLVM_ADDRESS_SANITIZER_BUILD
225
    // Add trailing bytes as a "red zone" under ASan.
226
    SizeToAllocate += RedZoneSize;
227
#endif
228
229
1.16G
    // Check if we have enough space.
230
1.16G
    if (Adjustment + SizeToAllocate <= size_t(End - CurPtr)) {
231
1.15G
      char *AlignedPtr = CurPtr + Adjustment;
232
1.15G
      CurPtr = AlignedPtr + SizeToAllocate;
233
1.15G
      // Update the allocation point of this memory block in MemorySanitizer.
234
1.15G
      // Without this, MemorySanitizer messages for values originated from here
235
1.15G
      // will point to the allocation of the entire slab.
236
1.15G
      __msan_allocated_memory(AlignedPtr, Size);
237
1.15G
      // Similarly, tell ASan about this space.
238
1.15G
      __asan_unpoison_memory_region(AlignedPtr, Size);
239
1.15G
      return AlignedPtr;
240
1.15G
    }
241
16.3M
242
16.3M
    // If Size is really big, allocate a separate slab for it.
243
16.3M
    size_t PaddedSize = SizeToAllocate + Alignment - 1;
244
16.3M
    if (PaddedSize > SizeThreshold) {
245
23.7k
      void *NewSlab = Allocator.Allocate(PaddedSize, 0);
246
23.7k
      // We own the new slab and don't want anyone reading anyting other than
247
23.7k
      // pieces returned from this method.  So poison the whole slab.
248
23.7k
      __asan_poison_memory_region(NewSlab, PaddedSize);
249
23.7k
      CustomSizedSlabs.push_back(std::make_pair(NewSlab, PaddedSize));
250
23.7k
251
23.7k
      uintptr_t AlignedAddr = alignAddr(NewSlab, Alignment);
252
23.7k
      assert(AlignedAddr + Size <= (uintptr_t)NewSlab + PaddedSize);
253
23.7k
      char *AlignedPtr = (char*)AlignedAddr;
254
23.7k
      __msan_allocated_memory(AlignedPtr, Size);
255
23.7k
      __asan_unpoison_memory_region(AlignedPtr, Size);
256
23.7k
      return AlignedPtr;
257
23.7k
    }
258
16.3M
259
16.3M
    // Otherwise, start a new slab and try again.
260
16.3M
    StartNewSlab();
261
16.3M
    uintptr_t AlignedAddr = alignAddr(CurPtr, Alignment);
262
16.3M
    assert(AlignedAddr + SizeToAllocate <= (uintptr_t)End &&
263
16.3M
           "Unable to allocate memory!");
264
16.3M
    char *AlignedPtr = (char*)AlignedAddr;
265
16.3M
    CurPtr = AlignedPtr + SizeToAllocate;
266
16.3M
    __msan_allocated_memory(AlignedPtr, Size);
267
16.3M
    __asan_unpoison_memory_region(AlignedPtr, Size);
268
16.3M
    return AlignedPtr;
269
16.3M
  }
llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 65536ul, 65536ul>::Allocate(unsigned long, unsigned long)
Line
Count
Source
214
6.71k
  Allocate(size_t Size, size_t Alignment) {
215
6.71k
    assert(Alignment > 0 && "0-byte alignnment is not allowed. Use 1 instead.");
216
6.71k
217
6.71k
    // Keep track of how many bytes we've allocated.
218
6.71k
    BytesAllocated += Size;
219
6.71k
220
6.71k
    size_t Adjustment = alignmentAdjustment(CurPtr, Alignment);
221
6.71k
    assert(Adjustment + Size >= Size && "Adjustment + Size must not overflow");
222
6.71k
223
6.71k
    size_t SizeToAllocate = Size;
224
#if LLVM_ADDRESS_SANITIZER_BUILD
225
    // Add trailing bytes as a "red zone" under ASan.
226
    SizeToAllocate += RedZoneSize;
227
#endif
228
229
6.71k
    // Check if we have enough space.
230
6.71k
    if (Adjustment + SizeToAllocate <= size_t(End - CurPtr)) {
231
0
      char *AlignedPtr = CurPtr + Adjustment;
232
0
      CurPtr = AlignedPtr + SizeToAllocate;
233
0
      // Update the allocation point of this memory block in MemorySanitizer.
234
0
      // Without this, MemorySanitizer messages for values originated from here
235
0
      // will point to the allocation of the entire slab.
236
0
      __msan_allocated_memory(AlignedPtr, Size);
237
0
      // Similarly, tell ASan about this space.
238
0
      __asan_unpoison_memory_region(AlignedPtr, Size);
239
0
      return AlignedPtr;
240
0
    }
241
6.71k
242
6.71k
    // If Size is really big, allocate a separate slab for it.
243
6.71k
    size_t PaddedSize = SizeToAllocate + Alignment - 1;
244
6.71k
    if (PaddedSize > SizeThreshold) {
245
6.71k
      void *NewSlab = Allocator.Allocate(PaddedSize, 0);
246
6.71k
      // We own the new slab and don't want anyone reading anyting other than
247
6.71k
      // pieces returned from this method.  So poison the whole slab.
248
6.71k
      __asan_poison_memory_region(NewSlab, PaddedSize);
249
6.71k
      CustomSizedSlabs.push_back(std::make_pair(NewSlab, PaddedSize));
250
6.71k
251
6.71k
      uintptr_t AlignedAddr = alignAddr(NewSlab, Alignment);
252
6.71k
      assert(AlignedAddr + Size <= (uintptr_t)NewSlab + PaddedSize);
253
6.71k
      char *AlignedPtr = (char*)AlignedAddr;
254
6.71k
      __msan_allocated_memory(AlignedPtr, Size);
255
6.71k
      __asan_unpoison_memory_region(AlignedPtr, Size);
256
6.71k
      return AlignedPtr;
257
6.71k
    }
258
0
259
0
    // Otherwise, start a new slab and try again.
260
0
    StartNewSlab();
261
0
    uintptr_t AlignedAddr = alignAddr(CurPtr, Alignment);
262
0
    assert(AlignedAddr + SizeToAllocate <= (uintptr_t)End &&
263
0
           "Unable to allocate memory!");
264
0
    char *AlignedPtr = (char*)AlignedAddr;
265
0
    CurPtr = AlignedPtr + SizeToAllocate;
266
0
    __msan_allocated_memory(AlignedPtr, Size);
267
0
    __asan_unpoison_memory_region(AlignedPtr, Size);
268
0
    return AlignedPtr;
269
0
  }
270
271
  // Pull in base class overloads.
272
  using AllocatorBase<BumpPtrAllocatorImpl>::Allocate;
273
274
  // Bump pointer allocators are expected to never free their storage; and
275
  // clients expect pointers to remain valid for non-dereferencing uses even
276
  // after deallocation.
277
143M
  void Deallocate(const void *Ptr, size_t Size) {
278
143M
    __asan_poison_memory_region(Ptr, Size);
279
143M
  }
280
281
  // Pull in base class overloads.
282
  using AllocatorBase<BumpPtrAllocatorImpl>::Deallocate;
283
284
  size_t GetNumSlabs() const { return Slabs.size() + CustomSizedSlabs.size(); }
285
286
  /// \return An index uniquely and reproducibly identifying
287
  /// an input pointer \p Ptr in the given allocator.
288
  /// The returned value is negative iff the object is inside a custom-size
289
  /// slab.
290
  /// Returns an empty optional if the pointer is not found in the allocator.
291
9
  llvm::Optional<int64_t> identifyObject(const void *Ptr) {
292
9
    const char *P = static_cast<const char *>(Ptr);
293
9
    int64_t InSlabIdx = 0;
294
168
    for (size_t Idx = 0, E = Slabs.size(); Idx < E; 
Idx++159
) {
295
168
      const char *S = static_cast<const char *>(Slabs[Idx]);
296
168
      if (P >= S && 
P < S + computeSlabSize(Idx)148
)
297
9
        return InSlabIdx + static_cast<int64_t>(P - S);
298
159
      InSlabIdx += static_cast<int64_t>(computeSlabSize(Idx));
299
159
    }
300
9
301
9
    // Use negative index to denote custom sized slabs.
302
9
    int64_t InCustomSizedSlabIdx = -1;
303
0
    for (size_t Idx = 0, E = CustomSizedSlabs.size(); Idx < E; Idx++) {
304
0
      const char *S = static_cast<const char *>(CustomSizedSlabs[Idx].first);
305
0
      size_t Size = CustomSizedSlabs[Idx].second;
306
0
      if (P >= S && P < S + Size)
307
0
        return InCustomSizedSlabIdx - static_cast<int64_t>(P - S);
308
0
      InCustomSizedSlabIdx -= static_cast<int64_t>(Size);
309
0
    }
310
0
    return None;
311
0
  }
312
313
  /// A wrapper around identifyObject that additionally asserts that
314
  /// the object is indeed within the allocator.
315
  /// \return An index uniquely and reproducibly identifying
316
  /// an input pointer \p Ptr in the given allocator.
317
9
  int64_t identifyKnownObject(const void *Ptr) {
318
9
    Optional<int64_t> Out = identifyObject(Ptr);
319
9
    assert(Out && "Wrong allocator used");
320
9
    return *Out;
321
9
  }
322
323
  /// A wrapper around identifyKnownObject. Accepts type information
324
  /// about the object and produces a smaller identifier by relying on
325
  /// the alignment information. Note that sub-classes may have different
326
  /// alignment, so the most base class should be passed as template parameter
327
  /// in order to obtain correct results. For that reason automatic template
328
  /// parameter deduction is disabled.
329
  /// \return An index uniquely and reproducibly identifying
330
  /// an input pointer \p Ptr in the given allocator. This identifier is
331
  /// different from the ones produced by identifyObject and
332
  /// identifyAlignedObject.
333
  template <typename T>
334
9
  int64_t identifyKnownAlignedObject(const void *Ptr) {
335
9
    int64_t Out = identifyKnownObject(Ptr);
336
9
    assert(Out % alignof(T) == 0 && "Wrong alignment information");
337
9
    return Out / alignof(T);
338
9
  }
Unexecuted instantiation: long long llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>::identifyKnownAlignedObject<clang::ento::ExplodedNode>(void const*)
Unexecuted instantiation: long long llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>::identifyKnownAlignedObject<clang::ento::ProgramState>(void const*)
Unexecuted instantiation: long long llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>::identifyKnownAlignedObject<clang::Decl>(void const*)
Unexecuted instantiation: long long llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>::identifyKnownAlignedObject<clang::CXXCtorInitializer>(void const*)
long long llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>::identifyKnownAlignedObject<clang::Stmt>(void const*)
Line
Count
Source
334
9
  int64_t identifyKnownAlignedObject(const void *Ptr) {
335
9
    int64_t Out = identifyKnownObject(Ptr);
336
9
    assert(Out % alignof(T) == 0 && "Wrong alignment information");
337
9
    return Out / alignof(T);
338
9
  }
339
340
24
  size_t getTotalMemory() const {
341
24
    size_t TotalMemory = 0;
342
245
    for (auto I = Slabs.begin(), E = Slabs.end(); I != E; 
++I221
)
343
221
      TotalMemory += computeSlabSize(std::distance(Slabs.begin(), I));
344
24
    for (auto &PtrAndSize : CustomSizedSlabs)
345
0
      TotalMemory += PtrAndSize.second;
346
24
    return TotalMemory;
347
24
  }
348
349
  size_t getBytesAllocated() const { return BytesAllocated; }
350
351
928k
  void setRedZoneSize(size_t NewSize) {
352
928k
    RedZoneSize = NewSize;
353
928k
  }
354
355
9
  void PrintStats() const {
356
9
    detail::printBumpPtrAllocatorStats(Slabs.size(), BytesAllocated,
357
9
                                       getTotalMemory());
358
9
  }
359
360
private:
361
  /// The current pointer into the current slab.
362
  ///
363
  /// This points to the next free byte in the slab.
364
  char *CurPtr = nullptr;
365
366
  /// The end of the current slab.
367
  char *End = nullptr;
368
369
  /// The slabs allocated so far.
370
  SmallVector<void *, 4> Slabs;
371
372
  /// Custom-sized slabs allocated for too-large allocation requests.
373
  SmallVector<std::pair<void *, size_t>, 0> CustomSizedSlabs;
374
375
  /// How many bytes we've allocated.
376
  ///
377
  /// Used so that we can compute how much space was wasted.
378
  size_t BytesAllocated = 0;
379
380
  /// The number of bytes to put between allocations when running under
381
  /// a sanitizer.
382
  size_t RedZoneSize = 1;
383
384
  /// The allocator instance we use to get slabs of memory.
385
  AllocatorT Allocator;
386
387
31.7M
  static size_t computeSlabSize(unsigned SlabIdx) {
388
31.7M
    // Scale the actual allocated slab size based on the number of slabs
389
31.7M
    // allocated. Every 128 slabs allocated, we double the allocated size to
390
31.7M
    // reduce allocation frequency, but saturate at multiplying the slab size by
391
31.7M
    // 2^30.
392
31.7M
    return SlabSize * ((size_t)1 << std::min<size_t>(30, SlabIdx / 128));
393
31.7M
  }
llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>::computeSlabSize(unsigned int)
Line
Count
Source
387
31.7M
  static size_t computeSlabSize(unsigned SlabIdx) {
388
31.7M
    // Scale the actual allocated slab size based on the number of slabs
389
31.7M
    // allocated. Every 128 slabs allocated, we double the allocated size to
390
31.7M
    // reduce allocation frequency, but saturate at multiplying the slab size by
391
31.7M
    // 2^30.
392
31.7M
    return SlabSize * ((size_t)1 << std::min<size_t>(30, SlabIdx / 128));
393
31.7M
  }
Unexecuted instantiation: llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 65536ul, 65536ul>::computeSlabSize(unsigned int)
394
395
  /// Allocate a new slab and move the bump pointers over into the new
396
  /// slab, modifying CurPtr and End.
397
16.3M
  void StartNewSlab() {
398
16.3M
    size_t AllocatedSlabSize = computeSlabSize(Slabs.size());
399
16.3M
400
16.3M
    void *NewSlab = Allocator.Allocate(AllocatedSlabSize, 0);
401
16.3M
    // We own the new slab and don't want anyone reading anything other than
402
16.3M
    // pieces returned from this method.  So poison the whole slab.
403
16.3M
    __asan_poison_memory_region(NewSlab, AllocatedSlabSize);
404
16.3M
405
16.3M
    Slabs.push_back(NewSlab);
406
16.3M
    CurPtr = (char *)(NewSlab);
407
16.3M
    End = ((char *)NewSlab) + AllocatedSlabSize;
408
16.3M
  }
llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>::StartNewSlab()
Line
Count
Source
397
16.3M
  void StartNewSlab() {
398
16.3M
    size_t AllocatedSlabSize = computeSlabSize(Slabs.size());
399
16.3M
400
16.3M
    void *NewSlab = Allocator.Allocate(AllocatedSlabSize, 0);
401
16.3M
    // We own the new slab and don't want anyone reading anything other than
402
16.3M
    // pieces returned from this method.  So poison the whole slab.
403
16.3M
    __asan_poison_memory_region(NewSlab, AllocatedSlabSize);
404
16.3M
405
16.3M
    Slabs.push_back(NewSlab);
406
16.3M
    CurPtr = (char *)(NewSlab);
407
16.3M
    End = ((char *)NewSlab) + AllocatedSlabSize;
408
16.3M
  }
Unexecuted instantiation: llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 65536ul, 65536ul>::StartNewSlab()
409
410
  /// Deallocate a sequence of slabs.
411
  void DeallocateSlabs(SmallVectorImpl<void *>::iterator I,
412
59.7M
                       SmallVectorImpl<void *>::iterator E) {
413
73.3M
    for (; I != E; 
++I13.6M
) {
414
13.6M
      size_t AllocatedSlabSize =
415
13.6M
          computeSlabSize(std::distance(Slabs.begin(), I));
416
13.6M
      Allocator.Deallocate(*I, AllocatedSlabSize);
417
13.6M
    }
418
59.7M
  }
llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>::DeallocateSlabs(void**, void**)
Line
Count
Source
412
59.7M
                       SmallVectorImpl<void *>::iterator E) {
413
73.3M
    for (; I != E; 
++I13.6M
) {
414
13.6M
      size_t AllocatedSlabSize =
415
13.6M
          computeSlabSize(std::distance(Slabs.begin(), I));
416
13.6M
      Allocator.Deallocate(*I, AllocatedSlabSize);
417
13.6M
    }
418
59.7M
  }
llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 65536ul, 65536ul>::DeallocateSlabs(void**, void**)
Line
Count
Source
412
6.69k
                       SmallVectorImpl<void *>::iterator E) {
413
6.69k
    for (; I != E; 
++I0
) {
414
0
      size_t AllocatedSlabSize =
415
0
          computeSlabSize(std::distance(Slabs.begin(), I));
416
0
      Allocator.Deallocate(*I, AllocatedSlabSize);
417
0
    }
418
6.69k
  }
419
420
  /// Deallocate all memory for custom sized slabs.
421
72.1M
  void DeallocateCustomSizedSlabs() {
422
72.1M
    for (auto &PtrAndSize : CustomSizedSlabs) {
423
17.1k
      void *Ptr = PtrAndSize.first;
424
17.1k
      size_t Size = PtrAndSize.second;
425
17.1k
      Allocator.Deallocate(Ptr, Size);
426
17.1k
    }
427
72.1M
  }
llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>::DeallocateCustomSizedSlabs()
Line
Count
Source
421
72.1M
  void DeallocateCustomSizedSlabs() {
422
72.1M
    for (auto &PtrAndSize : CustomSizedSlabs) {
423
10.4k
      void *Ptr = PtrAndSize.first;
424
10.4k
      size_t Size = PtrAndSize.second;
425
10.4k
      Allocator.Deallocate(Ptr, Size);
426
10.4k
    }
427
72.1M
  }
llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 65536ul, 65536ul>::DeallocateCustomSizedSlabs()
Line
Count
Source
421
13.4k
  void DeallocateCustomSizedSlabs() {
422
13.4k
    for (auto &PtrAndSize : CustomSizedSlabs) {
423
6.71k
      void *Ptr = PtrAndSize.first;
424
6.71k
      size_t Size = PtrAndSize.second;
425
6.71k
      Allocator.Deallocate(Ptr, Size);
426
6.71k
    }
427
13.4k
  }
428
429
  template <typename T> friend class SpecificBumpPtrAllocator;
430
};
431
432
/// The standard BumpPtrAllocator which just uses the default template
433
/// parameters.
434
typedef BumpPtrAllocatorImpl<> BumpPtrAllocator;
435
436
/// A BumpPtrAllocator that allows only elements of a specific type to be
437
/// allocated.
438
///
439
/// This allows calling the destructor in DestroyAll() and when the allocator is
440
/// destroyed.
441
template <typename T> class SpecificBumpPtrAllocator {
442
  BumpPtrAllocator Allocator;
443
444
public:
445
770k
  SpecificBumpPtrAllocator() {
446
770k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
770k
    // it can't have red zones between allocations.
448
770k
    Allocator.setRedZoneSize(0);
449
770k
  }
llvm::SpecificBumpPtrAllocator<llvm::GCNIterativeScheduler::Region>::SpecificBumpPtrAllocator()
Line
Count
Source
445
8
  SpecificBumpPtrAllocator() {
446
8
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
8
    // it can't have red zones between allocations.
448
8
    Allocator.setRedZoneSize(0);
449
8
  }
GCNMinRegStrategy.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::GCNMinRegScheduler::Candidate>::SpecificBumpPtrAllocator()
Line
Count
Source
445
6
  SpecificBumpPtrAllocator() {
446
6
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
6
    // it can't have red zones between allocations.
448
6
    Allocator.setRedZoneSize(0);
449
6
  }
GCNILPSched.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::GCNILPScheduler::Candidate>::SpecificBumpPtrAllocator()
Line
Count
Source
445
2
  SpecificBumpPtrAllocator() {
446
2
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
2
    // it can't have red zones between allocations.
448
2
    Allocator.setRedZoneSize(0);
449
2
  }
ARMLoadStoreOptimizer.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::ARMLoadStoreOpt::MergeCandidate>::SpecificBumpPtrAllocator()
Line
Count
Source
445
4.92k
  SpecificBumpPtrAllocator() {
446
4.92k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
4.92k
    // it can't have red zones between allocations.
448
4.92k
    Allocator.setRedZoneSize(0);
449
4.92k
  }
llvm::SpecificBumpPtrAllocator<llvm::DomainValue>::SpecificBumpPtrAllocator()
Line
Count
Source
445
16.3k
  SpecificBumpPtrAllocator() {
446
16.3k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
16.3k
    // it can't have red zones between allocations.
448
16.3k
    Allocator.setRedZoneSize(0);
449
16.3k
  }
HexagonCommonGEP.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::GepNode>::SpecificBumpPtrAllocator()
Line
Count
Source
445
3.34k
  SpecificBumpPtrAllocator() {
446
3.34k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
3.34k
    // it can't have red zones between allocations.
448
3.34k
    Allocator.setRedZoneSize(0);
449
3.34k
  }
llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::Node>::SpecificBumpPtrAllocator()
Line
Count
Source
445
448
  SpecificBumpPtrAllocator() {
446
448
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
448
    // it can't have red zones between allocations.
448
448
    Allocator.setRedZoneSize(0);
449
448
  }
llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::SCC>::SpecificBumpPtrAllocator()
Line
Count
Source
445
448
  SpecificBumpPtrAllocator() {
446
448
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
448
    // it can't have red zones between allocations.
448
448
    Allocator.setRedZoneSize(0);
449
448
  }
llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::RefSCC>::SpecificBumpPtrAllocator()
Line
Count
Source
445
1.30k
  SpecificBumpPtrAllocator() {
446
1.30k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
1.30k
    // it can't have red zones between allocations.
448
1.30k
    Allocator.setRedZoneSize(0);
449
1.30k
  }
MachineBlockPlacement.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::BlockChain>::SpecificBumpPtrAllocator()
Line
Count
Source
445
34.0k
  SpecificBumpPtrAllocator() {
446
34.0k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
34.0k
    // it can't have red zones between allocations.
448
34.0k
    Allocator.setRedZoneSize(0);
449
34.0k
  }
MachineOutliner.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::SuffixTreeNode>::SpecificBumpPtrAllocator()
Line
Count
Source
445
8.38k
  SpecificBumpPtrAllocator() {
446
8.38k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
8.38k
    // it can't have red zones between allocations.
448
8.38k
    Allocator.setRedZoneSize(0);
449
8.38k
  }
llvm::SpecificBumpPtrAllocator<llvm::PMTopLevelManager::AUFoldingSetNode>::SpecificBumpPtrAllocator()
Line
Count
Source
445
152k
  SpecificBumpPtrAllocator() {
446
152k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
152k
    // it can't have red zones between allocations.
448
152k
    Allocator.setRedZoneSize(0);
449
152k
  }
llvm::SpecificBumpPtrAllocator<BasicBlockState>::SpecificBumpPtrAllocator()
Line
Count
Source
445
34
  SpecificBumpPtrAllocator() {
446
34
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
34
    // it can't have red zones between allocations.
448
34
    Allocator.setRedZoneSize(0);
449
34
  }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionCOFF>::SpecificBumpPtrAllocator()
Line
Count
Source
445
54.0k
  SpecificBumpPtrAllocator() {
446
54.0k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
54.0k
    // it can't have red zones between allocations.
448
54.0k
    Allocator.setRedZoneSize(0);
449
54.0k
  }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionELF>::SpecificBumpPtrAllocator()
Line
Count
Source
445
54.0k
  SpecificBumpPtrAllocator() {
446
54.0k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
54.0k
    // it can't have red zones between allocations.
448
54.0k
    Allocator.setRedZoneSize(0);
449
54.0k
  }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionMachO>::SpecificBumpPtrAllocator()
Line
Count
Source
445
54.0k
  SpecificBumpPtrAllocator() {
446
54.0k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
54.0k
    // it can't have red zones between allocations.
448
54.0k
    Allocator.setRedZoneSize(0);
449
54.0k
  }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionWasm>::SpecificBumpPtrAllocator()
Line
Count
Source
445
54.0k
  SpecificBumpPtrAllocator() {
446
54.0k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
54.0k
    // it can't have red zones between allocations.
448
54.0k
    Allocator.setRedZoneSize(0);
449
54.0k
  }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionXCOFF>::SpecificBumpPtrAllocator()
Line
Count
Source
445
54.0k
  SpecificBumpPtrAllocator() {
446
54.0k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
54.0k
    // it can't have red zones between allocations.
448
54.0k
    Allocator.setRedZoneSize(0);
449
54.0k
  }
llvm::SpecificBumpPtrAllocator<llvm::MCSubtargetInfo>::SpecificBumpPtrAllocator()
Line
Count
Source
445
54.0k
  SpecificBumpPtrAllocator() {
446
54.0k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
54.0k
    // it can't have red zones between allocations.
448
54.0k
    Allocator.setRedZoneSize(0);
449
54.0k
  }
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::HeaderFileInfoTrait>::Item>::SpecificBumpPtrAllocator()
Line
Count
Source
445
3.61k
  SpecificBumpPtrAllocator() {
446
3.61k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
3.61k
    // it can't have red zones between allocations.
448
3.61k
    Allocator.setRedZoneSize(0);
449
3.61k
  }
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTMethodPoolTrait>::Item>::SpecificBumpPtrAllocator()
Line
Count
Source
445
176
  SpecificBumpPtrAllocator() {
446
176
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
176
    // it can't have red zones between allocations.
448
176
    Allocator.setRedZoneSize(0);
449
176
  }
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTIdentifierTableTrait>::Item>::SpecificBumpPtrAllocator()
Line
Count
Source
445
3.61k
  SpecificBumpPtrAllocator() {
446
3.61k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
3.61k
    // it can't have red zones between allocations.
448
3.61k
    Allocator.setRedZoneSize(0);
449
3.61k
  }
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTDeclContextNameLookupTrait>::Item>::SpecificBumpPtrAllocator()
Line
Count
Source
445
11.0k
  SpecificBumpPtrAllocator() {
446
11.0k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
11.0k
    // it can't have red zones between allocations.
448
11.0k
    Allocator.setRedZoneSize(0);
449
11.0k
  }
GlobalModuleIndex.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::IdentifierIndexWriterTrait>::Item>::SpecificBumpPtrAllocator()
Line
Count
Source
445
621
  SpecificBumpPtrAllocator() {
446
621
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
621
    // it can't have red zones between allocations.
448
621
    Allocator.setRedZoneSize(0);
449
621
  }
llvm::SpecificBumpPtrAllocator<llvm::SmallVector<llvm::Register, 1u> >::SpecificBumpPtrAllocator()
Line
Count
Source
445
7.00k
  SpecificBumpPtrAllocator() {
446
7.00k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
7.00k
    // it can't have red zones between allocations.
448
7.00k
    Allocator.setRedZoneSize(0);
449
7.00k
  }
llvm::SpecificBumpPtrAllocator<llvm::SmallVector<unsigned long long, 1u> >::SpecificBumpPtrAllocator()
Line
Count
Source
445
7.00k
  SpecificBumpPtrAllocator() {
446
7.00k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
7.00k
    // it can't have red zones between allocations.
448
7.00k
    Allocator.setRedZoneSize(0);
449
7.00k
  }
llvm::SpecificBumpPtrAllocator<std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, unsigned int> >::SpecificBumpPtrAllocator()
Line
Count
Source
445
3.10k
  SpecificBumpPtrAllocator() {
446
3.10k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
3.10k
    // it can't have red zones between allocations.
448
3.10k
    Allocator.setRedZoneSize(0);
449
3.10k
  }
RecordLayoutBuilder.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::BaseSubobjectInfo>::SpecificBumpPtrAllocator()
Line
Count
Source
445
189k
  SpecificBumpPtrAllocator() {
446
189k
    // Because SpecificBumpPtrAllocator walks the memory to call destructors,
447
189k
    // it can't have red zones between allocations.
448
189k
    Allocator.setRedZoneSize(0);
449
189k
  }
450
  SpecificBumpPtrAllocator(SpecificBumpPtrAllocator &&Old)
451
1.70k
      : Allocator(std::move(Old.Allocator)) {}
llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::Node>::SpecificBumpPtrAllocator(llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::Node>&&)
Line
Count
Source
451
852
      : Allocator(std::move(Old.Allocator)) {}
llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::SCC>::SpecificBumpPtrAllocator(llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::SCC>&&)
Line
Count
Source
451
852
      : Allocator(std::move(Old.Allocator)) {}
452
770k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
llvm::SpecificBumpPtrAllocator<llvm::GCNIterativeScheduler::Region>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
8
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
GCNMinRegStrategy.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::GCNMinRegScheduler::Candidate>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
6
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
GCNILPSched.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::GCNILPScheduler::Candidate>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
2
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
ARMLoadStoreOptimizer.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::ARMLoadStoreOpt::MergeCandidate>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
4.89k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
llvm::SpecificBumpPtrAllocator<llvm::DomainValue>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
16.2k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
HexagonCommonGEP.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::GepNode>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
3.34k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
MachineBlockPlacement.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::BlockChain>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
33.9k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
MachineOutliner.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::SuffixTreeNode>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
8.38k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
llvm::SpecificBumpPtrAllocator<llvm::PMTopLevelManager::AUFoldingSetNode>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
152k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
llvm::SpecificBumpPtrAllocator<BasicBlockState>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
34
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionCOFF>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
53.7k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionELF>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
53.7k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionMachO>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
53.7k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionWasm>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
53.7k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionXCOFF>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
53.7k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
llvm::SpecificBumpPtrAllocator<llvm::MCSubtargetInfo>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
53.7k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTDeclContextNameLookupTrait>::Item>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
11.0k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::HeaderFileInfoTrait>::Item>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
3.61k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTMethodPoolTrait>::Item>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
176
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTIdentifierTableTrait>::Item>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
3.61k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
GlobalModuleIndex.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::IdentifierIndexWriterTrait>::Item>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
621
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
llvm::SpecificBumpPtrAllocator<llvm::SmallVector<unsigned long long, 1u> >::~SpecificBumpPtrAllocator()
Line
Count
Source
452
7.00k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
llvm::SpecificBumpPtrAllocator<llvm::SmallVector<llvm::Register, 1u> >::~SpecificBumpPtrAllocator()
Line
Count
Source
452
7.00k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
llvm::SpecificBumpPtrAllocator<std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, unsigned int> >::~SpecificBumpPtrAllocator()
Line
Count
Source
452
3.11k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
RecordLayoutBuilder.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::BaseSubobjectInfo>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
189k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::RefSCC>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
1.30k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::SCC>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
1.30k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::Node>::~SpecificBumpPtrAllocator()
Line
Count
Source
452
1.30k
  ~SpecificBumpPtrAllocator() { DestroyAll(); }
453
454
0
  SpecificBumpPtrAllocator &operator=(SpecificBumpPtrAllocator &&RHS) {
455
0
    Allocator = std::move(RHS.Allocator);
456
0
    return *this;
457
0
  }
Unexecuted instantiation: llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::Node>::operator=(llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::Node>&&)
Unexecuted instantiation: llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::SCC>::operator=(llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::SCC>&&)
458
459
  /// Call the destructor of each allocated object and deallocate all but the
460
  /// current slab and reset the current pointer to the beginning of it, freeing
461
  /// all memory allocated so far.
462
1.82M
  void DestroyAll() {
463
1.82M
    auto DestroyElements = [](char *Begin, char *End) {
464
1.43M
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
31.1M
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)29.7M
)
466
29.7M
        reinterpret_cast<T *>(Ptr)->~T();
467
1.43M
    };
llvm::SpecificBumpPtrAllocator<llvm::GCNIterativeScheduler::Region>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
8
    auto DestroyElements = [](char *Begin, char *End) {
464
8
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
16
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)8
)
466
8
        reinterpret_cast<T *>(Ptr)->~T();
467
8
    };
GCNMinRegStrategy.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::GCNMinRegScheduler::Candidate>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
18
    auto DestroyElements = [](char *Begin, char *End) {
464
18
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
1.98k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)1.97k
)
466
1.97k
        reinterpret_cast<T *>(Ptr)->~T();
467
18
    };
GCNILPSched.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::GCNILPScheduler::Candidate>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
4
    auto DestroyElements = [](char *Begin, char *End) {
464
4
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
458
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)454
)
466
454
        reinterpret_cast<T *>(Ptr)->~T();
467
4
    };
ARMLoadStoreOptimizer.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::ARMLoadStoreOpt::MergeCandidate>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
16.2k
    auto DestroyElements = [](char *Begin, char *End) {
464
16.2k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
104k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)88.0k
)
466
88.0k
        reinterpret_cast<T *>(Ptr)->~T();
467
16.2k
    };
llvm::SpecificBumpPtrAllocator<llvm::DomainValue>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
111k
    auto DestroyElements = [](char *Begin, char *End) {
464
111k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
342k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)230k
)
466
230k
        reinterpret_cast<T *>(Ptr)->~T();
467
111k
    };
HexagonCommonGEP.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::GepNode>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
485
    auto DestroyElements = [](char *Begin, char *End) {
464
485
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
3.52k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)3.03k
)
466
3.03k
        reinterpret_cast<T *>(Ptr)->~T();
467
485
    };
MachineBlockPlacement.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::BlockChain>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
180k
    auto DestroyElements = [](char *Begin, char *End) {
464
180k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
2.89M
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)2.71M
)
466
2.71M
        reinterpret_cast<T *>(Ptr)->~T();
467
180k
    };
MachineOutliner.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::SuffixTreeNode>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
8.39k
    auto DestroyElements = [](char *Begin, char *End) {
464
8.39k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
18.9k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)10.5k
)
466
10.5k
        reinterpret_cast<T *>(Ptr)->~T();
467
8.39k
    };
llvm::SpecificBumpPtrAllocator<llvm::PMTopLevelManager::AUFoldingSetNode>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
281k
    auto DestroyElements = [](char *Begin, char *End) {
464
281k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
4.25M
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)3.97M
)
466
3.97M
        reinterpret_cast<T *>(Ptr)->~T();
467
281k
    };
llvm::SpecificBumpPtrAllocator<BasicBlockState>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
34
    auto DestroyElements = [](char *Begin, char *End) {
464
34
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
109
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)75
)
466
75
        reinterpret_cast<T *>(Ptr)->~T();
467
34
    };
llvm::SpecificBumpPtrAllocator<llvm::MCSectionWasm>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
874
    auto DestroyElements = [](char *Begin, char *End) {
464
874
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
13.9k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)13.0k
)
466
13.0k
        reinterpret_cast<T *>(Ptr)->~T();
467
874
    };
llvm::SpecificBumpPtrAllocator<llvm::MCSectionCOFF>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
5.20k
    auto DestroyElements = [](char *Begin, char *End) {
464
5.20k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
67.0k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)61.8k
)
466
61.8k
        reinterpret_cast<T *>(Ptr)->~T();
467
5.20k
    };
llvm::SpecificBumpPtrAllocator<llvm::MCSectionELF>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
131k
    auto DestroyElements = [](char *Begin, char *End) {
464
131k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
2.28M
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)2.15M
)
466
2.15M
        reinterpret_cast<T *>(Ptr)->~T();
467
131k
    };
llvm::SpecificBumpPtrAllocator<llvm::MCSectionMachO>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
67.6k
    auto DestroyElements = [](char *Begin, char *End) {
464
67.6k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
957k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)889k
)
466
889k
        reinterpret_cast<T *>(Ptr)->~T();
467
67.6k
    };
llvm::SpecificBumpPtrAllocator<llvm::MCSectionXCOFF>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
16
    auto DestroyElements = [](char *Begin, char *End) {
464
16
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
32
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)16
)
466
16
        reinterpret_cast<T *>(Ptr)->~T();
467
16
    };
llvm::SpecificBumpPtrAllocator<llvm::MCSubtargetInfo>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
4.13k
    auto DestroyElements = [](char *Begin, char *End) {
464
4.13k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
6.83k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)2.69k
)
466
2.69k
        reinterpret_cast<T *>(Ptr)->~T();
467
4.13k
    };
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTDeclContextNameLookupTrait>::Item>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
11.1k
    auto DestroyElements = [](char *Begin, char *End) {
464
11.1k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
61.5k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)50.4k
)
466
50.4k
        reinterpret_cast<T *>(Ptr)->~T();
467
11.1k
    };
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::HeaderFileInfoTrait>::Item>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
3.58k
    auto DestroyElements = [](char *Begin, char *End) {
464
3.58k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
9.28k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)5.69k
)
466
5.69k
        reinterpret_cast<T *>(Ptr)->~T();
467
3.58k
    };
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTMethodPoolTrait>::Item>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
176
    auto DestroyElements = [](char *Begin, char *End) {
464
176
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
726
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)550
)
466
550
        reinterpret_cast<T *>(Ptr)->~T();
467
176
    };
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTIdentifierTableTrait>::Item>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
46.6k
    auto DestroyElements = [](char *Begin, char *End) {
464
46.6k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
5.70M
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)5.65M
)
466
5.65M
        reinterpret_cast<T *>(Ptr)->~T();
467
46.6k
    };
GlobalModuleIndex.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::IdentifierIndexWriterTrait>::Item>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
1.71k
    auto DestroyElements = [](char *Begin, char *End) {
464
1.71k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
91.5k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)89.8k
)
466
89.8k
        reinterpret_cast<T *>(Ptr)->~T();
467
1.71k
    };
llvm::SpecificBumpPtrAllocator<llvm::SmallVector<llvm::Register, 1u> >::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
274k
    auto DestroyElements = [](char *Begin, char *End) {
464
274k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
11.7M
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)11.4M
)
466
11.4M
        reinterpret_cast<T *>(Ptr)->~T();
467
274k
    };
llvm::SpecificBumpPtrAllocator<llvm::SmallVector<unsigned long long, 1u> >::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
244k
    auto DestroyElements = [](char *Begin, char *End) {
464
244k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
2.01M
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)1.77M
)
466
1.77M
        reinterpret_cast<T *>(Ptr)->~T();
467
244k
    };
llvm::SpecificBumpPtrAllocator<std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, unsigned int> >::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
61
    auto DestroyElements = [](char *Begin, char *End) {
464
61
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
301
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)240
)
466
240
        reinterpret_cast<T *>(Ptr)->~T();
467
61
    };
RecordLayoutBuilder.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::BaseSubobjectInfo>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
40.3k
    auto DestroyElements = [](char *Begin, char *End) {
464
40.3k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
613k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)572k
)
466
572k
        reinterpret_cast<T *>(Ptr)->~T();
467
40.3k
    };
llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::RefSCC>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
406
    auto DestroyElements = [](char *Begin, char *End) {
464
406
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
2.62k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)2.21k
)
466
2.21k
        reinterpret_cast<T *>(Ptr)->~T();
467
406
    };
llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::SCC>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
384
    auto DestroyElements = [](char *Begin, char *End) {
464
384
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
2.66k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)2.28k
)
466
2.28k
        reinterpret_cast<T *>(Ptr)->~T();
467
384
    };
llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::Node>::DestroyAll()::'lambda'(char*, char*)::operator()(char*, char*) const
Line
Count
Source
463
400
    auto DestroyElements = [](char *Begin, char *End) {
464
400
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
2.78k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; 
Ptr += sizeof(T)2.38k
)
466
2.38k
        reinterpret_cast<T *>(Ptr)->~T();
467
400
    };
468
1.82M
469
3.25M
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
1.82M
         
++I1.43M
) {
471
1.43M
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
1.43M
          std::distance(Allocator.Slabs.begin(), I));
473
1.43M
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
1.43M
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr1.10M
475
1.43M
                                               : 
(char *)*I + AllocatedSlabSize329k
;
476
1.43M
477
1.43M
      DestroyElements(Begin, End);
478
1.43M
    }
479
1.82M
480
1.82M
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
1.82M
486
1.82M
    Allocator.Reset();
487
1.82M
  }
llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::Node>::DestroyAll()
Line
Count
Source
462
1.30k
  void DestroyAll() {
463
1.30k
    auto DestroyElements = [](char *Begin, char *End) {
464
1.30k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
1.30k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
1.30k
        reinterpret_cast<T *>(Ptr)->~T();
467
1.30k
    };
468
1.30k
469
1.70k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
1.30k
         
++I400
) {
471
400
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
400
          std::distance(Allocator.Slabs.begin(), I));
473
400
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
400
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr382
475
400
                                               : 
(char *)*I + AllocatedSlabSize18
;
476
400
477
400
      DestroyElements(Begin, End);
478
400
    }
479
1.30k
480
1.30k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
1.30k
486
1.30k
    Allocator.Reset();
487
1.30k
  }
llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::SCC>::DestroyAll()
Line
Count
Source
462
1.30k
  void DestroyAll() {
463
1.30k
    auto DestroyElements = [](char *Begin, char *End) {
464
1.30k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
1.30k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
1.30k
        reinterpret_cast<T *>(Ptr)->~T();
467
1.30k
    };
468
1.30k
469
1.68k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
1.30k
         
++I384
) {
471
384
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
384
          std::distance(Allocator.Slabs.begin(), I));
473
384
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
384
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr381
475
384
                                               : 
(char *)*I + AllocatedSlabSize3
;
476
384
477
384
      DestroyElements(Begin, End);
478
384
    }
479
1.30k
480
1.30k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
1.30k
486
1.30k
    Allocator.Reset();
487
1.30k
  }
llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::RefSCC>::DestroyAll()
Line
Count
Source
462
1.30k
  void DestroyAll() {
463
1.30k
    auto DestroyElements = [](char *Begin, char *End) {
464
1.30k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
1.30k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
1.30k
        reinterpret_cast<T *>(Ptr)->~T();
467
1.30k
    };
468
1.30k
469
1.70k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
1.30k
         
++I406
) {
471
406
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
406
          std::distance(Allocator.Slabs.begin(), I));
473
406
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
406
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr381
475
406
                                               : 
(char *)*I + AllocatedSlabSize25
;
476
406
477
406
      DestroyElements(Begin, End);
478
406
    }
479
1.30k
480
1.30k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
1.30k
486
1.30k
    Allocator.Reset();
487
1.30k
  }
llvm::SpecificBumpPtrAllocator<llvm::SmallVector<llvm::Register, 1u> >::DestroyAll()
Line
Count
Source
462
244k
  void DestroyAll() {
463
244k
    auto DestroyElements = [](char *Begin, char *End) {
464
244k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
244k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
244k
        reinterpret_cast<T *>(Ptr)->~T();
467
244k
    };
468
244k
469
519k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
274k
         ++I) {
471
274k
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
274k
          std::distance(Allocator.Slabs.begin(), I));
473
274k
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
274k
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr244k
475
274k
                                               : 
(char *)*I + AllocatedSlabSize30.1k
;
476
274k
477
274k
      DestroyElements(Begin, End);
478
274k
    }
479
244k
480
244k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
244k
486
244k
    Allocator.Reset();
487
244k
  }
llvm::SpecificBumpPtrAllocator<llvm::SmallVector<unsigned long long, 1u> >::DestroyAll()
Line
Count
Source
462
244k
  void DestroyAll() {
463
244k
    auto DestroyElements = [](char *Begin, char *End) {
464
244k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
244k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
244k
        reinterpret_cast<T *>(Ptr)->~T();
467
244k
    };
468
244k
469
489k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
244k
         
++I244k
) {
471
244k
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
244k
          std::distance(Allocator.Slabs.begin(), I));
473
244k
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
244k
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr244k
475
244k
                                               : 
(char *)*I + AllocatedSlabSize9
;
476
244k
477
244k
      DestroyElements(Begin, End);
478
244k
    }
479
244k
480
244k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
244k
486
244k
    Allocator.Reset();
487
244k
  }
llvm::SpecificBumpPtrAllocator<llvm::GCNIterativeScheduler::Region>::DestroyAll()
Line
Count
Source
462
8
  void DestroyAll() {
463
8
    auto DestroyElements = [](char *Begin, char *End) {
464
8
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
8
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
8
        reinterpret_cast<T *>(Ptr)->~T();
467
8
    };
468
8
469
16
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
8
         ++I) {
471
8
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
8
          std::distance(Allocator.Slabs.begin(), I));
473
8
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
8
      char *End = *I == Allocator.Slabs.back() ? Allocator.CurPtr
475
8
                                               : 
(char *)*I + AllocatedSlabSize0
;
476
8
477
8
      DestroyElements(Begin, End);
478
8
    }
479
8
480
8
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
8
486
8
    Allocator.Reset();
487
8
  }
GCNMinRegStrategy.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::GCNMinRegScheduler::Candidate>::DestroyAll()
Line
Count
Source
462
6
  void DestroyAll() {
463
6
    auto DestroyElements = [](char *Begin, char *End) {
464
6
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
6
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
6
        reinterpret_cast<T *>(Ptr)->~T();
467
6
    };
468
6
469
24
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
18
         ++I) {
471
18
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
18
          std::distance(Allocator.Slabs.begin(), I));
473
18
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
18
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr6
475
18
                                               : 
(char *)*I + AllocatedSlabSize12
;
476
18
477
18
      DestroyElements(Begin, End);
478
18
    }
479
6
480
6
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
6
486
6
    Allocator.Reset();
487
6
  }
GCNILPSched.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::GCNILPScheduler::Candidate>::DestroyAll()
Line
Count
Source
462
2
  void DestroyAll() {
463
2
    auto DestroyElements = [](char *Begin, char *End) {
464
2
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
2
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
2
        reinterpret_cast<T *>(Ptr)->~T();
467
2
    };
468
2
469
6
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
4
         ++I) {
471
4
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
4
          std::distance(Allocator.Slabs.begin(), I));
473
4
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
4
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr2
475
4
                                               : 
(char *)*I + AllocatedSlabSize2
;
476
4
477
4
      DestroyElements(Begin, End);
478
4
    }
479
2
480
2
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
2
486
2
    Allocator.Reset();
487
2
  }
ARMLoadStoreOptimizer.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::ARMLoadStoreOpt::MergeCandidate>::DestroyAll()
Line
Count
Source
462
30.1k
  void DestroyAll() {
463
30.1k
    auto DestroyElements = [](char *Begin, char *End) {
464
30.1k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
30.1k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
30.1k
        reinterpret_cast<T *>(Ptr)->~T();
467
30.1k
    };
468
30.1k
469
46.4k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
30.1k
         
++I16.2k
) {
471
16.2k
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
16.2k
          std::distance(Allocator.Slabs.begin(), I));
473
16.2k
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
16.2k
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr16.0k
475
16.2k
                                               : 
(char *)*I + AllocatedSlabSize225
;
476
16.2k
477
16.2k
      DestroyElements(Begin, End);
478
16.2k
    }
479
30.1k
480
30.1k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
30.1k
486
30.1k
    Allocator.Reset();
487
30.1k
  }
llvm::SpecificBumpPtrAllocator<llvm::DomainValue>::DestroyAll()
Line
Count
Source
462
144k
  void DestroyAll() {
463
144k
    auto DestroyElements = [](char *Begin, char *End) {
464
144k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
144k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
144k
        reinterpret_cast<T *>(Ptr)->~T();
467
144k
    };
468
144k
469
255k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
144k
         
++I111k
) {
471
111k
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
111k
          std::distance(Allocator.Slabs.begin(), I));
473
111k
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
111k
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr111k
475
111k
                                               : 
(char *)*I + AllocatedSlabSize93
;
476
111k
477
111k
      DestroyElements(Begin, End);
478
111k
    }
479
144k
480
144k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
144k
486
144k
    Allocator.Reset();
487
144k
  }
HexagonCommonGEP.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::GepNode>::DestroyAll()
Line
Count
Source
462
3.34k
  void DestroyAll() {
463
3.34k
    auto DestroyElements = [](char *Begin, char *End) {
464
3.34k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
3.34k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
3.34k
        reinterpret_cast<T *>(Ptr)->~T();
467
3.34k
    };
468
3.34k
469
3.83k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
3.34k
         
++I485
) {
471
485
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
485
          std::distance(Allocator.Slabs.begin(), I));
473
485
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
485
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr482
475
485
                                               : 
(char *)*I + AllocatedSlabSize3
;
476
485
477
485
      DestroyElements(Begin, End);
478
485
    }
479
3.34k
480
3.34k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
3.34k
486
3.34k
    Allocator.Reset();
487
3.34k
  }
MachineBlockPlacement.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::BlockChain>::DestroyAll()
Line
Count
Source
462
190k
  void DestroyAll() {
463
190k
    auto DestroyElements = [](char *Begin, char *End) {
464
190k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
190k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
190k
        reinterpret_cast<T *>(Ptr)->~T();
467
190k
    };
468
190k
469
371k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
190k
         
++I180k
) {
471
180k
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
180k
          std::distance(Allocator.Slabs.begin(), I));
473
180k
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
180k
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr170k
475
180k
                                               : 
(char *)*I + AllocatedSlabSize10.2k
;
476
180k
477
180k
      DestroyElements(Begin, End);
478
180k
    }
479
190k
480
190k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
190k
486
190k
    Allocator.Reset();
487
190k
  }
MachineOutliner.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::SuffixTreeNode>::DestroyAll()
Line
Count
Source
462
8.38k
  void DestroyAll() {
463
8.38k
    auto DestroyElements = [](char *Begin, char *End) {
464
8.38k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
8.38k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
8.38k
        reinterpret_cast<T *>(Ptr)->~T();
467
8.38k
    };
468
8.38k
469
16.7k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
8.39k
         ++I) {
471
8.39k
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
8.39k
          std::distance(Allocator.Slabs.begin(), I));
473
8.39k
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
8.39k
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr8.38k
475
8.39k
                                               : 
(char *)*I + AllocatedSlabSize14
;
476
8.39k
477
8.39k
      DestroyElements(Begin, End);
478
8.39k
    }
479
8.38k
480
8.38k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
8.38k
486
8.38k
    Allocator.Reset();
487
8.38k
  }
llvm::SpecificBumpPtrAllocator<llvm::PMTopLevelManager::AUFoldingSetNode>::DestroyAll()
Line
Count
Source
462
152k
  void DestroyAll() {
463
152k
    auto DestroyElements = [](char *Begin, char *End) {
464
152k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
152k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
152k
        reinterpret_cast<T *>(Ptr)->~T();
467
152k
    };
468
152k
469
433k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
281k
         ++I) {
471
281k
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
281k
          std::distance(Allocator.Slabs.begin(), I));
473
281k
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
281k
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr151k
475
281k
                                               : 
(char *)*I + AllocatedSlabSize130k
;
476
281k
477
281k
      DestroyElements(Begin, End);
478
281k
    }
479
152k
480
152k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
152k
486
152k
    Allocator.Reset();
487
152k
  }
llvm::SpecificBumpPtrAllocator<BasicBlockState>::DestroyAll()
Line
Count
Source
462
34
  void DestroyAll() {
463
34
    auto DestroyElements = [](char *Begin, char *End) {
464
34
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
34
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
34
        reinterpret_cast<T *>(Ptr)->~T();
467
34
    };
468
34
469
68
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
34
         ++I) {
471
34
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
34
          std::distance(Allocator.Slabs.begin(), I));
473
34
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
34
      char *End = *I == Allocator.Slabs.back() ? Allocator.CurPtr
475
34
                                               : 
(char *)*I + AllocatedSlabSize0
;
476
34
477
34
      DestroyElements(Begin, End);
478
34
    }
479
34
480
34
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
34
486
34
    Allocator.Reset();
487
34
  }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionWasm>::DestroyAll()
Line
Count
Source
462
53.7k
  void DestroyAll() {
463
53.7k
    auto DestroyElements = [](char *Begin, char *End) {
464
53.7k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
53.7k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
53.7k
        reinterpret_cast<T *>(Ptr)->~T();
467
53.7k
    };
468
53.7k
469
54.5k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
53.7k
         
++I874
) {
471
874
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
874
          std::distance(Allocator.Slabs.begin(), I));
473
874
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
874
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr437
475
874
                                               : 
(char *)*I + AllocatedSlabSize437
;
476
874
477
874
      DestroyElements(Begin, End);
478
874
    }
479
53.7k
480
53.7k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
53.7k
486
53.7k
    Allocator.Reset();
487
53.7k
  }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionCOFF>::DestroyAll()
Line
Count
Source
462
107k
  void DestroyAll() {
463
107k
    auto DestroyElements = [](char *Begin, char *End) {
464
107k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
107k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
107k
        reinterpret_cast<T *>(Ptr)->~T();
467
107k
    };
468
107k
469
112k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
107k
         
++I5.19k
) {
471
5.19k
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
5.19k
          std::distance(Allocator.Slabs.begin(), I));
473
5.19k
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
5.19k
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr2.59k
475
5.19k
                                               : 
(char *)*I + AllocatedSlabSize2.60k
;
476
5.19k
477
5.19k
      DestroyElements(Begin, End);
478
5.19k
    }
479
107k
480
107k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
107k
486
107k
    Allocator.Reset();
487
107k
  }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionELF>::DestroyAll()
Line
Count
Source
462
107k
  void DestroyAll() {
463
107k
    auto DestroyElements = [](char *Begin, char *End) {
464
107k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
107k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
107k
        reinterpret_cast<T *>(Ptr)->~T();
467
107k
    };
468
107k
469
239k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
131k
         ++I) {
471
131k
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
131k
          std::distance(Allocator.Slabs.begin(), I));
473
131k
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
131k
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr63.6k
475
131k
                                               : 
(char *)*I + AllocatedSlabSize68.3k
;
476
131k
477
131k
      DestroyElements(Begin, End);
478
131k
    }
479
107k
480
107k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
107k
486
107k
    Allocator.Reset();
487
107k
  }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionMachO>::DestroyAll()
Line
Count
Source
462
107k
  void DestroyAll() {
463
107k
    auto DestroyElements = [](char *Begin, char *End) {
464
107k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
107k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
107k
        reinterpret_cast<T *>(Ptr)->~T();
467
107k
    };
468
107k
469
174k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
107k
         
++I67.6k
) {
471
67.6k
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
67.6k
          std::distance(Allocator.Slabs.begin(), I));
473
67.6k
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
67.6k
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr33.8k
475
67.6k
                                               : 
(char *)*I + AllocatedSlabSize33.8k
;
476
67.6k
477
67.6k
      DestroyElements(Begin, End);
478
67.6k
    }
479
107k
480
107k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
107k
486
107k
    Allocator.Reset();
487
107k
  }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionXCOFF>::DestroyAll()
Line
Count
Source
462
107k
  void DestroyAll() {
463
107k
    auto DestroyElements = [](char *Begin, char *End) {
464
107k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
107k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
107k
        reinterpret_cast<T *>(Ptr)->~T();
467
107k
    };
468
107k
469
107k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
107k
         
++I16
) {
471
16
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
16
          std::distance(Allocator.Slabs.begin(), I));
473
16
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
16
      char *End = *I == Allocator.Slabs.back() ? Allocator.CurPtr
475
16
                                               : 
(char *)*I + AllocatedSlabSize0
;
476
16
477
16
      DestroyElements(Begin, End);
478
16
    }
479
107k
480
107k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
107k
486
107k
    Allocator.Reset();
487
107k
  }
llvm::SpecificBumpPtrAllocator<llvm::MCSubtargetInfo>::DestroyAll()
Line
Count
Source
462
107k
  void DestroyAll() {
463
107k
    auto DestroyElements = [](char *Begin, char *End) {
464
107k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
107k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
107k
        reinterpret_cast<T *>(Ptr)->~T();
467
107k
    };
468
107k
469
111k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
107k
         
++I4.13k
) {
471
4.13k
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
4.13k
          std::distance(Allocator.Slabs.begin(), I));
473
4.13k
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
4.13k
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr4.13k
475
4.13k
                                               : 
(char *)*I + AllocatedSlabSize7
;
476
4.13k
477
4.13k
      DestroyElements(Begin, End);
478
4.13k
    }
479
107k
480
107k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
107k
486
107k
    Allocator.Reset();
487
107k
  }
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTDeclContextNameLookupTrait>::Item>::DestroyAll()
Line
Count
Source
462
11.0k
  void DestroyAll() {
463
11.0k
    auto DestroyElements = [](char *Begin, char *End) {
464
11.0k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
11.0k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
11.0k
        reinterpret_cast<T *>(Ptr)->~T();
467
11.0k
    };
468
11.0k
469
22.1k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
11.1k
         ++I) {
471
11.1k
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
11.1k
          std::distance(Allocator.Slabs.begin(), I));
473
11.1k
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
11.1k
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr11.0k
475
11.1k
                                               : 
(char *)*I + AllocatedSlabSize12
;
476
11.1k
477
11.1k
      DestroyElements(Begin, End);
478
11.1k
    }
479
11.0k
480
11.0k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
11.0k
486
11.0k
    Allocator.Reset();
487
11.0k
  }
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::HeaderFileInfoTrait>::Item>::DestroyAll()
Line
Count
Source
462
3.61k
  void DestroyAll() {
463
3.61k
    auto DestroyElements = [](char *Begin, char *End) {
464
3.61k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
3.61k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
3.61k
        reinterpret_cast<T *>(Ptr)->~T();
467
3.61k
    };
468
3.61k
469
7.20k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
3.61k
         
++I3.58k
) {
471
3.58k
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
3.58k
          std::distance(Allocator.Slabs.begin(), I));
473
3.58k
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
3.58k
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr3.58k
475
3.58k
                                               : 
(char *)*I + AllocatedSlabSize6
;
476
3.58k
477
3.58k
      DestroyElements(Begin, End);
478
3.58k
    }
479
3.61k
480
3.61k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
3.61k
486
3.61k
    Allocator.Reset();
487
3.61k
  }
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTMethodPoolTrait>::Item>::DestroyAll()
Line
Count
Source
462
176
  void DestroyAll() {
463
176
    auto DestroyElements = [](char *Begin, char *End) {
464
176
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
176
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
176
        reinterpret_cast<T *>(Ptr)->~T();
467
176
    };
468
176
469
352
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
176
         ++I) {
471
176
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
176
          std::distance(Allocator.Slabs.begin(), I));
473
176
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
176
      char *End = *I == Allocator.Slabs.back() ? Allocator.CurPtr
475
176
                                               : 
(char *)*I + AllocatedSlabSize0
;
476
176
477
176
      DestroyElements(Begin, End);
478
176
    }
479
176
480
176
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
176
486
176
    Allocator.Reset();
487
176
  }
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTIdentifierTableTrait>::Item>::DestroyAll()
Line
Count
Source
462
3.61k
  void DestroyAll() {
463
3.61k
    auto DestroyElements = [](char *Begin, char *End) {
464
3.61k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
3.61k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
3.61k
        reinterpret_cast<T *>(Ptr)->~T();
467
3.61k
    };
468
3.61k
469
50.3k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
46.6k
         ++I) {
471
46.6k
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
46.6k
          std::distance(Allocator.Slabs.begin(), I));
473
46.6k
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
46.6k
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr3.61k
475
46.6k
                                               : 
(char *)*I + AllocatedSlabSize43.0k
;
476
46.6k
477
46.6k
      DestroyElements(Begin, End);
478
46.6k
    }
479
3.61k
480
3.61k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
3.61k
486
3.61k
    Allocator.Reset();
487
3.61k
  }
GlobalModuleIndex.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::IdentifierIndexWriterTrait>::Item>::DestroyAll()
Line
Count
Source
462
621
  void DestroyAll() {
463
621
    auto DestroyElements = [](char *Begin, char *End) {
464
621
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
621
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
621
        reinterpret_cast<T *>(Ptr)->~T();
467
621
    };
468
621
469
2.33k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
1.71k
         ++I) {
471
1.71k
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
1.71k
          std::distance(Allocator.Slabs.begin(), I));
473
1.71k
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
1.71k
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr619
475
1.71k
                                               : 
(char *)*I + AllocatedSlabSize1.09k
;
476
1.71k
477
1.71k
      DestroyElements(Begin, End);
478
1.71k
    }
479
621
480
621
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
621
486
621
    Allocator.Reset();
487
621
  }
llvm::SpecificBumpPtrAllocator<std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, unsigned int> >::DestroyAll()
Line
Count
Source
462
3.11k
  void DestroyAll() {
463
3.11k
    auto DestroyElements = [](char *Begin, char *End) {
464
3.11k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
3.11k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
3.11k
        reinterpret_cast<T *>(Ptr)->~T();
467
3.11k
    };
468
3.11k
469
3.17k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
3.11k
         
++I61
) {
471
61
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
61
          std::distance(Allocator.Slabs.begin(), I));
473
61
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
61
      char *End = *I == Allocator.Slabs.back() ? Allocator.CurPtr
475
61
                                               : 
(char *)*I + AllocatedSlabSize0
;
476
61
477
61
      DestroyElements(Begin, End);
478
61
    }
479
3.11k
480
3.11k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
3.11k
486
3.11k
    Allocator.Reset();
487
3.11k
  }
RecordLayoutBuilder.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::BaseSubobjectInfo>::DestroyAll()
Line
Count
Source
462
189k
  void DestroyAll() {
463
189k
    auto DestroyElements = [](char *Begin, char *End) {
464
189k
      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
465
189k
      for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
466
189k
        reinterpret_cast<T *>(Ptr)->~T();
467
189k
    };
468
189k
469
229k
    for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
470
189k
         
++I40.3k
) {
471
40.3k
      size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
472
40.3k
          std::distance(Allocator.Slabs.begin(), I));
473
40.3k
      char *Begin = (char *)alignAddr(*I, alignof(T));
474
40.3k
      char *End = *I == Allocator.Slabs.back() ? 
Allocator.CurPtr30.6k
475
40.3k
                                               : 
(char *)*I + AllocatedSlabSize9.73k
;
476
40.3k
477
40.3k
      DestroyElements(Begin, End);
478
40.3k
    }
479
189k
480
189k
    for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
481
0
      void *Ptr = PtrAndSize.first;
482
0
      size_t Size = PtrAndSize.second;
483
0
      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
484
0
    }
485
189k
486
189k
    Allocator.Reset();
487
189k
  }
488
489
  /// Allocate space for an array of objects without constructing them.
490
29.7M
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
llvm::SpecificBumpPtrAllocator<llvm::SmallVector<llvm::Register, 1u> >::Allocate(unsigned long)
Line
Count
Source
490
11.4M
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
llvm::SpecificBumpPtrAllocator<llvm::SmallVector<unsigned long long, 1u> >::Allocate(unsigned long)
Line
Count
Source
490
1.77M
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
llvm::SpecificBumpPtrAllocator<llvm::GCNIterativeScheduler::Region>::Allocate(unsigned long)
Line
Count
Source
490
8
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
GCNMinRegStrategy.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::GCNMinRegScheduler::Candidate>::Allocate(unsigned long)
Line
Count
Source
490
1.97k
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
GCNILPSched.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::GCNILPScheduler::Candidate>::Allocate(unsigned long)
Line
Count
Source
490
454
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
ARMLoadStoreOptimizer.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::ARMLoadStoreOpt::MergeCandidate>::Allocate(unsigned long)
Line
Count
Source
490
88.0k
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
HexagonCommonGEP.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::GepNode>::Allocate(unsigned long)
Line
Count
Source
490
3.03k
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::SCC>::Allocate(unsigned long)
Line
Count
Source
490
2.28k
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::RefSCC>::Allocate(unsigned long)
Line
Count
Source
490
2.21k
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
llvm::SpecificBumpPtrAllocator<llvm::LazyCallGraph::Node>::Allocate(unsigned long)
Line
Count
Source
490
2.38k
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
llvm::SpecificBumpPtrAllocator<llvm::DomainValue>::Allocate(unsigned long)
Line
Count
Source
490
230k
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
MachineBlockPlacement.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::BlockChain>::Allocate(unsigned long)
Line
Count
Source
490
2.71M
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
MachineOutliner.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::SuffixTreeNode>::Allocate(unsigned long)
Line
Count
Source
490
10.5k
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
llvm::SpecificBumpPtrAllocator<llvm::PMTopLevelManager::AUFoldingSetNode>::Allocate(unsigned long)
Line
Count
Source
490
3.99M
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
llvm::SpecificBumpPtrAllocator<BasicBlockState>::Allocate(unsigned long)
Line
Count
Source
490
75
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionMachO>::Allocate(unsigned long)
Line
Count
Source
490
890k
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionELF>::Allocate(unsigned long)
Line
Count
Source
490
2.16M
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionCOFF>::Allocate(unsigned long)
Line
Count
Source
490
62.2k
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionWasm>::Allocate(unsigned long)
Line
Count
Source
490
13.3k
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
llvm::SpecificBumpPtrAllocator<llvm::MCSectionXCOFF>::Allocate(unsigned long)
Line
Count
Source
490
17
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
llvm::SpecificBumpPtrAllocator<llvm::MCSubtargetInfo>::Allocate(unsigned long)
Line
Count
Source
490
2.70k
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::HeaderFileInfoTrait>::Item>::Allocate(unsigned long)
Line
Count
Source
490
5.69k
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTMethodPoolTrait>::Item>::Allocate(unsigned long)
Line
Count
Source
490
550
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTIdentifierTableTrait>::Item>::Allocate(unsigned long)
Line
Count
Source
490
5.65M
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
ASTWriter.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::ASTDeclContextNameLookupTrait>::Item>::Allocate(unsigned long)
Line
Count
Source
490
50.4k
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
GlobalModuleIndex.cpp:llvm::SpecificBumpPtrAllocator<llvm::OnDiskChainedHashTableGenerator<(anonymous namespace)::IdentifierIndexWriterTrait>::Item>::Allocate(unsigned long)
Line
Count
Source
490
89.8k
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
RecordLayoutBuilder.cpp:llvm::SpecificBumpPtrAllocator<(anonymous namespace)::BaseSubobjectInfo>::Allocate(unsigned long)
Line
Count
Source
490
572k
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
llvm::SpecificBumpPtrAllocator<std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, unsigned int> >::Allocate(unsigned long)
Line
Count
Source
490
240
  T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
491
};
492
493
} // end namespace llvm
494
495
template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold>
496
void *operator new(size_t Size,
497
                   llvm::BumpPtrAllocatorImpl<AllocatorT, SlabSize,
498
152M
                                              SizeThreshold> &Allocator) {
499
152M
  struct S {
500
152M
    char c;
501
152M
    union {
502
152M
      double D;
503
152M
      long double LD;
504
152M
      long long L;
505
152M
      void *P;
506
152M
    } x;
507
152M
  };
508
152M
  return Allocator.Allocate(
509
152M
      Size, std::min((size_t)llvm::NextPowerOf2(Size), offsetof(S, x)));
510
152M
}
511
512
template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold>
513
void operator delete(
514
    void *, llvm::BumpPtrAllocatorImpl<AllocatorT, SlabSize, SizeThreshold> &) {
515
}
516
517
#endif // LLVM_SUPPORT_ALLOCATOR_H