Unreviewed, rolling out r234489.
[WebKit-https.git] / Source / WTF / wtf / Gigacage.h
1 /*
2  * Copyright (C) 2017-2018 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #pragma once
27
28 #include <wtf/FastMalloc.h>
29
30 #if defined(USE_SYSTEM_MALLOC) && USE_SYSTEM_MALLOC
31 #define GIGACAGE_ENABLED 0
32 #define PRIMITIVE_GIGACAGE_MASK 0
33 #define JSVALUE_GIGACAGE_MASK 0
34 #define GIGACAGE_BASE_PTRS_SIZE 8192
35
36 extern "C" {
37 alignas(void*) extern WTF_EXPORT_PRIVATE char g_gigacageBasePtrs[GIGACAGE_BASE_PTRS_SIZE];
38 }
39
40 namespace Gigacage {
41
42 struct BasePtrs {
43     void* primitive;
44     void* jsValue;
45 };
46
47 enum Kind {
48     Primitive,
49     JSValue,
50 };
51
52 inline void ensureGigacage() { }
53 inline void disablePrimitiveGigacage() { }
54 inline bool shouldBeEnabled() { return false; }
55
56 inline void addPrimitiveDisableCallback(void (*)(void*), void*) { }
57 inline void removePrimitiveDisableCallback(void (*)(void*), void*) { }
58
59 inline void disableDisablingPrimitiveGigacageIfShouldBeEnabled() { }
60
61 inline bool isDisablingPrimitiveGigacageDisabled() { return false; }
62 inline bool isPrimitiveGigacagePermanentlyEnabled() { return false; }
63 inline bool canPrimitiveGigacageBeDisabled() { return true; }
64
65 ALWAYS_INLINE const char* name(Kind kind)
66 {
67     switch (kind) {
68     case Primitive:
69         return "Primitive";
70     case JSValue:
71         return "JSValue";
72     }
73     RELEASE_ASSERT_NOT_REACHED();
74     return nullptr;
75 }
76
77 ALWAYS_INLINE void*& basePtr(BasePtrs& basePtrs, Kind kind)
78 {
79     switch (kind) {
80     case Primitive:
81         return basePtrs.primitive;
82     case JSValue:
83         return basePtrs.jsValue;
84     }
85     RELEASE_ASSERT_NOT_REACHED();
86     return basePtrs.primitive;
87 }
88
89 ALWAYS_INLINE BasePtrs& basePtrs()
90 {
91     return *reinterpret_cast<BasePtrs*>(reinterpret_cast<void*>(g_gigacageBasePtrs));
92 }
93
94 ALWAYS_INLINE void*& basePtr(Kind kind)
95 {
96     return basePtr(basePtrs(), kind);
97 }
98
99 ALWAYS_INLINE bool isEnabled(Kind kind)
100 {
101     return !!basePtr(kind);
102 }
103
104 ALWAYS_INLINE size_t mask(Kind) { return 0; }
105
106 template<typename T>
107 inline T* caged(Kind, T* ptr) { return ptr; }
108
109 inline bool isCaged(Kind, const void*) { return false; }
110
111 inline void* tryAlignedMalloc(Kind, size_t alignment, size_t size) { return tryFastAlignedMalloc(alignment, size); }
112 inline void alignedFree(Kind, void* p) { fastAlignedFree(p); }
113 WTF_EXPORT_PRIVATE void* tryMalloc(Kind, size_t size);
114 inline void free(Kind, void* p) { fastFree(p); }
115
116 WTF_EXPORT_PRIVATE void* tryAllocateZeroedVirtualPages(Kind, size_t size);
117 WTF_EXPORT_PRIVATE void freeVirtualPages(Kind, void* basePtr, size_t size);
118
119 } // namespace Gigacage
120 #else
121 #include <bmalloc/Gigacage.h>
122
123 namespace Gigacage {
124
125 WTF_EXPORT_PRIVATE void* tryAlignedMalloc(Kind, size_t alignment, size_t size);
126 WTF_EXPORT_PRIVATE void alignedFree(Kind, void*);
127 WTF_EXPORT_PRIVATE void* tryMalloc(Kind, size_t);
128 WTF_EXPORT_PRIVATE void free(Kind, void*);
129
130 WTF_EXPORT_PRIVATE void* tryAllocateZeroedVirtualPages(Kind, size_t size);
131 WTF_EXPORT_PRIVATE void freeVirtualPages(Kind, void* basePtr, size_t size);
132
133 } // namespace Gigacage
134 #endif
135
136 namespace Gigacage {
137
138 WTF_EXPORT_PRIVATE void* tryMallocArray(Kind, size_t numElements, size_t elementSize);
139
140 WTF_EXPORT_PRIVATE void* malloc(Kind, size_t);
141 WTF_EXPORT_PRIVATE void* mallocArray(Kind, size_t numElements, size_t elementSize);
142
143 } // namespace Gigacage
144
145