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
145
146
147
148
149
|
/*
* Copyright (C) 2016-2022 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include "JSInternalFieldObjectImpl.h"
namespace JSC {
class ProxyObject final : public JSInternalFieldObjectImpl<2> {
public:
using Base = JSInternalFieldObjectImpl<2>;
static constexpr unsigned StructureFlags = Base::StructureFlags | OverridesGetOwnPropertySlot | OverridesGetOwnPropertyNames | OverridesGetPrototype | OverridesGetCallData | OverridesPut | OverridesIsExtensible | InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | ProhibitsPropertyCaching;
enum class Field : uint32_t {
Target = 0,
Handler,
};
static_assert(numberOfInternalFields == 2);
static std::array<JSValue, numberOfInternalFields> initialValues()
{
return { {
jsNull(),
jsUndefined(),
} };
}
enum class HandlerTrap : uint8_t {
Has = 0,
Get,
GetOwnPropertyDescriptor,
OwnKeys,
Set,
};
static constexpr unsigned numberOfCachedHandlerTrapsOffsets = 5;
template<typename CellType, SubspaceAccess mode>
static GCClient::IsoSubspace* subspaceFor(VM& vm)
{
return vm.proxyObjectSpace<mode>();
}
static ProxyObject* create(JSGlobalObject* globalObject, JSValue target, JSValue handler)
{
VM& vm = getVM(globalObject);
Structure* structure = ProxyObject::structureForTarget(globalObject, target);
ProxyObject* proxy = new (NotNull, allocateCell<ProxyObject>(vm)) ProxyObject(vm, structure);
proxy->finishCreation(vm, globalObject, target, handler);
return proxy;
}
inline static Structure* createStructure(VM&, JSGlobalObject*, JSValue, bool);
DECLARE_EXPORT_INFO;
JSObject* target() const { return jsCast<JSObject*>(internalField(Field::Target).get()); }
JSValue handler() const { return internalField(Field::Handler).get(); }
static void validateNegativeHasTrapResult(JSGlobalObject*, JSObject*, PropertyName);
static void validatePositiveSetTrapResult(JSGlobalObject*, JSObject*, PropertyName, JSValue putValue);
static void validateGetTrapResult(JSGlobalObject*, JSValue trapResult, JSObject*, PropertyName);
static bool put(JSCell*, JSGlobalObject*, PropertyName, JSValue, PutPropertySlot&);
static bool putByIndex(JSCell*, JSGlobalObject*, unsigned propertyName, JSValue, bool shouldThrow);
bool putByIndexCommon(JSGlobalObject*, JSValue thisValue, unsigned propertyName, JSValue putValue, bool shouldThrow);
JSValue performGetPrototype(JSGlobalObject*);
void revoke(VM&);
bool isRevoked() const;
const WriteBarrier<Unknown>& internalField(Field field) const { return Base::internalField(static_cast<uint32_t>(field)); }
WriteBarrier<Unknown>& internalField(Field field) { return Base::internalField(static_cast<uint32_t>(field)); }
JSObject* getHandlerTrap(JSGlobalObject*, JSObject*, CallData&, const Identifier&, HandlerTrap);
bool forwardsGetOwnPropertyNamesToTarget(DontEnumPropertiesMode);
private:
JS_EXPORT_PRIVATE ProxyObject(VM&, Structure*);
JS_EXPORT_PRIVATE void finishCreation(VM&, JSGlobalObject*, JSValue target, JSValue handler);
JS_EXPORT_PRIVATE static Structure* structureForTarget(JSGlobalObject*, JSValue target);
bool isHandlerTrapsCacheValid(JSObject* handler);
void clearHandlerTrapsOffsetsCache();
static bool getOwnPropertySlot(JSObject*, JSGlobalObject*, PropertyName, PropertySlot&);
static bool getOwnPropertySlotByIndex(JSObject*, JSGlobalObject*, unsigned propertyName, PropertySlot&);
static CallData getCallData(JSCell*);
static CallData getConstructData(JSCell*);
static bool deleteProperty(JSCell*, JSGlobalObject*, PropertyName, DeletePropertySlot&);
static bool deletePropertyByIndex(JSCell*, JSGlobalObject*, unsigned propertyName);
static bool preventExtensions(JSObject*, JSGlobalObject*);
static bool isExtensible(JSObject*, JSGlobalObject*);
static bool defineOwnProperty(JSObject*, JSGlobalObject*, PropertyName, const PropertyDescriptor&, bool shouldThrow);
static void getOwnPropertyNames(JSObject*, JSGlobalObject*, PropertyNameArray&, DontEnumPropertiesMode);
static bool setPrototype(JSObject*, JSGlobalObject*, JSValue prototype, bool shouldThrowIfCantSet);
static JSValue getPrototype(JSObject*, JSGlobalObject*);
DECLARE_VISIT_CHILDREN;
bool getOwnPropertySlotCommon(JSGlobalObject*, PropertyName, PropertySlot&);
bool performInternalMethodGetOwnProperty(JSGlobalObject*, PropertyName, PropertySlot&);
bool performGet(JSGlobalObject*, PropertyName, PropertySlot&);
bool performHasProperty(JSGlobalObject*, PropertyName, PropertySlot&);
template <typename DefaultDeleteFunction>
bool performDelete(JSGlobalObject*, PropertyName, DefaultDeleteFunction);
template <typename PerformDefaultPutFunction>
bool performPut(JSGlobalObject*, JSValue putValue, JSValue thisValue, PropertyName, PerformDefaultPutFunction, bool shouldThrow);
bool performPreventExtensions(JSGlobalObject*);
bool performIsExtensible(JSGlobalObject*);
bool performDefineOwnProperty(JSGlobalObject*, PropertyName, const PropertyDescriptor&, bool shouldThrow);
void performGetOwnPropertyNames(JSGlobalObject*, PropertyNameArray&);
void performGetOwnEnumerablePropertyNames(JSGlobalObject*, PropertyNameArray&);
bool performSetPrototype(JSGlobalObject*, JSValue prototype, bool shouldThrowIfCantSet);
bool m_isCallable : 1 { false };
bool m_isConstructible : 1 { false };
PropertyOffset m_handlerTrapsOffsetsCache[numberOfCachedHandlerTrapsOffsets];
WriteBarrierStructureID m_handlerStructureID;
WriteBarrierStructureID m_handlerPrototypeStructureID;
};
ALWAYS_INLINE bool ProxyObject::isHandlerTrapsCacheValid(JSObject* handler)
{
return handler->structureID() == m_handlerStructureID.value() && asObject(handler->getPrototypeDirect())->structureID() == m_handlerPrototypeStructureID.value();
}
} // namespace JSC
|
