darlinghq/darling-JavaScriptCore
1
0
Fork 0
mirror of https://github.com/darlinghq/darling-JavaScriptCore.git synced 2025-02-17 02:18:14 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
darling-JavaScriptCore/runtime/GenericArgumentsInlines.h

337 lines
13 KiB
C++
Raw Permalink Blame History

/*
* Copyright (C) 2015-2020 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. ``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
* 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 "GenericArguments.h"
#include "JSCInlines.h"
namespace JSC {
template<typename Type>
void GenericArguments<Type>::visitChildren(JSCell* thisCell, SlotVisitor& visitor)
{
Type* thisObject = static_cast<Type*>(thisCell);
ASSERT_GC_OBJECT_INHERITS(thisObject, info());
Base::visitChildren(thisCell, visitor);
if (thisObject->m_modifiedArgumentsDescriptor)
visitor.markAuxiliary(thisObject->m_modifiedArgumentsDescriptor.getUnsafe());
}
template<typename Type>
bool GenericArguments<Type>::getOwnPropertySlot(JSObject* object, JSGlobalObject* globalObject, PropertyName ident, PropertySlot& slot)
{
Type* thisObject = jsCast<Type*>(object);
VM& vm = globalObject->vm();
if (!thisObject->overrodeThings()) {
if (ident == vm.propertyNames->length) {
slot.setValue(thisObject, static_cast<unsigned>(PropertyAttribute::DontEnum), jsNumber(thisObject->internalLength()));
return true;
}
if (ident == vm.propertyNames->callee) {
slot.setValue(thisObject, static_cast<unsigned>(PropertyAttribute::DontEnum), thisObject->callee());
return true;
}
if (ident == vm.propertyNames->iteratorSymbol) {
slot.setValue(thisObject, static_cast<unsigned>(PropertyAttribute::DontEnum), thisObject->globalObject(vm)->arrayProtoValuesFunction());
return true;
}
}
if (Optional<uint32_t> index = parseIndex(ident))
return GenericArguments<Type>::getOwnPropertySlotByIndex(thisObject, globalObject, *index, slot);
return Base::getOwnPropertySlot(thisObject, globalObject, ident, slot);
}
template<typename Type>
bool GenericArguments<Type>::getOwnPropertySlotByIndex(JSObject* object, JSGlobalObject* globalObject, unsigned index, PropertySlot& slot)
{
Type* thisObject = jsCast<Type*>(object);
if (!thisObject->isModifiedArgumentDescriptor(index) && thisObject->isMappedArgument(index)) {
slot.setValue(thisObject, static_cast<unsigned>(PropertyAttribute::None), thisObject->getIndexQuickly(index));
return true;
}
bool result = Base::getOwnPropertySlotByIndex(object, globalObject, index, slot);
if (thisObject->isMappedArgument(index)) {
ASSERT(result);
slot.setValue(thisObject, slot.attributes(), thisObject->getIndexQuickly(index));
return true;
}
return result;
}
template<typename Type>
void GenericArguments<Type>::getOwnPropertyNames(JSObject* object, JSGlobalObject* globalObject, PropertyNameArray& array, DontEnumPropertiesMode mode)
{
VM& vm = globalObject->vm();
Type* thisObject = jsCast<Type*>(object);
if (array.includeStringProperties()) {
for (unsigned i = 0; i < thisObject->internalLength(); ++i) {
if (!thisObject->isMappedArgument(i))
continue;
array.add(Identifier::from(vm, i));
}
thisObject->getOwnIndexedPropertyNames(globalObject, array, mode);
}
if (mode == DontEnumPropertiesMode::Include && !thisObject->overrodeThings()) {
array.add(vm.propertyNames->length);
array.add(vm.propertyNames->callee);
array.add(vm.propertyNames->iteratorSymbol);
}
thisObject->getOwnNonIndexPropertyNames(globalObject, array, mode);
}
template<typename Type>
bool GenericArguments<Type>::put(JSCell* cell, JSGlobalObject* globalObject, PropertyName ident, JSValue value, PutPropertySlot& slot)
{
Type* thisObject = jsCast<Type*>(cell);
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
if (!thisObject->overrodeThings()
&& (ident == vm.propertyNames->length
|| ident == vm.propertyNames->callee
|| ident == vm.propertyNames->iteratorSymbol)) {
thisObject->overrideThings(globalObject);
RETURN_IF_EXCEPTION(scope, false);
PutPropertySlot dummy = slot; // This put is not cacheable, so we shadow the slot that was given to us.
RELEASE_AND_RETURN(scope, Base::put(thisObject, globalObject, ident, value, dummy));
}
// https://tc39.github.io/ecma262/#sec-arguments-exotic-objects-set-p-v-receiver
// Fall back to the OrdinarySet when the receiver is altered from the thisObject.
if (UNLIKELY(isThisValueAltered(slot, thisObject)))
RELEASE_AND_RETURN(scope, ordinarySetSlow(globalObject, thisObject, ident, value, slot.thisValue(), slot.isStrictMode()));
Optional<uint32_t> index = parseIndex(ident);
if (index && thisObject->isMappedArgument(index.value())) {
thisObject->setIndexQuickly(vm, index.value(), value);
return true;
}
auto result = Base::put(thisObject, globalObject, ident, value, slot);
RETURN_IF_EXCEPTION(scope, false);
RELEASE_AND_RETURN(scope, result);
}
template<typename Type>
bool GenericArguments<Type>::putByIndex(JSCell* cell, JSGlobalObject* globalObject, unsigned index, JSValue value, bool shouldThrow)
{
Type* thisObject = jsCast<Type*>(cell);
VM& vm = globalObject->vm();
if (thisObject->isMappedArgument(index)) {
thisObject->setIndexQuickly(vm, index, value);
return true;
}
return Base::putByIndex(cell, globalObject, index, value, shouldThrow);
}
template<typename Type>
bool GenericArguments<Type>::deleteProperty(JSCell* cell, JSGlobalObject* globalObject, PropertyName ident, DeletePropertySlot& slot)
{
Type* thisObject = jsCast<Type*>(cell);
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
if (!thisObject->overrodeThings()
&& (ident == vm.propertyNames->length
|| ident == vm.propertyNames->callee
|| ident == vm.propertyNames->iteratorSymbol)) {
thisObject->overrideThings(globalObject);
RETURN_IF_EXCEPTION(scope, false);
}
if (Optional<uint32_t> index = parseIndex(ident))
RELEASE_AND_RETURN(scope, GenericArguments<Type>::deletePropertyByIndex(thisObject, globalObject, *index));
RELEASE_AND_RETURN(scope, Base::deleteProperty(thisObject, globalObject, ident, slot));
}
template<typename Type>
bool GenericArguments<Type>::deletePropertyByIndex(JSCell* cell, JSGlobalObject* globalObject, unsigned index)
{
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
Type* thisObject = jsCast<Type*>(cell);
bool propertyMightBeInJSObjectStorage = thisObject->isModifiedArgumentDescriptor(index) || !thisObject->isMappedArgument(index);
bool deletedProperty = true;
if (propertyMightBeInJSObjectStorage) {
deletedProperty = Base::deletePropertyByIndex(cell, globalObject, index);
RETURN_IF_EXCEPTION(scope, true);
}
if (deletedProperty) {
// Deleting an indexed property unconditionally unmaps it.
if (thisObject->isMappedArgument(index)) {
// We need to check that the property was mapped so we don't write to random memory.
thisObject->unmapArgument(globalObject, index);
RETURN_IF_EXCEPTION(scope, true);
}
thisObject->setModifiedArgumentDescriptor(globalObject, index);
RETURN_IF_EXCEPTION(scope, true);
}
return deletedProperty;
}
// https://tc39.es/ecma262/#sec-arguments-exotic-objects-defineownproperty-p-desc
template<typename Type>
bool GenericArguments<Type>::defineOwnProperty(JSObject* object, JSGlobalObject* globalObject, PropertyName ident, const PropertyDescriptor& descriptor, bool shouldThrow)
{
Type* thisObject = jsCast<Type*>(object);
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
if (ident == vm.propertyNames->length
|| ident == vm.propertyNames->callee
|| ident == vm.propertyNames->iteratorSymbol) {
thisObject->overrideThingsIfNecessary(globalObject);
RETURN_IF_EXCEPTION(scope, false);
} else if (Optional<uint32_t> optionalIndex = parseIndex(ident)) {
uint32_t index = optionalIndex.value();
bool isMapped = thisObject->isMappedArgument(index);
PropertyDescriptor newDescriptor = descriptor;
if (isMapped) {
if (thisObject->isModifiedArgumentDescriptor(index)) {
if (!descriptor.value() && descriptor.writablePresent() && !descriptor.writable())
newDescriptor.setValue(thisObject->getIndexQuickly(index));
} else
thisObject->putDirectIndex(globalObject, index, thisObject->getIndexQuickly(index));
scope.assertNoException();
}
bool status = thisObject->defineOwnIndexedProperty(globalObject, index, newDescriptor, shouldThrow);
RETURN_IF_EXCEPTION(scope, false);
if (!status) {
ASSERT(!isMapped || thisObject->isModifiedArgumentDescriptor(index));
return false;
}
thisObject->setModifiedArgumentDescriptor(globalObject, index);
RETURN_IF_EXCEPTION(scope, false);
if (isMapped) {
if (descriptor.isAccessorDescriptor())
thisObject->unmapArgument(globalObject, index);
else {
if (descriptor.value())
thisObject->setIndexQuickly(vm, index, descriptor.value());
if (descriptor.writablePresent() && !descriptor.writable())
thisObject->unmapArgument(globalObject, index);
}
RETURN_IF_EXCEPTION(scope, false);
}
return true;
}
RELEASE_AND_RETURN(scope, Base::defineOwnProperty(object, globalObject, ident, descriptor, shouldThrow));
}
template<typename Type>
void GenericArguments<Type>::initModifiedArgumentsDescriptor(JSGlobalObject* globalObject, unsigned argsLength)
{
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
RELEASE_ASSERT(!m_modifiedArgumentsDescriptor);
if (argsLength) {
void* backingStore = vm.gigacageAuxiliarySpace(m_modifiedArgumentsDescriptor.kind).allocateNonVirtual(vm, WTF::roundUpToMultipleOf<8>(argsLength), nullptr, AllocationFailureMode::ReturnNull);
if (UNLIKELY(!backingStore)) {
throwOutOfMemoryError(globalObject, scope);
return;
}
bool* modifiedArguments = static_cast<bool*>(backingStore);
m_modifiedArgumentsDescriptor.set(vm, this, modifiedArguments, argsLength);
for (unsigned i = argsLength; i--;)
modifiedArguments[i] = false;
}
}
template<typename Type>
void GenericArguments<Type>::initModifiedArgumentsDescriptorIfNecessary(JSGlobalObject* globalObject, unsigned argsLength)
{
if (!m_modifiedArgumentsDescriptor)
initModifiedArgumentsDescriptor(globalObject, argsLength);
}
template<typename Type>
void GenericArguments<Type>::setModifiedArgumentDescriptor(JSGlobalObject* globalObject, unsigned index, unsigned length)
{
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
initModifiedArgumentsDescriptorIfNecessary(globalObject, length);
RETURN_IF_EXCEPTION(scope, void());
if (index < length)
m_modifiedArgumentsDescriptor.at(index, length) = true;
}
template<typename Type>
bool GenericArguments<Type>::isModifiedArgumentDescriptor(unsigned index, unsigned length)
{
if (!m_modifiedArgumentsDescriptor)
return false;
if (index < length)
return m_modifiedArgumentsDescriptor.at(index, length);
return false;
}
template<typename Type>
void GenericArguments<Type>::copyToArguments(JSGlobalObject* globalObject, JSValue* firstElementDest, unsigned offset, unsigned length)
{
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
Type* thisObject = static_cast<Type*>(this);
for (unsigned i = 0; i < length; ++i) {
if (thisObject->isMappedArgument(i + offset))
firstElementDest[i] = thisObject->getIndexQuickly(i + offset);
else {
firstElementDest[i] = get(globalObject, i + offset);
RETURN_IF_EXCEPTION(scope, void());
}
}
}
} // namespace JSC
Reference in New Issue View Git Blame Copy Permalink