1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef WTF_Allocator_h
#define WTF_Allocator_h
#include "wtf/Assertions.h"
#include "wtf/Partitions.h"
#include "wtf/StdLibExtras.h"
namespace WTF {
// Classes that contain references to garbage-collected objects but aren't
// themselves garbaged allocated, have some extra macros available which
// allows their use to be restricted to cases where the garbage collector
// is able to discover their references. These macros will be useful for
// non-garbage-collected objects to avoid unintended allocations.
//
// STACK_ALLOCATED(): Use if the object is only stack allocated.
// Garbage-collected objects should be in Members but you do not need the
// trace method as they are on the stack. (Down the line these might turn
// in to raw pointers, but for now Members indicate that we have thought
// about them and explicitly taken care of them.)
//
// DISALLOW_NEW(): Cannot be allocated with new operators but can be a
// part of object. If it has Members you need a trace method and the containing
// object needs to call that trace method.
//
// DISALLOW_NEW_EXCEPT_PLACEMENT_NEW(): Allows only placement new operator. This
// disallows general allocation of this object but allows to put the object as a
// value object in collections. If these have Members you need to have a trace
// method. That trace method will be called automatically by the on-heap
// collections.
//
#define DISALLOW_NEW() \
private: \
void* operator new(size_t) = delete; \
void* operator new(size_t, NotNullTag, void*) = delete; \
void* operator new(size_t, void*) = delete; \
public:
#define DISALLOW_NEW_EXCEPT_PLACEMENT_NEW() \
public: \
using IsAllowOnlyPlacementNew = int; \
void* operator new(size_t, NotNullTag, void* location) { return location; } \
void* operator new(size_t, void* location) { return location; } \
private: \
void* operator new(size_t) = delete; \
public:
#define STATIC_ONLY(Type) \
private: \
Type() = delete; \
Type(const Type&) = delete; \
Type& operator=(const Type&) = delete; \
void* operator new(size_t) = delete; \
void* operator new(size_t, NotNullTag, void*) = delete; \
void* operator new(size_t, void*) = delete; \
public:
#define IS_GARBAGE_COLLECTED_TYPE() \
public: \
using IsGarbageCollectedTypeMarker = int; \
private:
#if COMPILER(CLANG)
#define STACK_ALLOCATED() \
private: \
__attribute__((annotate("blink_stack_allocated"))) \
void* operator new(size_t) = delete; \
void* operator new(size_t, NotNullTag, void*) = delete; \
void* operator new(size_t, void*) = delete; \
public:
#else
#define STACK_ALLOCATED() DISALLOW_NEW()
#endif
// Provides customizable overrides of fastMalloc/fastFree and operator new/delete
//
// Provided functionality:
// Macro: USING_FAST_MALLOC
//
// Example usage:
// class Widget {
// USING_FAST_MALLOC(Widget)
// ...
// };
//
// struct Data {
// USING_FAST_MALLOC(Data)
// public:
// ...
// };
//
#define USING_FAST_MALLOC_INTERNAL(type, typeName) \
public: \
void* operator new(size_t, void* p) { return p; } \
void* operator new[](size_t, void* p) { return p; } \
\
void* operator new(size_t size) \
{ \
return ::WTF::Partitions::fastMalloc(size, typeName); \
} \
\
void operator delete(void* p) \
{ \
::WTF::Partitions::fastFree(p); \
} \
\
void* operator new[](size_t size) \
{ \
return ::WTF::Partitions::fastMalloc(size, typeName); \
} \
\
void operator delete[](void* p) \
{ \
::WTF::Partitions::fastFree(p); \
} \
void* operator new(size_t, NotNullTag, void* location) \
{ \
ASSERT(location); \
return location; \
} \
static const char* classNameForAllocator() \
{ \
return #type; \
} \
private: \
typedef int __thisIsHereToForceASemicolonAfterThisMacro
// Both of these macros enable fast malloc and provide type info to the heap
// profiler. The regular macro does not provide type info in official builds,
// to avoid bloating the binary with type name strings. The |WITH_TYPE_NAME|
// variant provides type info unconditionally, so it should be used sparingly.
// Furthermore, the |WITH_TYPE_NAME| variant does not work if |type| is a
// template argument; |USING_FAST_MALLOC| does.
#define USING_FAST_MALLOC(type) USING_FAST_MALLOC_INTERNAL(type, WTF_HEAP_PROFILER_TYPE_NAME(type))
#define USING_FAST_MALLOC_WITH_TYPE_NAME(type) USING_FAST_MALLOC_INTERNAL(type, #type)
} // namespace WTF
#endif /* WTF_Allocator_h */
|
