cpp

Coverage Report

Created: 2023-01-21 22:37

/home/andy/git/oilshell/oil/mycpp/gc_alloc.h
Line
Count
Source (jump to first uncovered line)
1
// gc_alloc.h: Functions that wrap gHeap.Allocate()
2
3
#ifndef MYCPP_GC_ALLOC_H
4
#define MYCPP_GC_ALLOC_H
5
6
#include <string.h>  // strlen
7
8
#include <new>      // placement new
9
#include <utility>  // std::forward
10
11
#include "mycpp/gc_slab.h"  // for NewSlab()
12
#include "mycpp/gc_str.h"   // for NewStr()
13
14
#if defined(BUMP_LEAK)
15
  #include "mycpp/bump_leak_heap.h"
16
extern BumpLeakHeap gHeap;
17
#elif defined(MARK_SWEEP)
18
  #include "mycpp/mark_sweep_heap.h"
19
extern MarkSweepHeap gHeap;
20
#elif defined(CHENEY_GC)
21
  #include "mycpp/cheney_heap.h"
22
extern CheneyHeap gHeap;
23
#endif
24
25
#define VALIDATE_ROOTS 0
26
27
// mycpp generates code that keeps track of the root set
28
class StackRoots {
29
 public:
30
  // Note: void** seems logical, because these are pointers to pointers, but
31
  // the C++ compiler doesn't like it.
32
109k
  StackRoots(std::initializer_list<void*> roots) {
33
109k
    n_ = roots.size();
34
35
#if VALIDATE_ROOTS
36
    int i = 0;
37
#endif
38
39
110k
    for (auto root : roots) {  // can't use roots[i]
40
41
#if VALIDATE_ROOTS
42
      RawObject* obj = *(reinterpret_cast<RawObject**>(root));
43
      if (obj) {
44
        RawObject* header = FindObjHeader(obj);
45
        log("obj %p header %p", obj, header);
46
47
        switch (header->heap_tag) {
48
        case HeapTag::Global:
49
        case HeapTag::Opaque:
50
        case HeapTag::Scanned:
51
        case HeapTag::FixedSize:
52
          break;
53
54
        default:
55
          log("root %d heap %d type %d mask %d len %d", i, header->heap_tag,
56
              header->type_tag, header->field_mask, header->obj_len);
57
          FAIL(kShouldNotGetHere);
58
          break;
59
        }
60
      }
61
      i++;
62
#endif
63
64
110k
      gHeap.PushRoot(reinterpret_cast<RawObject**>(root));
65
110k
    }
66
109k
  }
67
68
109k
  ~StackRoots() {
69
220k
    for (int i = 0; i < n_; ++i) {
70
110k
      gHeap.PopRoot();
71
110k
    }
72
109k
  }
73
74
 private:
75
  int n_;
76
};
77
78
// Note:
79
// - This function causes code bloat due to template expansion on hundreds of
80
//   types.  Could switch to a GC_NEW() macro
81
// - GCC generates slightly larger code if you factor out void* place and new
82
//   (place) T()
83
//
84
// Variadic templates:
85
// https://eli.thegreenplace.net/2014/variadic-templates-in-c/
86
template <typename T, typename... Args>
87
1.49k
T* Alloc(Args&&... args) {
88
1.49k
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1.49k
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1.49k
  int obj_id = gHeap.UnusedObjectId();
95
1.49k
#endif
96
97
1.49k
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1.49k
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1.49k
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1.49k
  header->obj_id = obj_id;
103
1.49k
#endif
104
1.49k
  return obj;
105
1.49k
}
_Z5AllocIN5mylib15CFileLineReaderEJRP8_IO_FILEEEPT_DpOT0_
Line
Count
Source
87
8
T* Alloc(Args&&... args) {
88
8
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
8
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
8
  int obj_id = gHeap.UnusedObjectId();
95
8
#endif
96
97
8
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
8
#if MARK_SWEEP
100
  // Hack for now: find the header
101
8
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
8
  header->obj_id = obj_id;
103
8
#endif
104
8
  return obj;
105
8
}
_Z5AllocI10ValueErrorJEEPT_DpOT0_
Line
Count
Source
87
13
T* Alloc(Args&&... args) {
88
13
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
13
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
13
  int obj_id = gHeap.UnusedObjectId();
95
13
#endif
96
97
13
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
13
#if MARK_SWEEP
100
  // Hack for now: find the header
101
13
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
13
  header->obj_id = obj_id;
103
13
#endif
104
13
  return obj;
105
13
}
_Z5AllocI7IOErrorJRiEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocI4ListIP3StrEJEEPT_DpOT0_
Line
Count
Source
87
148
T* Alloc(Args&&... args) {
88
148
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
148
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
148
  int obj_id = gHeap.UnusedObjectId();
95
148
#endif
96
97
148
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
148
#if MARK_SWEEP
100
  // Hack for now: find the header
101
148
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
148
  header->obj_id = obj_id;
103
148
#endif
104
148
  return obj;
105
148
}
_Z5AllocIN14asdl_generated17arith_expr__ConstEJiEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
Unexecuted instantiation: _Z5AllocIN14asdl_generated17arith_expr__ConstEJRiEEPT_DpOT0_
_Z5AllocI4DictIP3StrS2_EJEEPT_DpOT0_
Line
Count
Source
87
9
T* Alloc(Args&&... args) {
88
9
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
9
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
9
  int obj_id = gHeap.UnusedObjectId();
95
9
#endif
96
97
9
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
9
#if MARK_SWEEP
100
  // Hack for now: find the header
101
9
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
9
  header->obj_id = obj_id;
103
9
#endif
104
9
  return obj;
105
9
}
_Z5AllocIN10classes_gc6OpaqueEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN10classes_gc10OpaqueBaseEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN10classes_gc13OpaqueDerivedEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN10classes_gc8PointersEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN10classes_gc12PointersBaseEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN10classes_gc15PointersDerivedEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN10classes_gc14BaseWithMethodEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN10classes_gc17DerivedWithMethodEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN10classes_gc8WithDictEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
Unexecuted instantiation: _Z5AllocI8KeyErrorJEEPT_DpOT0_
_Z5AllocIN10classes_gc6PrintfEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
Unexecuted instantiation: _Z5AllocI4ListIPN10classes_gc10OpaqueBaseEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN10classes_gc12PointersBaseEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN10classes_gc14BaseWithMethodEEJEEPT_DpOT0_
_Z5AllocIN5mylib11CFileWriterEJRP8_IO_FILEEEPT_DpOT0_
Line
Count
Source
87
9
T* Alloc(Args&&... args) {
88
9
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
9
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
9
  int obj_id = gHeap.UnusedObjectId();
95
9
#endif
96
97
9
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
9
#if MARK_SWEEP
100
  // Hack for now: find the header
101
9
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
9
  header->obj_id = obj_id;
103
9
#endif
104
9
  return obj;
105
9
}
_Z5AllocIN7classes10TextOutputEJRPN5mylib6WriterEEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN7classes4BaseEJDnEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN7classes8DerivedIEJDniEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN7classes9DerivedSSEJDnRP3StrS4_EEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN5mylib9BufWriterEJEEPT_DpOT0_
Line
Count
Source
87
41
T* Alloc(Args&&... args) {
88
41
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
41
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
41
  int obj_id = gHeap.UnusedObjectId();
95
41
#endif
96
97
41
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
41
#if MARK_SWEEP
100
  // Hack for now: find the header
101
41
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
41
  header->obj_id = obj_id;
103
41
#endif
104
41
  return obj;
105
41
}
Unexecuted instantiation: _Z5AllocIN7classes10TextOutputEJRPN5mylib9BufWriterEEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocIN7classes4NodeEJDniEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocIN7classes4NodeEJRPS1_RiEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocIN7classes8DerivedIEJRPNS0_4BaseERiEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocIN7classes9DerivedSSEJRPNS0_8DerivedIERP3StrS7_EEPT_DpOT0_
Unexecuted instantiation: _Z5AllocIN7classes4BaseEJRPNS0_9DerivedSSEEEPT_DpOT0_
_Z5AllocI4ListIiEJEEPT_DpOT0_
Line
Count
Source
87
654
T* Alloc(Args&&... args) {
88
654
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
654
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
654
  int obj_id = gHeap.UnusedObjectId();
95
654
#endif
96
97
654
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
654
#if MARK_SWEEP
100
  // Hack for now: find the header
101
654
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
654
  header->obj_id = obj_id;
103
654
#endif
104
654
  return obj;
105
654
}
_Z5AllocI6Tuple2IiP3StrEJiRS2_EEPT_DpOT0_
Line
Count
Source
87
9
T* Alloc(Args&&... args) {
88
9
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
9
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
9
  int obj_id = gHeap.UnusedObjectId();
95
9
#endif
96
97
9
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
9
#if MARK_SWEEP
100
  // Hack for now: find the header
101
9
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
9
  header->obj_id = obj_id;
103
9
#endif
104
9
  return obj;
105
9
}
_Z5AllocIN10containers5PointEJiiEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocI4DictIP3StriEJEEPT_DpOT0_
Line
Count
Source
87
17
T* Alloc(Args&&... args) {
88
17
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
17
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
17
  int obj_id = gHeap.UnusedObjectId();
95
17
#endif
96
97
17
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
17
#if MARK_SWEEP
100
  // Hack for now: find the header
101
17
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
17
  header->obj_id = obj_id;
103
17
#endif
104
17
  return obj;
105
17
}
_Z5AllocIN12control_flow10ParseErrorEJRP3StrEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocI6Tuple2IiP3StrEJRiS2_EEPT_DpOT0_
Line
Count
Source
87
11
T* Alloc(Args&&... args) {
88
11
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
11
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
11
  int obj_id = gHeap.UnusedObjectId();
95
11
#endif
96
97
11
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
11
#if MARK_SWEEP
100
  // Hack for now: find the header
101
11
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
11
  header->obj_id = obj_id;
103
11
#endif
104
11
  return obj;
105
11
}
_Z5AllocI13StopIterationJEEPT_DpOT0_
Line
Count
Source
87
3
T* Alloc(Args&&... args) {
88
3
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
3
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
3
  int obj_id = gHeap.UnusedObjectId();
95
3
#endif
96
97
3
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
3
#if MARK_SWEEP
100
  // Hack for now: find the header
101
3
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
3
  header->obj_id = obj_id;
103
3
#endif
104
3
  return obj;
105
3
}
_Z5AllocIN9iterators3FooEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocI6Tuple2IP3StriEJRS2_iEEPT_DpOT0_
Line
Count
Source
87
3
T* Alloc(Args&&... args) {
88
3
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
3
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
3
  int obj_id = gHeap.UnusedObjectId();
95
3
#endif
96
97
3
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
3
#if MARK_SWEEP
100
  // Hack for now: find the header
101
3
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
3
  header->obj_id = obj_id;
103
3
#endif
104
3
  return obj;
105
3
}
_Z5AllocI4ListIP6Tuple2IP3StriEEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocI4ListIP6Tuple2IiP3StrEEJEEPT_DpOT0_
Line
Count
Source
87
5
T* Alloc(Args&&... args) {
88
5
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
5
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
5
  int obj_id = gHeap.UnusedObjectId();
95
5
#endif
96
97
5
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
5
#if MARK_SWEEP
100
  // Hack for now: find the header
101
5
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
5
  header->obj_id = obj_id;
103
5
#endif
104
5
  return obj;
105
5
}
_Z5AllocIN7modules3DogEJRP3StrEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN7module13CatEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN7modules6SphinxEJRP3StrEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocI4ListIPN10hnode_asdl5fieldEEJEEPT_DpOT0_
Line
Count
Source
87
34
T* Alloc(Args&&... args) {
88
34
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
34
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
34
  int obj_id = gHeap.UnusedObjectId();
95
34
#endif
96
97
34
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
34
#if MARK_SWEEP
100
  // Hack for now: find the header
101
34
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
34
  header->obj_id = obj_id;
103
34
#endif
104
34
  return obj;
105
34
}
_Z5AllocI4ListIPN10hnode_asdl7hnode_tEEJEEPT_DpOT0_
Line
Count
Source
87
34
T* Alloc(Args&&... args) {
88
34
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
34
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
34
  int obj_id = gHeap.UnusedObjectId();
95
34
#endif
96
97
34
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
34
#if MARK_SWEEP
100
  // Hack for now: find the header
101
34
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
34
  header->obj_id = obj_id;
103
34
#endif
104
34
  return obj;
105
34
}
_Z5AllocIN10hnode_asdl13hnode__RecordEJRP3StrP4ListIPNS0_5fieldEEbS4_S4_PS5_IPNS0_7hnode_tEEEEPT_DpOT0_
Line
Count
Source
87
34
T* Alloc(Args&&... args) {
88
34
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
34
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
34
  int obj_id = gHeap.UnusedObjectId();
95
34
#endif
96
97
34
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
34
#if MARK_SWEEP
100
  // Hack for now: find the header
101
34
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
34
  header->obj_id = obj_id;
103
34
#endif
104
34
  return obj;
105
34
}
Unexecuted instantiation: _Z5AllocIN10hnode_asdl11hnode__LeafEJRP3StrNS0_7color_eEEEPT_DpOT0_
_Z5AllocIN10hnode_asdl11hnode__LeafEJRP3StrRNS0_7color_eEEEPT_DpOT0_
Line
Count
Source
87
20
T* Alloc(Args&&... args) {
88
20
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
20
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
20
  int obj_id = gHeap.UnusedObjectId();
95
20
#endif
96
97
20
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
20
#if MARK_SWEEP
100
  // Hack for now: find the header
101
20
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
20
  header->obj_id = obj_id;
103
20
#endif
104
20
  return obj;
105
20
}
Unexecuted instantiation: _Z5AllocIN6format10AnsiOutputEJRPN5mylib6WriterEEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocIN6format10TextOutputEJRPN5mylib6WriterEEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocIN6format10TextOutputEJPN5mylib9BufWriterEEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocIN6format10HtmlOutputEJPN5mylib9BufWriterEEEPT_DpOT0_
_Z5AllocIN6format10AnsiOutputEJPN5mylib9BufWriterEEEPT_DpOT0_
Line
Count
Source
87
31
T* Alloc(Args&&... args) {
88
31
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
31
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
31
  int obj_id = gHeap.UnusedObjectId();
95
31
#endif
96
97
31
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
31
#if MARK_SWEEP
100
  // Hack for now: find the header
101
31
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
31
  header->obj_id = obj_id;
103
31
#endif
104
31
  return obj;
105
31
}
_Z5AllocI6Tuple2IP3StriEJRS2_RiEEPT_DpOT0_
Line
Count
Source
87
22
T* Alloc(Args&&... args) {
88
22
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
22
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
22
  int obj_id = gHeap.UnusedObjectId();
95
22
#endif
96
97
22
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
22
#if MARK_SWEEP
100
  // Hack for now: find the header
101
22
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
22
  header->obj_id = obj_id;
103
22
#endif
104
22
  return obj;
105
22
}
_Z5AllocIN6format14_PrettyPrinterEJiEEPT_DpOT0_
Line
Count
Source
87
8
T* Alloc(Args&&... args) {
88
8
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
8
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
8
  int obj_id = gHeap.UnusedObjectId();
95
8
#endif
96
97
8
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
8
#if MARK_SWEEP
100
  // Hack for now: find the header
101
8
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
8
  header->obj_id = obj_id;
103
8
#endif
104
8
  return obj;
105
8
}
_Z5AllocIN5parse10ParseErrorEJP3StrEEPT_DpOT0_
Line
Count
Source
87
5
T* Alloc(Args&&... args) {
88
5
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
5
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
5
  int obj_id = gHeap.UnusedObjectId();
95
5
#endif
96
97
5
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
5
#if MARK_SWEEP
100
  // Hack for now: find the header
101
5
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
5
  header->obj_id = obj_id;
103
5
#endif
104
5
  return obj;
105
5
}
_Z5AllocIN9expr_asdl9expr__VarEJRP3StrEEPT_DpOT0_
Line
Count
Source
87
9
T* Alloc(Args&&... args) {
88
9
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
9
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
9
  int obj_id = gHeap.UnusedObjectId();
95
9
#endif
96
97
9
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
9
#if MARK_SWEEP
100
  // Hack for now: find the header
101
9
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
9
  header->obj_id = obj_id;
103
9
#endif
104
9
  return obj;
105
9
}
_Z5AllocIN9expr_asdl11expr__ConstEJiEEPT_DpOT0_
Line
Count
Source
87
14
T* Alloc(Args&&... args) {
88
14
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
14
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
14
  int obj_id = gHeap.UnusedObjectId();
95
14
#endif
96
97
14
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
14
#if MARK_SWEEP
100
  // Hack for now: find the header
101
14
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
14
  header->obj_id = obj_id;
103
14
#endif
104
14
  return obj;
105
14
}
_Z5AllocIN9expr_asdl12expr__BinaryEJRP3StrRPNS0_6expr_tES7_EEPT_DpOT0_
Line
Count
Source
87
14
T* Alloc(Args&&... args) {
88
14
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
14
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
14
  int obj_id = gHeap.UnusedObjectId();
95
14
#endif
96
97
14
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
14
#if MARK_SWEEP
100
  // Hack for now: find the header
101
14
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
14
  header->obj_id = obj_id;
103
14
#endif
104
14
  return obj;
105
14
}
_Z5AllocIN5parse5LexerEJRP3StrEEPT_DpOT0_
Line
Count
Source
87
14
T* Alloc(Args&&... args) {
88
14
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
14
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
14
  int obj_id = gHeap.UnusedObjectId();
95
14
#endif
96
97
14
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
14
#if MARK_SWEEP
100
  // Hack for now: find the header
101
14
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
14
  header->obj_id = obj_id;
103
14
#endif
104
14
  return obj;
105
14
}
_Z5AllocIN5parse6ParserEJRPNS0_5LexerEEEPT_DpOT0_
Line
Count
Source
87
13
T* Alloc(Args&&... args) {
88
13
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
13
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
13
  int obj_id = gHeap.UnusedObjectId();
95
13
#endif
96
97
13
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
13
#if MARK_SWEEP
100
  // Hack for now: find the header
101
13
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
13
  header->obj_id = obj_id;
103
13
#endif
104
13
  return obj;
105
13
}
_Z5AllocIN6format10AnsiOutputEJPN5mylib6WriterEEEPT_DpOT0_
Line
Count
Source
87
8
T* Alloc(Args&&... args) {
88
8
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
8
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
8
  int obj_id = gHeap.UnusedObjectId();
95
8
#endif
96
97
8
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
8
#if MARK_SWEEP
100
  // Hack for now: find the header
101
8
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
8
  header->obj_id = obj_id;
103
8
#endif
104
8
  return obj;
105
8
}
_Z5AllocIN10hnode_asdl11hnode__LeafEJP3StrNS0_7color_eEEEPT_DpOT0_
Line
Count
Source
87
14
T* Alloc(Args&&... args) {
88
14
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
14
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
14
  int obj_id = gHeap.UnusedObjectId();
95
14
#endif
96
97
14
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
14
#if MARK_SWEEP
100
  // Hack for now: find the header
101
14
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
14
  header->obj_id = obj_id;
103
14
#endif
104
14
  return obj;
105
14
}
_Z5AllocIN10hnode_asdl5fieldEJP3StrRPNS0_7hnode_tEEEPT_DpOT0_
Line
Count
Source
87
60
T* Alloc(Args&&... args) {
88
60
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
60
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
60
  int obj_id = gHeap.UnusedObjectId();
95
60
#endif
96
97
60
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
60
#if MARK_SWEEP
100
  // Hack for now: find the header
101
60
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
60
  header->obj_id = obj_id;
103
60
#endif
104
60
  return obj;
105
60
}
_Z5AllocIN15scoped_resource7MyErrorEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN15scoped_resource8DirStackEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocI4ListIbEJEEPT_DpOT0_
Line
Count
Source
87
3
T* Alloc(Args&&... args) {
88
3
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
3
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
3
  int obj_id = gHeap.UnusedObjectId();
95
3
#endif
96
97
3
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
3
#if MARK_SWEEP
100
  // Hack for now: find the header
101
3
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
3
  header->obj_id = obj_id;
103
3
#endif
104
3
  return obj;
105
3
}
_Z5AllocIN7strings3FooEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN9test_cast11ColorOutputEJRPN5mylib9BufWriterEEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocI6Tuple2IP3StriEJS2_iEEPT_DpOT0_
Line
Count
Source
87
6
T* Alloc(Args&&... args) {
88
6
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
6
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
6
  int obj_id = gHeap.UnusedObjectId();
95
6
#endif
96
97
6
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
6
#if MARK_SWEEP
100
  // Hack for now: find the header
101
6
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
6
  header->obj_id = obj_id;
103
6
#endif
104
6
  return obj;
105
6
}
_Z5AllocI10ValueErrorJRP3StrEEPT_DpOT0_
Line
Count
Source
87
2
T* Alloc(Args&&... args) {
88
2
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
2
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
2
  int obj_id = gHeap.UnusedObjectId();
95
2
#endif
96
97
2
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
2
#if MARK_SWEEP
100
  // Hack for now: find the header
101
2
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
2
  header->obj_id = obj_id;
103
2
#endif
104
2
  return obj;
105
2
}
_Z5AllocI10IndexErrorJEEPT_DpOT0_
Line
Count
Source
87
2
T* Alloc(Args&&... args) {
88
2
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
2
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
2
  int obj_id = gHeap.UnusedObjectId();
95
2
#endif
96
97
2
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
2
#if MARK_SWEEP
100
  // Hack for now: find the header
101
2
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
2
  header->obj_id = obj_id;
103
2
#endif
104
2
  return obj;
105
2
}
_Z5AllocI7OSErrorJiEEPT_DpOT0_
Line
Count
Source
87
2
T* Alloc(Args&&... args) {
88
2
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
2
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
2
  int obj_id = gHeap.UnusedObjectId();
95
2
#endif
96
97
2
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
2
#if MARK_SWEEP
100
  // Hack for now: find the header
101
2
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
2
  header->obj_id = obj_id;
103
2
#endif
104
2
  return obj;
105
2
}
_Z5AllocI12RuntimeErrorJRP3StrEEPT_DpOT0_
Line
Count
Source
87
2
T* Alloc(Args&&... args) {
88
2
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
2
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
2
  int obj_id = gHeap.UnusedObjectId();
95
2
#endif
96
97
2
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
2
#if MARK_SWEEP
100
  // Hack for now: find the header
101
2
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
2
  header->obj_id = obj_id;
103
2
#endif
104
2
  return obj;
105
2
}
_Z5AllocI12UnicodeErrorJP3StrEEPT_DpOT0_
Line
Count
Source
87
2
T* Alloc(Args&&... args) {
88
2
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
2
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
2
  int obj_id = gHeap.UnusedObjectId();
95
2
#endif
96
97
2
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
2
#if MARK_SWEEP
100
  // Hack for now: find the header
101
2
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
2
  header->obj_id = obj_id;
103
2
#endif
104
2
  return obj;
105
2
}
_Z5AllocI7IOErrorJiEEPT_DpOT0_
Line
Count
Source
87
2
T* Alloc(Args&&... args) {
88
2
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
2
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
2
  int obj_id = gHeap.UnusedObjectId();
95
2
#endif
96
97
2
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
2
#if MARK_SWEEP
100
  // Hack for now: find the header
101
2
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
2
  header->obj_id = obj_id;
103
2
#endif
104
2
  return obj;
105
2
}
_Z5AllocI4DictIiP3StrEJEEPT_DpOT0_
Line
Count
Source
87
8
T* Alloc(Args&&... args) {
88
8
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
8
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
8
  int obj_id = gHeap.UnusedObjectId();
95
8
#endif
96
97
8
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
8
#if MARK_SWEEP
100
  // Hack for now: find the header
101
8
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
8
  header->obj_id = obj_id;
103
8
#endif
104
8
  return obj;
105
8
}
_Z5AllocI4DictIiiEJEEPT_DpOT0_
Line
Count
Source
87
2
T* Alloc(Args&&... args) {
88
2
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
2
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
2
  int obj_id = gHeap.UnusedObjectId();
95
2
#endif
96
97
2
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
2
#if MARK_SWEEP
100
  // Hack for now: find the header
101
2
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
2
  header->obj_id = obj_id;
103
2
#endif
104
2
  return obj;
105
2
}
_Z5AllocI5PointJiiEEPT_DpOT0_
Line
Count
Source
87
4
T* Alloc(Args&&... args) {
88
4
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
4
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
4
  int obj_id = gHeap.UnusedObjectId();
95
4
#endif
96
97
4
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
4
#if MARK_SWEEP
100
  // Hack for now: find the header
101
4
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
4
  header->obj_id = obj_id;
103
4
#endif
104
4
  return obj;
105
4
}
_Z5AllocI4LineJEEPT_DpOT0_
Line
Count
Source
87
2
T* Alloc(Args&&... args) {
88
2
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
2
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
2
  int obj_id = gHeap.UnusedObjectId();
95
2
#endif
96
97
2
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
2
#if MARK_SWEEP
100
  // Hack for now: find the header
101
2
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
2
  header->obj_id = obj_id;
103
2
#endif
104
2
  return obj;
105
2
}
_Z5AllocI10DerivedObjJEEPT_DpOT0_
Line
Count
Source
87
2
T* Alloc(Args&&... args) {
88
2
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
2
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
2
  int obj_id = gHeap.UnusedObjectId();
95
2
#endif
96
97
2
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
2
#if MARK_SWEEP
100
  // Hack for now: find the header
101
2
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
2
  header->obj_id = obj_id;
103
2
#endif
104
2
  return obj;
105
2
}
_Z5AllocI4ListIdEJEEPT_DpOT0_
Line
Count
Source
87
2
T* Alloc(Args&&... args) {
88
2
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
2
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
2
  int obj_id = gHeap.UnusedObjectId();
95
2
#endif
96
97
2
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
2
#if MARK_SWEEP
100
  // Hack for now: find the header
101
2
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
2
  header->obj_id = obj_id;
103
2
#endif
104
2
  return obj;
105
2
}
_Z5AllocIN5mylib13BufLineReaderEJRP3StrEEPT_DpOT0_
Line
Count
Source
87
2
T* Alloc(Args&&... args) {
88
2
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
2
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
2
  int obj_id = gHeap.UnusedObjectId();
95
2
#endif
96
97
2
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
2
#if MARK_SWEEP
100
  // Hack for now: find the header
101
2
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
2
  header->obj_id = obj_id;
103
2
#endif
104
2
  return obj;
105
2
}
_Z5AllocI6Tuple2IiiEJiiEEPT_DpOT0_
Line
Count
Source
87
7
T* Alloc(Args&&... args) {
88
7
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
7
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
7
  int obj_id = gHeap.UnusedObjectId();
95
7
#endif
96
97
7
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
7
#if MARK_SWEEP
100
  // Hack for now: find the header
101
7
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
7
  header->obj_id = obj_id;
103
7
#endif
104
7
  return obj;
105
7
}
_Z5AllocI6Tuple2IiP3StrEJiS2_EEPT_DpOT0_
Line
Count
Source
87
7
T* Alloc(Args&&... args) {
88
7
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
7
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
7
  int obj_id = gHeap.UnusedObjectId();
95
7
#endif
96
97
7
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
7
#if MARK_SWEEP
100
  // Hack for now: find the header
101
7
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
7
  header->obj_id = obj_id;
103
7
#endif
104
7
  return obj;
105
7
}
_Z5AllocI6Tuple3IiP3StrS2_EJiS2_S2_EEPT_DpOT0_
Line
Count
Source
87
2
T* Alloc(Args&&... args) {
88
2
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
2
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
2
  int obj_id = gHeap.UnusedObjectId();
95
2
#endif
96
97
2
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
2
#if MARK_SWEEP
100
  // Hack for now: find the header
101
2
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
2
  header->obj_id = obj_id;
103
2
#endif
104
2
  return obj;
105
2
}
_Z5AllocI6Tuple4IiP3StrS2_iEJiS2_S2_iEEPT_DpOT0_
Line
Count
Source
87
2
T* Alloc(Args&&... args) {
88
2
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
2
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
2
  int obj_id = gHeap.UnusedObjectId();
95
2
#endif
96
97
2
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
2
#if MARK_SWEEP
100
  // Hack for now: find the header
101
2
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
2
  header->obj_id = obj_id;
103
2
#endif
104
2
  return obj;
105
2
}
_Z5AllocI6Tuple2IiPS0_IiP3StrEEJiRS4_EEPT_DpOT0_
Line
Count
Source
87
2
T* Alloc(Args&&... args) {
88
2
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
2
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
2
  int obj_id = gHeap.UnusedObjectId();
95
2
#endif
96
97
2
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
2
#if MARK_SWEEP
100
  // Hack for now: find the header
101
2
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
2
  header->obj_id = obj_id;
103
2
#endif
104
2
  return obj;
105
2
}
_Z5AllocI4NodeJEEPT_DpOT0_
Line
Count
Source
87
4
T* Alloc(Args&&... args) {
88
4
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
4
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
4
  int obj_id = gHeap.UnusedObjectId();
95
4
#endif
96
97
4
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
4
#if MARK_SWEEP
100
  // Hack for now: find the header
101
4
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
4
  header->obj_id = obj_id;
103
4
#endif
104
4
  return obj;
105
4
}
_Z5AllocIN5error5UsageEJP3StriEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN4pyos9ReadErrorEJiEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocI7OSErrorJRiEEPT_DpOT0_
Line
Count
Source
87
4
T* Alloc(Args&&... args) {
88
4
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
4
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
4
  int obj_id = gHeap.UnusedObjectId();
95
4
#endif
96
97
4
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
4
#if MARK_SWEEP
100
  // Hack for now: find the header
101
4
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
4
  header->obj_id = obj_id;
103
4
#endif
104
4
  return obj;
105
4
}
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl13compound_wordEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl11word_part_tEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl9command_tEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl6word_tEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl5redirEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl8env_pairEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl11assign_pairEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl6if_armEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl8case_armEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl9name_typeEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl12place_expr_tEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl5paramEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl11type_expr_tEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl7variantEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl12class_item_tEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl11import_nameEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl12UntypedParamEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl10TypedParamEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl5TokenEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl5speckEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl6expr_tEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl13comprehensionEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl20class_literal_term_tEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl17char_class_term_tEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl4re_tEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl9named_argEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN11syntax_asdl11string_lineEEJEEPT_DpOT0_
_Z5AllocI4ListIPN4pyos11PasswdEntryEEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN4pyos11PasswdEntryEJRP6passwdEEPT_DpOT0_
Line
Count
Source
87
75
T* Alloc(Args&&... args) {
88
75
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
75
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
75
  int obj_id = gHeap.UnusedObjectId();
95
75
#endif
96
97
75
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
75
#if MARK_SWEEP
100
  // Hack for now: find the header
101
75
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
75
  header->obj_id = obj_id;
103
75
#endif
104
75
  return obj;
105
75
}
_Z5AllocIN4pyos13SignalHandlerEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN6pyutil15_ResourceLoaderEJEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
_Z5AllocIN5error12FatalRuntimeEJRP3StrEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
Unexecuted instantiation: _Z5AllocIN5error5ParseEJRP3StrRiEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocIN5error5ParseEJRP3StrRPN11syntax_asdl5TokenEEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocIN5error5ParseEJRP3StrRPN11syntax_asdl11word_part_tEEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocIN5error5ParseEJRP3StrRPN11syntax_asdl6word_tEEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocIN5error12FatalRuntimeEJRiRP3StrEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocIN5error6StrictEJRP3StrEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocIN5error5UsageEJRP3StriEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocIN5error5UsageEJRP3StrRiEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocIN10hnode_asdl12hnode__ArrayEJP4ListIPNS0_7hnode_tEEEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocIN10hnode_asdl5fieldEJP3StrRPNS0_12hnode__ArrayEEEPT_DpOT0_
_Z5AllocIN5match11SimpleLexerEJPFvPKhiiPiS4_ERP3StrEEPT_DpOT0_
Line
Count
Source
87
4
T* Alloc(Args&&... args) {
88
4
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
4
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
4
  int obj_id = gHeap.UnusedObjectId();
95
4
#endif
96
97
4
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
4
#if MARK_SWEEP
100
  // Hack for now: find the header
101
4
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
4
  header->obj_id = obj_id;
103
4
#endif
104
4
  return obj;
105
4
}
Unexecuted instantiation: _Z5AllocI12RuntimeErrorJP3StrEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN12runtime_asdl10assign_argEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN12runtime_asdl12part_value_tEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4ListIPN12runtime_asdl7value_tEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocI4DictIP3StrPN12runtime_asdl8hay_nodeEEJEEPT_DpOT0_
Unexecuted instantiation: _Z5AllocIN10hnode_asdl15hnode__ExternalEJRPvEEPT_DpOT0_
_Z5AllocIN9flag_spec16_FlagSpecAndMoreEJEEPT_DpOT0_
Line
Count
Source
87
2
T* Alloc(Args&&... args) {
88
2
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
2
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
2
  int obj_id = gHeap.UnusedObjectId();
95
2
#endif
96
97
2
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
2
#if MARK_SWEEP
100
  // Hack for now: find the header
101
2
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
2
  header->obj_id = obj_id;
103
2
#endif
104
2
  return obj;
105
2
}
_Z5AllocIN9flag_spec9_FlagSpecEJEEPT_DpOT0_
Line
Count
Source
87
3
T* Alloc(Args&&... args) {
88
3
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
3
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
3
  int obj_id = gHeap.UnusedObjectId();
95
3
#endif
96
97
3
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
3
#if MARK_SWEEP
100
  // Hack for now: find the header
101
3
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
3
  header->obj_id = obj_id;
103
3
#endif
104
3
  return obj;
105
3
}
_Z5AllocIN12runtime_asdl11value__BoolEJRbEEPT_DpOT0_
Line
Count
Source
87
19
T* Alloc(Args&&... args) {
88
19
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
19
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
19
  int obj_id = gHeap.UnusedObjectId();
95
19
#endif
96
97
19
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
19
#if MARK_SWEEP
100
  // Hack for now: find the header
101
19
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
19
  header->obj_id = obj_id;
103
19
#endif
104
19
  return obj;
105
19
}
_Z5AllocIN12runtime_asdl10value__IntEJRiEEPT_DpOT0_
Line
Count
Source
87
1
T* Alloc(Args&&... args) {
88
1
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
1
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
1
  int obj_id = gHeap.UnusedObjectId();
95
1
#endif
96
97
1
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
1
#if MARK_SWEEP
100
  // Hack for now: find the header
101
1
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
1
  header->obj_id = obj_id;
103
1
#endif
104
1
  return obj;
105
1
}
Unexecuted instantiation: _Z5AllocIN12runtime_asdl12value__FloatEJRfEEPT_DpOT0_
_Z5AllocIN12runtime_asdl12value__UndefEJEEPT_DpOT0_
Line
Count
Source
87
7
T* Alloc(Args&&... args) {
88
7
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
7
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
7
  int obj_id = gHeap.UnusedObjectId();
95
7
#endif
96
97
7
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
7
#if MARK_SWEEP
100
  // Hack for now: find the header
101
7
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
7
  header->obj_id = obj_id;
103
7
#endif
104
7
  return obj;
105
7
}
_Z5AllocIN12runtime_asdl10value__StrEJP3StrEEPT_DpOT0_
Line
Count
Source
87
2
T* Alloc(Args&&... args) {
88
2
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
2
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
2
  int obj_id = gHeap.UnusedObjectId();
95
2
#endif
96
97
2
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
2
#if MARK_SWEEP
100
  // Hack for now: find the header
101
2
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
2
  header->obj_id = obj_id;
103
2
#endif
104
2
  return obj;
105
2
}
_Z5AllocI4DictIP3StrPN4args7_ActionEEJEEPT_DpOT0_
Line
Count
Source
87
6
T* Alloc(Args&&... args) {
88
6
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
6
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
6
  int obj_id = gHeap.UnusedObjectId();
95
6
#endif
96
97
6
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
6
#if MARK_SWEEP
100
  // Hack for now: find the header
101
6
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
6
  header->obj_id = obj_id;
103
6
#endif
104
6
  return obj;
105
6
}
_Z5AllocI4DictIP3StrPN12runtime_asdl7value_tEEJEEPT_DpOT0_
Line
Count
Source
87
3
T* Alloc(Args&&... args) {
88
3
  DCHECK(gHeap.is_initialized_);
89
90
0
  void* place = gHeap.Allocate(sizeof(T));
91
3
#if MARK_SWEEP
92
  // IMPORTANT: save the object ID before calling placement new, which can
93
  // invoke Allocate() again!
94
3
  int obj_id = gHeap.UnusedObjectId();
95
3
#endif
96
97
3
  T* obj = new (place) T(std::forward<Args>(args)...);
98
99
3
#if MARK_SWEEP
100
  // Hack for now: find the header
101
3
  ObjHeader* header = FindObjHeader(reinterpret_cast<RawObject*>(obj));
102
3
  header->obj_id = obj_id;
103
3
#endif
104
3
  return obj;
105
3
}
Unexecuted instantiation: _Z5AllocI8KeyErrorJEEPT_DpOT0_
106
107
//
108
// String "Constructors".  We need these because of the "flexible array"
109
// pattern.  I don't think "new Str()" can do that, and placement new would
110
// require mycpp to generate 2 statements everywhere.
111
//
112
113
5.50k
inline Str* NewStr(int len) {
114
5.50k
  int obj_len = kStrHeaderSize + len + 1;
115
116
  // only allocation is unconditionally returned
117
5.50k
  void* place = gHeap.Allocate(obj_len);
118
119
5.50k
  auto s = new (place) Str();
120
5.50k
#if defined(MARK_SWEEP) || defined(BUMP_LEAK)
121
5.50k
  STR_LEN(s->header_) = len;
122
#else
123
  // reversed in len() to derive string length
124
  s->header_.obj_len = kStrHeaderSize + len + 1;
125
#endif
126
127
5.50k
#if MARK_SWEEP
128
5.50k
  s->header_.obj_id = gHeap.UnusedObjectId();
129
5.50k
#endif
130
5.50k
  return s;
131
5.50k
}
132
133
// Call OverAllocatedStr() when you don't know the length of the string up
134
// front, e.g. with snprintf().  CALLER IS RESPONSIBLE for calling
135
// s->MaybeShrink() afterward!
136
97
inline Str* OverAllocatedStr(int len) {
137
97
  int obj_len = kStrHeaderSize + len + 1;  // NUL terminator
138
97
  void* place = gHeap.Allocate(obj_len);
139
97
  auto s = new (place) Str();
140
97
#if MARK_SWEEP
141
97
  s->header_.obj_id = gHeap.UnusedObjectId();
142
97
#endif
143
97
  return s;
144
97
}
145
146
// Copy C string into the managed heap.
147
2.72k
inline Str* StrFromC(const char* data, int len) {
148
  // Optimization that could be taken out once we have SmallStr
149
2.72k
  if (len == 0) {
150
164
    return kEmptyString;
151
164
  }
152
2.56k
  Str* s = NewStr(len);
153
2.56k
  memcpy(s->data_, data, len);
154
2.56k
  DCHECK(s->data_[len] == '\0');  // should be true because Heap was zeroed
155
156
0
  return s;
157
2.72k
}
158
159
1.49k
inline Str* StrFromC(const char* data) {
160
1.49k
  return StrFromC(data, strlen(data));
161
1.49k
}
162
163
// Create a slab with a number of entries of a certain type.
164
// Note: entries will be zero'd because we use calloc().  TODO: Consider
165
// zeroing them separately.
166
template <typename T>
167
1.03k
inline Slab<T>* NewSlab(int len) {
168
1.03k
  int obj_len = RoundUp(kSlabHeaderSize + len * sizeof(T));
169
1.03k
  void* place = gHeap.Allocate(obj_len);
170
1.03k
  auto slab = new (place) Slab<T>(len);  // placement new
171
1.03k
#if MARK_SWEEP
172
1.03k
  slab->header_.obj_id = gHeap.UnusedObjectId();
173
1.03k
#endif
174
1.03k
  return slab;
175
1.03k
}
_Z7NewSlabIP3StrEP4SlabIT_Ei
Line
Count
Source
167
203
inline Slab<T>* NewSlab(int len) {
168
203
  int obj_len = RoundUp(kSlabHeaderSize + len * sizeof(T));
169
203
  void* place = gHeap.Allocate(obj_len);
170
203
  auto slab = new (place) Slab<T>(len);  // placement new
171
203
#if MARK_SWEEP
172
203
  slab->header_.obj_id = gHeap.UnusedObjectId();
173
203
#endif
174
203
  return slab;
175
203
}
_Z7NewSlabIiEP4SlabIT_Ei
Line
Count
Source
167
772
inline Slab<T>* NewSlab(int len) {
168
772
  int obj_len = RoundUp(kSlabHeaderSize + len * sizeof(T));
169
772
  void* place = gHeap.Allocate(obj_len);
170
772
  auto slab = new (place) Slab<T>(len);  // placement new
171
772
#if MARK_SWEEP
172
772
  slab->header_.obj_id = gHeap.UnusedObjectId();
173
772
#endif
174
772
  return slab;
175
772
}
Unexecuted instantiation: _Z7NewSlabIPN10classes_gc10OpaqueBaseEEP4SlabIT_Ei
Unexecuted instantiation: _Z7NewSlabIPN10classes_gc12PointersBaseEEP4SlabIT_Ei
Unexecuted instantiation: _Z7NewSlabIPN10classes_gc14BaseWithMethodEEP4SlabIT_Ei
_Z7NewSlabIP6Tuple2IiP3StrEEP4SlabIT_Ei
Line
Count
Source
167
7
inline Slab<T>* NewSlab(int len) {
168
7
  int obj_len = RoundUp(kSlabHeaderSize + len * sizeof(T));
169
7
  void* place = gHeap.Allocate(obj_len);
170
7
  auto slab = new (place) Slab<T>(len);  // placement new
171
7
#if MARK_SWEEP
172
7
  slab->header_.obj_id = gHeap.UnusedObjectId();
173
7
#endif
174
7
  return slab;
175
7
}
_Z7NewSlabIP6Tuple2IP3StriEEP4SlabIT_Ei
Line
Count
Source
167
1
inline Slab<T>* NewSlab(int len) {
168
1
  int obj_len = RoundUp(kSlabHeaderSize + len * sizeof(T));
169
1
  void* place = gHeap.Allocate(obj_len);
170
1
  auto slab = new (place) Slab<T>(len);  // placement new
171
1
#if MARK_SWEEP
172
1
  slab->header_.obj_id = gHeap.UnusedObjectId();
173
1
#endif
174
1
  return slab;
175
1
}
_Z7NewSlabIPN10hnode_asdl5fieldEEP4SlabIT_Ei
Line
Count
Source
167
34
inline Slab<T>* NewSlab(int len) {
168
34
  int obj_len = RoundUp(kSlabHeaderSize + len * sizeof(T));
169
34
  void* place = gHeap.Allocate(obj_len);
170
34
  auto slab = new (place) Slab<T>(len);  // placement new
171
34
#if MARK_SWEEP
172
34
  slab->header_.obj_id = gHeap.UnusedObjectId();
173
34
#endif
174
34
  return slab;
175
34
}
_Z7NewSlabIbEP4SlabIT_Ei
Line
Count
Source
167
3
inline Slab<T>* NewSlab(int len) {
168
3
  int obj_len = RoundUp(kSlabHeaderSize + len * sizeof(T));
169
3
  void* place = gHeap.Allocate(obj_len);
170
3
  auto slab = new (place) Slab<T>(len);  // placement new
171
3
#if MARK_SWEEP
172
3
  slab->header_.obj_id = gHeap.UnusedObjectId();
173
3
#endif
174
3
  return slab;
175
3
}
_Z7NewSlabIdEP4SlabIT_Ei
Line
Count
Source
167
2
inline Slab<T>* NewSlab(int len) {
168
2
  int obj_len = RoundUp(kSlabHeaderSize + len * sizeof(T));
169
2
  void* place = gHeap.Allocate(obj_len);
170
2
  auto slab = new (place) Slab<T>(len);  // placement new
171
2
#if MARK_SWEEP
172
2
  slab->header_.obj_id = gHeap.UnusedObjectId();
173
2
#endif
174
2
  return slab;
175
2
}
_Z7NewSlabIPN4pyos11PasswdEntryEEP4SlabIT_Ei
Line
Count
Source
167
5
inline Slab<T>* NewSlab(int len) {
168
5
  int obj_len = RoundUp(kSlabHeaderSize + len * sizeof(T));
169
5
  void* place = gHeap.Allocate(obj_len);
170
5
  auto slab = new (place) Slab<T>(len);  // placement new
171
5
#if MARK_SWEEP
172
5
  slab->header_.obj_id = gHeap.UnusedObjectId();
173
5
#endif
174
5
  return slab;
175
5
}
Unexecuted instantiation: _Z7NewSlabIPN10hnode_asdl7hnode_tEEP4SlabIT_Ei
_Z7NewSlabIPN12runtime_asdl7value_tEEP4SlabIT_Ei
Line
Count
Source
167
6
inline Slab<T>* NewSlab(int len) {
168
6
  int obj_len = RoundUp(kSlabHeaderSize + len * sizeof(T));
169
6
  void* place = gHeap.Allocate(obj_len);
170
6
  auto slab = new (place) Slab<T>(len);  // placement new
171
6
#if MARK_SWEEP
172
6
  slab->header_.obj_id = gHeap.UnusedObjectId();
173
6
#endif
174
6
  return slab;
175
6
}
176
177
#endif  // MYCPP_GC_ALLOC_H