Introducing Integrity audit functions.
[WebKit-https.git] / Source / JavaScriptCore / runtime / ClassInfo.h
1 /*
2  *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
4  *  Copyright (C) 2003-2019 Apple Inc. All rights reserved.
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Library General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Library General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Library General Public License
17  *  along with this library; see the file COPYING.LIB.  If not, write to
18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  *  Boston, MA 02110-1301, USA.
20  *
21  */
22
23 #pragma once
24
25 #include "CallFrame.h"
26 #include "ConstructData.h"
27 #include "JSCast.h"
28 #include <wtf/PtrTag.h>
29
30 namespace WTF {
31 class PrintStream;
32 };
33
34 namespace JSC {
35
36 class HeapAnalyzer;
37 class JSArrayBufferView;
38 class Snippet;
39 struct HashTable;
40
41 #define METHOD_TABLE_ENTRY(method) \
42     WTF_VTBL_FUNCPTR_PTRAUTH_STR("MethodTable." #method) method
43
44 struct MethodTable {
45     using DestroyFunctionPtr = void (*)(JSCell*);
46     DestroyFunctionPtr METHOD_TABLE_ENTRY(destroy);
47
48     using VisitChildrenFunctionPtr = void (*)(JSCell*, SlotVisitor&);
49     VisitChildrenFunctionPtr METHOD_TABLE_ENTRY(visitChildren);
50
51     using GetCallDataFunctionPtr = CallType (*)(JSCell*, CallData&);
52     GetCallDataFunctionPtr METHOD_TABLE_ENTRY(getCallData);
53
54     using GetConstructDataFunctionPtr = ConstructType (*)(JSCell*, ConstructData&);
55     GetConstructDataFunctionPtr METHOD_TABLE_ENTRY(getConstructData);
56
57     using PutFunctionPtr = bool (*)(JSCell*, ExecState*, PropertyName propertyName, JSValue, PutPropertySlot&);
58     PutFunctionPtr METHOD_TABLE_ENTRY(put);
59
60     using PutByIndexFunctionPtr = bool (*)(JSCell*, ExecState*, unsigned propertyName, JSValue, bool shouldThrow);
61     PutByIndexFunctionPtr METHOD_TABLE_ENTRY(putByIndex);
62
63     using DeletePropertyFunctionPtr = bool (*)(JSCell*, ExecState*, PropertyName);
64     DeletePropertyFunctionPtr METHOD_TABLE_ENTRY(deleteProperty);
65
66     using DeletePropertyByIndexFunctionPtr = bool (*)(JSCell*, ExecState*, unsigned);
67     DeletePropertyByIndexFunctionPtr METHOD_TABLE_ENTRY(deletePropertyByIndex);
68
69     using GetOwnPropertySlotFunctionPtr = bool (*)(JSObject*, ExecState*, PropertyName, PropertySlot&);
70     GetOwnPropertySlotFunctionPtr METHOD_TABLE_ENTRY(getOwnPropertySlot);
71
72     using GetOwnPropertySlotByIndexFunctionPtr = bool (*)(JSObject*, ExecState*, unsigned, PropertySlot&);
73     GetOwnPropertySlotByIndexFunctionPtr METHOD_TABLE_ENTRY(getOwnPropertySlotByIndex);
74
75     using DoPutPropertySecurityCheckFunctionPtr = void (*)(JSObject*, ExecState*, PropertyName, PutPropertySlot&);
76     DoPutPropertySecurityCheckFunctionPtr METHOD_TABLE_ENTRY(doPutPropertySecurityCheck);
77
78     using ToThisFunctionPtr = JSValue (*)(JSCell*, ExecState*, ECMAMode);
79     ToThisFunctionPtr METHOD_TABLE_ENTRY(toThis);
80
81     using DefaultValueFunctionPtr = JSValue (*)(const JSObject*, ExecState*, PreferredPrimitiveType);
82     DefaultValueFunctionPtr METHOD_TABLE_ENTRY(defaultValue);
83
84     using GetOwnPropertyNamesFunctionPtr = void (*)(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
85     GetOwnPropertyNamesFunctionPtr METHOD_TABLE_ENTRY(getOwnPropertyNames);
86
87     using GetOwnNonIndexPropertyNamesFunctionPtr = void (*)(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
88     GetOwnNonIndexPropertyNamesFunctionPtr METHOD_TABLE_ENTRY(getOwnNonIndexPropertyNames);
89
90     using GetPropertyNamesFunctionPtr = void (*)(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
91     GetPropertyNamesFunctionPtr METHOD_TABLE_ENTRY(getPropertyNames);
92
93     using GetEnumerableLengthFunctionPtr = uint32_t (*)(ExecState*, JSObject*);
94     GetEnumerableLengthFunctionPtr METHOD_TABLE_ENTRY(getEnumerableLength);
95
96     GetPropertyNamesFunctionPtr METHOD_TABLE_ENTRY(getStructurePropertyNames);
97     GetPropertyNamesFunctionPtr METHOD_TABLE_ENTRY(getGenericPropertyNames);
98
99     using ClassNameFunctionPtr = String (*)(const JSObject*, VM&);
100     ClassNameFunctionPtr METHOD_TABLE_ENTRY(className);
101
102     using ToStringNameFunctionPtr = String (*)(const JSObject*, ExecState*);
103     ToStringNameFunctionPtr METHOD_TABLE_ENTRY(toStringName);
104
105     using CustomHasInstanceFunctionPtr = bool (*)(JSObject*, ExecState*, JSValue);
106     CustomHasInstanceFunctionPtr METHOD_TABLE_ENTRY(customHasInstance);
107
108     using DefineOwnPropertyFunctionPtr = bool (*)(JSObject*, ExecState*, PropertyName, const PropertyDescriptor&, bool);
109     DefineOwnPropertyFunctionPtr METHOD_TABLE_ENTRY(defineOwnProperty);
110
111     using PreventExtensionsFunctionPtr = bool (*)(JSObject*, ExecState*);
112     PreventExtensionsFunctionPtr METHOD_TABLE_ENTRY(preventExtensions);
113
114     using IsExtensibleFunctionPtr = bool (*)(JSObject*, ExecState*);
115     IsExtensibleFunctionPtr METHOD_TABLE_ENTRY(isExtensible);
116
117     using SetPrototypeFunctionPtr = bool (*)(JSObject*, ExecState*, JSValue, bool shouldThrowIfCantSet);
118     SetPrototypeFunctionPtr METHOD_TABLE_ENTRY(setPrototype);
119
120     using GetPrototypeFunctionPtr = JSValue (*)(JSObject*, ExecState*);
121     GetPrototypeFunctionPtr METHOD_TABLE_ENTRY(getPrototype);
122
123     using DumpToStreamFunctionPtr = void (*)(const JSCell*, PrintStream&);
124     DumpToStreamFunctionPtr METHOD_TABLE_ENTRY(dumpToStream);
125
126     using AnalyzeHeapFunctionPtr = void (*)(JSCell*, HeapAnalyzer&);
127     AnalyzeHeapFunctionPtr METHOD_TABLE_ENTRY(analyzeHeap);
128
129     using EstimatedSizeFunctionPtr = size_t (*)(JSCell*, VM&);
130     EstimatedSizeFunctionPtr METHOD_TABLE_ENTRY(estimatedSize);
131
132     using VisitOutputConstraintsPtr = void (*)(JSCell*, SlotVisitor&);
133     VisitOutputConstraintsPtr METHOD_TABLE_ENTRY(visitOutputConstraints);
134 };
135
136 #define CREATE_MEMBER_CHECKER(member) \
137     template <typename T> \
138     struct MemberCheck##member { \
139         struct Fallback { \
140             void member(...); \
141         }; \
142         struct Derived : T, Fallback { }; \
143         template <typename U, U> struct Check; \
144         typedef char Yes[2]; \
145         typedef char No[1]; \
146         template <typename U> \
147         static No &func(Check<void (Fallback::*)(...), &U::member>*); \
148         template <typename U> \
149         static Yes &func(...); \
150         enum { has = sizeof(func<Derived>(0)) == sizeof(Yes) }; \
151     }
152
153 #define HAS_MEMBER_NAMED(klass, name) (MemberCheck##name<klass>::has)
154
155 #define CREATE_METHOD_TABLE(ClassName) { \
156         &ClassName::destroy, \
157         &ClassName::visitChildren, \
158         &ClassName::getCallData, \
159         &ClassName::getConstructData, \
160         &ClassName::put, \
161         &ClassName::putByIndex, \
162         &ClassName::deleteProperty, \
163         &ClassName::deletePropertyByIndex, \
164         &ClassName::getOwnPropertySlot, \
165         &ClassName::getOwnPropertySlotByIndex, \
166         &ClassName::doPutPropertySecurityCheck, \
167         &ClassName::toThis, \
168         &ClassName::defaultValue, \
169         &ClassName::getOwnPropertyNames, \
170         &ClassName::getOwnNonIndexPropertyNames, \
171         &ClassName::getPropertyNames, \
172         &ClassName::getEnumerableLength, \
173         &ClassName::getStructurePropertyNames, \
174         &ClassName::getGenericPropertyNames, \
175         &ClassName::className, \
176         &ClassName::toStringName, \
177         &ClassName::customHasInstance, \
178         &ClassName::defineOwnProperty, \
179         &ClassName::preventExtensions, \
180         &ClassName::isExtensible, \
181         &ClassName::setPrototype, \
182         &ClassName::getPrototype, \
183         &ClassName::dumpToStream, \
184         &ClassName::analyzeHeap, \
185         &ClassName::estimatedSize, \
186         &ClassName::visitOutputConstraints, \
187     }, \
188     ClassName::TypedArrayStorageType, \
189     sizeof(ClassName)
190
191 struct ClassInfo {
192     // A string denoting the class name. Example: "Window".
193     const char* className;
194
195     // Pointer to the class information of the base class.
196     // nullptrif there is none.
197     const ClassInfo* parentClass;
198
199     static ptrdiff_t offsetOfParentClass()
200     {
201         return OBJECT_OFFSETOF(ClassInfo, parentClass);
202     }
203
204     bool isSubClassOf(const ClassInfo* other) const
205     {
206         for (const ClassInfo* ci = this; ci; ci = ci->parentClass) {
207             if (ci == other)
208                 return true;
209         }
210         return false;
211     }
212
213     JS_EXPORT_PRIVATE void dump(PrintStream&) const;
214
215     JS_EXPORT_PRIVATE bool hasStaticSetterOrReadonlyProperties() const;
216
217     const HashTable* staticPropHashTable;
218
219     using CheckSubClassSnippetFunctionPtr = Ref<Snippet> (*)(void);
220     CheckSubClassSnippetFunctionPtr checkSubClassSnippet;
221
222     MethodTable methodTable;
223
224     TypedArrayType typedArrayStorageType;
225     unsigned staticClassSize;
226 };
227
228 } // namespace JSC