We should support CreateThis in the FTL
[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-2018 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
29 namespace WTF {
30 class PrintStream;
31 };
32
33 namespace JSC {
34
35 class HeapSnapshotBuilder;
36 class JSArrayBufferView;
37 class Snippet;
38 struct HashTable;
39
40 struct MethodTable {
41     using DestroyFunctionPtr = void (*)(JSCell*);
42     DestroyFunctionPtr WTF_METHOD_TABLE_ENTRY(destroy);
43
44     using VisitChildrenFunctionPtr = void (*)(JSCell*, SlotVisitor&);
45     VisitChildrenFunctionPtr WTF_METHOD_TABLE_ENTRY(visitChildren);
46
47     using GetCallDataFunctionPtr = CallType (*)(JSCell*, CallData&);
48     GetCallDataFunctionPtr WTF_METHOD_TABLE_ENTRY(getCallData);
49
50     using GetConstructDataFunctionPtr = ConstructType (*)(JSCell*, ConstructData&);
51     GetConstructDataFunctionPtr WTF_METHOD_TABLE_ENTRY(getConstructData);
52
53     using PutFunctionPtr = bool (*)(JSCell*, ExecState*, PropertyName propertyName, JSValue, PutPropertySlot&);
54     PutFunctionPtr WTF_METHOD_TABLE_ENTRY(put);
55
56     using PutByIndexFunctionPtr = bool (*)(JSCell*, ExecState*, unsigned propertyName, JSValue, bool shouldThrow);
57     PutByIndexFunctionPtr WTF_METHOD_TABLE_ENTRY(putByIndex);
58
59     using DeletePropertyFunctionPtr = bool (*)(JSCell*, ExecState*, PropertyName);
60     DeletePropertyFunctionPtr WTF_METHOD_TABLE_ENTRY(deleteProperty);
61
62     using DeletePropertyByIndexFunctionPtr = bool (*)(JSCell*, ExecState*, unsigned);
63     DeletePropertyByIndexFunctionPtr WTF_METHOD_TABLE_ENTRY(deletePropertyByIndex);
64
65     using GetOwnPropertySlotFunctionPtr = bool (*)(JSObject*, ExecState*, PropertyName, PropertySlot&);
66     GetOwnPropertySlotFunctionPtr WTF_METHOD_TABLE_ENTRY(getOwnPropertySlot);
67
68     using GetOwnPropertySlotByIndexFunctionPtr = bool (*)(JSObject*, ExecState*, unsigned, PropertySlot&);
69     GetOwnPropertySlotByIndexFunctionPtr WTF_METHOD_TABLE_ENTRY(getOwnPropertySlotByIndex);
70
71     using ToThisFunctionPtr = JSValue (*)(JSCell*, ExecState*, ECMAMode);
72     ToThisFunctionPtr WTF_METHOD_TABLE_ENTRY(toThis);
73
74     using DefaultValueFunctionPtr = JSValue (*)(const JSObject*, ExecState*, PreferredPrimitiveType);
75     DefaultValueFunctionPtr WTF_METHOD_TABLE_ENTRY(defaultValue);
76
77     using GetOwnPropertyNamesFunctionPtr = void (*)(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
78     GetOwnPropertyNamesFunctionPtr WTF_METHOD_TABLE_ENTRY(getOwnPropertyNames);
79
80     using GetOwnNonIndexPropertyNamesFunctionPtr = void (*)(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
81     GetOwnNonIndexPropertyNamesFunctionPtr WTF_METHOD_TABLE_ENTRY(getOwnNonIndexPropertyNames);
82
83     using GetPropertyNamesFunctionPtr = void (*)(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
84     GetPropertyNamesFunctionPtr WTF_METHOD_TABLE_ENTRY(getPropertyNames);
85
86     using GetEnumerableLengthFunctionPtr = uint32_t (*)(ExecState*, JSObject*);
87     GetEnumerableLengthFunctionPtr WTF_METHOD_TABLE_ENTRY(getEnumerableLength);
88
89     GetPropertyNamesFunctionPtr WTF_METHOD_TABLE_ENTRY(getStructurePropertyNames);
90     GetPropertyNamesFunctionPtr WTF_METHOD_TABLE_ENTRY(getGenericPropertyNames);
91
92     using ClassNameFunctionPtr = String (*)(const JSObject*, VM&);
93     ClassNameFunctionPtr WTF_METHOD_TABLE_ENTRY(className);
94
95     using ToStringNameFunctionPtr = String (*)(const JSObject*, ExecState*);
96     ToStringNameFunctionPtr WTF_METHOD_TABLE_ENTRY(toStringName);
97
98     using CustomHasInstanceFunctionPtr = bool (*)(JSObject*, ExecState*, JSValue);
99     CustomHasInstanceFunctionPtr WTF_METHOD_TABLE_ENTRY(customHasInstance);
100
101     using DefineOwnPropertyFunctionPtr = bool (*)(JSObject*, ExecState*, PropertyName, const PropertyDescriptor&, bool);
102     DefineOwnPropertyFunctionPtr WTF_METHOD_TABLE_ENTRY(defineOwnProperty);
103
104     using PreventExtensionsFunctionPtr = bool (*)(JSObject*, ExecState*);
105     PreventExtensionsFunctionPtr WTF_METHOD_TABLE_ENTRY(preventExtensions);
106
107     using IsExtensibleFunctionPtr = bool (*)(JSObject*, ExecState*);
108     IsExtensibleFunctionPtr WTF_METHOD_TABLE_ENTRY(isExtensible);
109
110     using SetPrototypeFunctionPtr = bool (*)(JSObject*, ExecState*, JSValue, bool shouldThrowIfCantSet);
111     SetPrototypeFunctionPtr WTF_METHOD_TABLE_ENTRY(setPrototype);
112
113     using GetPrototypeFunctionPtr = JSValue (*)(JSObject*, ExecState*);
114     GetPrototypeFunctionPtr WTF_METHOD_TABLE_ENTRY(getPrototype);
115
116     using DumpToStreamFunctionPtr = void (*)(const JSCell*, PrintStream&);
117     DumpToStreamFunctionPtr WTF_METHOD_TABLE_ENTRY(dumpToStream);
118
119     using HeapSnapshotFunctionPtr = void (*)(JSCell*, HeapSnapshotBuilder&);
120     HeapSnapshotFunctionPtr WTF_METHOD_TABLE_ENTRY(heapSnapshot);
121
122     using EstimatedSizeFunctionPtr = size_t (*)(JSCell*, VM&);
123     EstimatedSizeFunctionPtr WTF_METHOD_TABLE_ENTRY(estimatedSize);
124
125     using VisitOutputConstraintsPtr = void (*)(JSCell*, SlotVisitor&);
126     VisitOutputConstraintsPtr WTF_METHOD_TABLE_ENTRY(visitOutputConstraints);
127 };
128
129 #define CREATE_MEMBER_CHECKER(member) \
130     template <typename T> \
131     struct MemberCheck##member { \
132         struct Fallback { \
133             void member(...); \
134         }; \
135         struct Derived : T, Fallback { }; \
136         template <typename U, U> struct Check; \
137         typedef char Yes[2]; \
138         typedef char No[1]; \
139         template <typename U> \
140         static No &func(Check<void (Fallback::*)(...), &U::member>*); \
141         template <typename U> \
142         static Yes &func(...); \
143         enum { has = sizeof(func<Derived>(0)) == sizeof(Yes) }; \
144     }
145
146 #define HAS_MEMBER_NAMED(klass, name) (MemberCheck##name<klass>::has)
147
148 #define CREATE_METHOD_TABLE(ClassName) { \
149         &ClassName::destroy, \
150         &ClassName::visitChildren, \
151         &ClassName::getCallData, \
152         &ClassName::getConstructData, \
153         &ClassName::put, \
154         &ClassName::putByIndex, \
155         &ClassName::deleteProperty, \
156         &ClassName::deletePropertyByIndex, \
157         &ClassName::getOwnPropertySlot, \
158         &ClassName::getOwnPropertySlotByIndex, \
159         &ClassName::toThis, \
160         &ClassName::defaultValue, \
161         &ClassName::getOwnPropertyNames, \
162         &ClassName::getOwnNonIndexPropertyNames, \
163         &ClassName::getPropertyNames, \
164         &ClassName::getEnumerableLength, \
165         &ClassName::getStructurePropertyNames, \
166         &ClassName::getGenericPropertyNames, \
167         &ClassName::className, \
168         &ClassName::toStringName, \
169         &ClassName::customHasInstance, \
170         &ClassName::defineOwnProperty, \
171         &ClassName::preventExtensions, \
172         &ClassName::isExtensible, \
173         &ClassName::setPrototype, \
174         &ClassName::getPrototype, \
175         &ClassName::dumpToStream, \
176         &ClassName::heapSnapshot, \
177         &ClassName::estimatedSize, \
178         &ClassName::visitOutputConstraints, \
179     }, \
180     ClassName::TypedArrayStorageType
181
182 struct ClassInfo {
183     // A string denoting the class name. Example: "Window".
184     const char* className;
185
186     // Pointer to the class information of the base class.
187     // nullptrif there is none.
188     const ClassInfo* parentClass;
189
190     static ptrdiff_t offsetOfParentClass()
191     {
192         return OBJECT_OFFSETOF(ClassInfo, parentClass);
193     }
194
195     bool isSubClassOf(const ClassInfo* other) const
196     {
197         for (const ClassInfo* ci = this; ci; ci = ci->parentClass) {
198             if (ci == other)
199                 return true;
200         }
201         return false;
202     }
203
204     JS_EXPORT_PRIVATE void dump(PrintStream&) const;
205
206     JS_EXPORT_PRIVATE bool hasStaticSetterOrReadonlyProperties() const;
207
208     const HashTable* staticPropHashTable;
209
210     using CheckSubClassSnippetFunctionPtr = Ref<Snippet> (*)(void);
211     CheckSubClassSnippetFunctionPtr checkSubClassSnippet;
212
213     MethodTable methodTable;
214
215     TypedArrayType typedArrayStorageType;
216 };
217
218 } // namespace JSC