/*

* Copyright (C) 2013-2021 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.

*/

#include "config.h"

#include "JITOperations.h"

#if ENABLE(JIT)

#include "ArithProfile.h"

#include "ArrayConstructor.h"

#include "CacheableIdentifierInlines.h"

#include "CodeBlockInlines.h"

#include "CommonSlowPathsInlines.h"

#include "DFGDriver.h"

#include "DFGOSREntry.h"

#include "DFGThunks.h"

#include "Debugger.h"

#include "ExceptionFuzz.h"

#include "FrameTracers.h"

#include "GetterSetter.h"

#include "ICStats.h"

#include "Interpreter.h"

#include "JIT.h"

#include "JITExceptions.h"

#include "JITToDFGDeferredCompilationCallback.h"

#include "JITWorklist.h"

#include "JSAsyncFunction.h"

#include "JSAsyncGenerator.h"

#include "JSAsyncGeneratorFunction.h"

#include "JSCInlines.h"

#include "JSCPtrTag.h"

#include "JSGeneratorFunction.h"

#include "JSGlobalObjectFunctions.h"

#include "JSInternalPromise.h"

#include "JSLexicalEnvironment.h"

#include "JSWithScope.h"

#include "LLIntEntrypoint.h"

#include "ObjectConstructor.h"

#include "PropertyName.h"

#include "RegExpObject.h"

#include "RepatchInlines.h"

#include "ShadowChicken.h"

#include "StructureStubInfo.h"

#include "SuperSampler.h"

#include "ThunkGenerators.h"

#include "TypeProfilerLog.h"

#include "VMInlines.h"

#include "VMTrapsInlines.h"

IGNORE_WARNINGS_BEGIN("frame-address")

namespace JSC {

ALWAYS_INLINE JSValue profiledAdd(JSGlobalObject* globalObject, JSValue op1, JSValue op2, BinaryArithProfile& arithProfile)

{

arithProfile.observeLHSAndRHS(op1, op2);

JSValue result = jsAdd(globalObject, op1, op2);

arithProfile.observeResult(result);

return result;

}

#if COMPILER(MSVC)

extern "C" void * _ReturnAddress(void);

#pragma intrinsic(_ReturnAddress)

#define OUR_RETURN_ADDRESS _ReturnAddress()

#else

// FIXME (see rdar://72897291): Work around a Clang bug where __builtin_return_address()

// sometimes gives us a signed pointer, and sometimes does not.

#define OUR_RETURN_ADDRESS removeCodePtrTag(__builtin_return_address(0))

#endif

JSC_DEFINE_JIT_OPERATION(operationThrowStackOverflowError, void, (CodeBlock* codeBlock))

{

// We pass in our own code block, because the callframe hasn't been populated.

VM& vm = codeBlock->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

callFrame->convertToStackOverflowFrame(vm, codeBlock);

throwStackOverflowError(codeBlock->globalObject(), scope);

}

JSC_DEFINE_JIT_OPERATION(operationThrowStackOverflowErrorFromThunk, void, (JSGlobalObject* globalObject))

{

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

throwStackOverflowError(globalObject, scope);

genericUnwind(vm, callFrame);

ASSERT(vm.targetMachinePCForThrow);

}

JSC_DEFINE_JIT_OPERATION(operationThrowIteratorResultIsNotObject, void, (JSGlobalObject* globalObject))

{

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

throwTypeError(globalObject, scope, "Iterator result interface is not an object."_s);

}

JSC_DEFINE_JIT_OPERATION(operationCallArityCheck, int32_t, (JSGlobalObject* globalObject))

{

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

int32_t missingArgCount = CommonSlowPaths::arityCheckFor(vm, callFrame, CodeForCall);

if (UNLIKELY(missingArgCount < 0)) {

CodeBlock* codeBlock = CommonSlowPaths::codeBlockFromCallFrameCallee(callFrame, CodeForCall);

callFrame->convertToStackOverflowFrame(vm, codeBlock);

throwStackOverflowError(globalObject, scope);

}

return missingArgCount;

}

JSC_DEFINE_JIT_OPERATION(operationConstructArityCheck, int32_t, (JSGlobalObject* globalObject))

{

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

int32_t missingArgCount = CommonSlowPaths::arityCheckFor(vm, callFrame, CodeForConstruct);

if (UNLIKELY(missingArgCount < 0)) {

CodeBlock* codeBlock = CommonSlowPaths::codeBlockFromCallFrameCallee(callFrame, CodeForConstruct);

callFrame->convertToStackOverflowFrame(vm, codeBlock);

throwStackOverflowError(globalObject, scope);

}

return missingArgCount;

}

JSC_DEFINE_JIT_OPERATION(operationTryGetById, EncodedJSValue, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue base, uintptr_t rawCacheableIdentifier))

{

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

stubInfo->tookSlowPath = true;

JSValue baseValue = JSValue::decode(base);

PropertySlot slot(baseValue, PropertySlot::InternalMethodType::VMInquiry, &vm);

baseValue.getPropertySlot(globalObject, ident, slot);

return JSValue::encode(slot.getPureResult());

}

JSC_DEFINE_JIT_OPERATION(operationTryGetByIdGeneric, EncodedJSValue, (JSGlobalObject* globalObject, EncodedJSValue base, uintptr_t rawCacheableIdentifier))

{

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

JSValue baseValue = JSValue::decode(base);

PropertySlot slot(baseValue, PropertySlot::InternalMethodType::VMInquiry, &vm);

baseValue.getPropertySlot(globalObject, ident, slot);

return JSValue::encode(slot.getPureResult());

}

JSC_DEFINE_JIT_OPERATION(operationTryGetByIdOptimize, EncodedJSValue, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue base, uintptr_t rawCacheableIdentifier))

{

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

JSValue baseValue = JSValue::decode(base);

PropertySlot slot(baseValue, PropertySlot::InternalMethodType::VMInquiry, &vm);

baseValue.getPropertySlot(globalObject, ident, slot);

RETURN_IF_EXCEPTION(scope, encodedJSValue());

CodeBlock* codeBlock = callFrame->codeBlock();

if (stubInfo->considerCachingBy(vm, codeBlock, baseValue.structureOrNull(vm), identifier) && !slot.isTaintedByOpaqueObject() && (slot.isCacheableValue() || slot.isCacheableGetter() || slot.isUnset()))

repatchGetBy(globalObject, codeBlock, baseValue, identifier, slot, *stubInfo, GetByKind::TryById);

return JSValue::encode(slot.getPureResult());

}

JSC_DEFINE_JIT_OPERATION(operationGetByIdDirect, EncodedJSValue, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue base, uintptr_t rawCacheableIdentifier))

{

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

stubInfo->tookSlowPath = true;

JSValue baseValue = JSValue::decode(base);

PropertySlot slot(baseValue, PropertySlot::InternalMethodType::GetOwnProperty);

bool found = baseValue.getOwnPropertySlot(globalObject, ident, slot);

RETURN_IF_EXCEPTION(scope, encodedJSValue());

RELEASE_AND_RETURN(scope, JSValue::encode(found ? slot.getValue(globalObject, ident) : jsUndefined()));

}

JSC_DEFINE_JIT_OPERATION(operationGetByIdDirectGeneric, EncodedJSValue, (JSGlobalObject* globalObject, EncodedJSValue base, uintptr_t rawCacheableIdentifier))

{

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

JSValue baseValue = JSValue::decode(base);

PropertySlot slot(baseValue, PropertySlot::InternalMethodType::GetOwnProperty);

bool found = baseValue.getOwnPropertySlot(globalObject, ident, slot);

RETURN_IF_EXCEPTION(scope, encodedJSValue());

RELEASE_AND_RETURN(scope, JSValue::encode(found ? slot.getValue(globalObject, ident) : jsUndefined()));

}

JSC_DEFINE_JIT_OPERATION(operationGetByIdDirectOptimize, EncodedJSValue, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue base, uintptr_t rawCacheableIdentifier))

{

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

JSValue baseValue = JSValue::decode(base);

PropertySlot slot(baseValue, PropertySlot::InternalMethodType::GetOwnProperty);

bool found = baseValue.getOwnPropertySlot(globalObject, ident, slot);

RETURN_IF_EXCEPTION(scope, encodedJSValue());

CodeBlock* codeBlock = callFrame->codeBlock();

if (stubInfo->considerCachingBy(vm, codeBlock, baseValue.structureOrNull(vm), identifier))

repatchGetBy(globalObject, codeBlock, baseValue, identifier, slot, *stubInfo, GetByKind::ByIdDirect);

RELEASE_AND_RETURN(scope, JSValue::encode(found ? slot.getValue(globalObject, ident) : jsUndefined()));

}

JSC_DEFINE_JIT_OPERATION(operationGetById, EncodedJSValue, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue base, uintptr_t rawCacheableIdentifier))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

stubInfo->tookSlowPath = true;

JSValue baseValue = JSValue::decode(base);

PropertySlot slot(baseValue, PropertySlot::InternalMethodType::Get);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

JSValue result = baseValue.get(globalObject, ident, slot);

LOG_IC((ICEvent::OperationGetById, baseValue.classInfoOrNull(vm), ident, baseValue == slot.slotBase()));

return JSValue::encode(result);

}

JSC_DEFINE_JIT_OPERATION(operationGetByIdGeneric, EncodedJSValue, (JSGlobalObject* globalObject, EncodedJSValue base, uintptr_t rawCacheableIdentifier))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

JSValue baseValue = JSValue::decode(base);

PropertySlot slot(baseValue, PropertySlot::InternalMethodType::Get);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

JSValue result = baseValue.get(globalObject, ident, slot);

LOG_IC((ICEvent::OperationGetByIdGeneric, baseValue.classInfoOrNull(vm), ident, baseValue == slot.slotBase()));

return JSValue::encode(result);

}

JSC_DEFINE_JIT_OPERATION(operationGetByIdOptimize, EncodedJSValue, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue base, uintptr_t rawCacheableIdentifier))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

JSValue baseValue = JSValue::decode(base);

return JSValue::encode(baseValue.getPropertySlot(globalObject, ident, [&] (bool found, PropertySlot& slot) -> JSValue {

LOG_IC((ICEvent::OperationGetByIdOptimize, baseValue.classInfoOrNull(vm), ident, baseValue == slot.slotBase()));

CodeBlock* codeBlock = callFrame->codeBlock();

if (stubInfo->considerCachingBy(vm, codeBlock, baseValue.structureOrNull(vm), identifier))

repatchGetBy(globalObject, codeBlock, baseValue, identifier, slot, *stubInfo, GetByKind::ById);

return found ? slot.getValue(globalObject, ident) : jsUndefined();

}));

}

JSC_DEFINE_JIT_OPERATION(operationGetByIdWithThis, EncodedJSValue, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue base, EncodedJSValue thisEncoded, uintptr_t rawCacheableIdentifier))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

stubInfo->tookSlowPath = true;

JSValue baseValue = JSValue::decode(base);

JSValue thisValue = JSValue::decode(thisEncoded);

PropertySlot slot(thisValue, PropertySlot::InternalMethodType::Get);

return JSValue::encode(baseValue.get(globalObject, ident, slot));

}

JSC_DEFINE_JIT_OPERATION(operationGetByIdWithThisGeneric, EncodedJSValue, (JSGlobalObject* globalObject, EncodedJSValue base, EncodedJSValue thisEncoded, uintptr_t rawCacheableIdentifier))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

JSValue baseValue = JSValue::decode(base);

JSValue thisValue = JSValue::decode(thisEncoded);

PropertySlot slot(thisValue, PropertySlot::InternalMethodType::Get);

return JSValue::encode(baseValue.get(globalObject, ident, slot));

}

JSC_DEFINE_JIT_OPERATION(operationGetByIdWithThisOptimize, EncodedJSValue, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue base, EncodedJSValue thisEncoded, uintptr_t rawCacheableIdentifier))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

JSValue baseValue = JSValue::decode(base);

JSValue thisValue = JSValue::decode(thisEncoded);

PropertySlot slot(thisValue, PropertySlot::InternalMethodType::Get);

return JSValue::encode(baseValue.getPropertySlot(globalObject, ident, slot, [&] (bool found, PropertySlot& slot) -> JSValue {

LOG_IC((ICEvent::OperationGetByIdWithThisOptimize, baseValue.classInfoOrNull(vm), ident, baseValue == slot.slotBase()));

CodeBlock* codeBlock = callFrame->codeBlock();

if (stubInfo->considerCachingBy(vm, codeBlock, baseValue.structureOrNull(vm), identifier))

repatchGetBy(globalObject, codeBlock, baseValue, identifier, slot, *stubInfo, GetByKind::ByIdWithThis);

return found ? slot.getValue(globalObject, ident) : jsUndefined();

}));

}

JSC_DEFINE_JIT_OPERATION(operationInByIdGeneric, EncodedJSValue, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue base, uintptr_t rawCacheableIdentifier))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

stubInfo->tookSlowPath = true;

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

JSValue baseValue = JSValue::decode(base);

if (!baseValue.isObject()) {

throwException(globalObject, scope, createInvalidInParameterError(globalObject, baseValue));

return JSValue::encode(jsUndefined());

}

JSObject* baseObject = asObject(baseValue);

LOG_IC((ICEvent::OperationInByIdGeneric, baseObject->classInfo(vm), ident));

scope.release();

PropertySlot slot(baseObject, PropertySlot::InternalMethodType::HasProperty);

return JSValue::encode(jsBoolean(baseObject->getPropertySlot(globalObject, ident, slot)));

}

JSC_DEFINE_JIT_OPERATION(operationInByIdOptimize, EncodedJSValue, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue base, uintptr_t rawCacheableIdentifier))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

JSValue baseValue = JSValue::decode(base);

if (!baseValue.isObject()) {

throwException(globalObject, scope, createInvalidInParameterError(globalObject, baseValue));

return JSValue::encode(jsUndefined());

}

JSObject* baseObject = asObject(baseValue);

LOG_IC((ICEvent::OperationInByIdOptimize, baseObject->classInfo(vm), ident));

scope.release();

PropertySlot slot(baseObject, PropertySlot::InternalMethodType::HasProperty);

bool found = baseObject->getPropertySlot(globalObject, ident, slot);

CodeBlock* codeBlock = callFrame->codeBlock();

if (stubInfo->considerCachingBy(vm, codeBlock, baseObject->structure(vm), identifier))

repatchInBy(globalObject, codeBlock, baseObject, identifier, found, slot, *stubInfo, InByKind::ById);

return JSValue::encode(jsBoolean(found));

}

JSC_DEFINE_JIT_OPERATION(operationInByValOptimize, EncodedJSValue, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, ArrayProfile* arrayProfile, EncodedJSValue encodedBase, EncodedJSValue encodedKey))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

JSValue baseValue = JSValue::decode(encodedBase);

if (!baseValue.isObject()) {

throwException(globalObject, scope, createInvalidInParameterError(globalObject, baseValue));

return encodedJSValue();

}

JSObject* baseObject = asObject(baseValue);

if (arrayProfile)

arrayProfile->observeStructure(baseObject->structure(vm));

JSValue key = JSValue::decode(encodedKey);

uint32_t i;

if (key.getUInt32(i)) {

// FIXME: InByVal should have inline caching for integer indices too, as GetByVal does.

// https://bugs.webkit.org/show_bug.cgi?id=226619

if (arrayProfile)

arrayProfile->observeIndexedRead(vm, baseObject, i);

RELEASE_AND_RETURN(scope, JSValue::encode(jsBoolean(baseObject->hasProperty(globalObject, i))));

}

const Identifier propertyName = key.toPropertyKey(globalObject);

RETURN_IF_EXCEPTION(scope, encodedJSValue());

PropertySlot slot(baseObject, PropertySlot::InternalMethodType::HasProperty);

bool found = baseObject->getPropertySlot(globalObject, propertyName, slot);

RETURN_IF_EXCEPTION(scope, encodedJSValue());

if (CacheableIdentifier::isCacheableIdentifierCell(key) && (key.isSymbol() || !parseIndex(propertyName))) {

CodeBlock* codeBlock = callFrame->codeBlock();

CacheableIdentifier identifier = CacheableIdentifier::createFromCell(key.asCell());

if (stubInfo->considerCachingBy(vm, codeBlock, baseObject->structure(vm), identifier))

repatchInBy(globalObject, codeBlock, baseObject, identifier, found, slot, *stubInfo, InByKind::ByVal);

}

return JSValue::encode(jsBoolean(found));

}

JSC_DEFINE_JIT_OPERATION(operationInByValGeneric, EncodedJSValue, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, ArrayProfile* arrayProfile, EncodedJSValue base, EncodedJSValue key))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

stubInfo->tookSlowPath = true;

return JSValue::encode(jsBoolean(CommonSlowPaths::opInByVal(globalObject, JSValue::decode(base), JSValue::decode(key), arrayProfile)));

}

JSC_DEFINE_JIT_OPERATION(operationHasPrivateNameOptimize, EncodedJSValue, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue encodedBase, EncodedJSValue encodedProperty))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

JSValue baseValue = JSValue::decode(encodedBase);

if (!baseValue.isObject()) {

throwException(globalObject, scope, createInvalidInParameterError(globalObject, baseValue));

return encodedJSValue();

}

JSObject* baseObject = asObject(baseValue);

JSValue propertyValue = JSValue::decode(encodedProperty);

ASSERT(propertyValue.isSymbol());

auto property = propertyValue.toPropertyKey(globalObject);

RETURN_IF_EXCEPTION(scope, { });

PropertySlot slot(baseObject, PropertySlot::InternalMethodType::HasProperty);

bool found = JSObject::getPrivateFieldSlot(baseObject, globalObject, property, slot);

ASSERT(CacheableIdentifier::isCacheableIdentifierCell(propertyValue));

CodeBlock* codeBlock = callFrame->codeBlock();

CacheableIdentifier identifier = CacheableIdentifier::createFromCell(propertyValue.asCell());

if (stubInfo->considerCachingBy(vm, codeBlock, baseObject->structure(vm), identifier))

repatchInBy(globalObject, codeBlock, baseObject, identifier, found, slot, *stubInfo, InByKind::PrivateName);

return JSValue::encode(jsBoolean(found));

}

JSC_DEFINE_JIT_OPERATION(operationHasPrivateNameGeneric, EncodedJSValue, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue encodedBase, EncodedJSValue encodedProperty))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

stubInfo->tookSlowPath = true;

JSValue baseValue = JSValue::decode(encodedBase);

if (!baseValue.isObject()) {

throwException(globalObject, scope, createInvalidInParameterError(globalObject, baseValue));

return encodedJSValue();

}

JSValue propertyValue = JSValue::decode(encodedProperty);

ASSERT(propertyValue.isSymbol());

auto property = propertyValue.toPropertyKey(globalObject);

RETURN_IF_EXCEPTION(scope, { });

return JSValue::encode(jsBoolean(asObject(baseValue)->hasPrivateField(globalObject, property)));

}

JSC_DEFINE_JIT_OPERATION(operationHasPrivateBrandOptimize, EncodedJSValue, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue encodedBase, EncodedJSValue encodedBrand))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

JSValue baseValue = JSValue::decode(encodedBase);

if (!baseValue.isObject()) {

throwException(globalObject, scope, createInvalidInParameterError(globalObject, baseValue));

return encodedJSValue();

}

JSObject* baseObject = asObject(baseValue);

JSValue brand = JSValue::decode(encodedBrand);

bool found = asObject(baseValue)->hasPrivateBrand(globalObject, brand);

ASSERT(CacheableIdentifier::isCacheableIdentifierCell(brand));

CodeBlock* codeBlock = callFrame->codeBlock();

CacheableIdentifier identifier = CacheableIdentifier::createFromCell(brand.asCell());

if (stubInfo->considerCachingBy(vm, codeBlock, baseObject->structure(vm), identifier))

repatchHasPrivateBrand(globalObject, codeBlock, baseObject, identifier, found, *stubInfo);

return JSValue::encode(jsBoolean(found));

}

JSC_DEFINE_JIT_OPERATION(operationHasPrivateBrandGeneric, EncodedJSValue, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue encodedBase, EncodedJSValue encodedBrand))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

stubInfo->tookSlowPath = true;

JSValue baseValue = JSValue::decode(encodedBase);

if (!baseValue.isObject()) {

throwException(globalObject, scope, createInvalidInParameterError(globalObject, baseValue));

return encodedJSValue();

}

return JSValue::encode(jsBoolean(asObject(baseValue)->hasPrivateBrand(globalObject, JSValue::decode(encodedBrand))));

}

JSC_DEFINE_JIT_OPERATION(operationPutByIdStrict, void, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t rawCacheableIdentifier))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

stubInfo->tookSlowPath = true;

JSValue baseValue = JSValue::decode(encodedBase);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

PutPropertySlot slot(baseValue, true, callFrame->codeBlock()->putByIdContext());

baseValue.putInline(globalObject, ident, JSValue::decode(encodedValue), slot);

LOG_IC((ICEvent::OperationPutByIdStrict, baseValue.classInfoOrNull(vm), ident, slot.base() == baseValue));

}

JSC_DEFINE_JIT_OPERATION(operationPutByIdNonStrict, void, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t rawCacheableIdentifier))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

stubInfo->tookSlowPath = true;

JSValue baseValue = JSValue::decode(encodedBase);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

PutPropertySlot slot(baseValue, false, callFrame->codeBlock()->putByIdContext());

baseValue.putInline(globalObject, ident, JSValue::decode(encodedValue), slot);

LOG_IC((ICEvent::OperationPutByIdNonStrict, baseValue.classInfoOrNull(vm), ident, slot.base() == baseValue));

}

JSC_DEFINE_JIT_OPERATION(operationPutByIdDirectStrict, void, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t rawCacheableIdentifier))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

stubInfo->tookSlowPath = true;

JSValue baseValue = JSValue::decode(encodedBase);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

PutPropertySlot slot(baseValue, true, callFrame->codeBlock()->putByIdContext());

CommonSlowPaths::putDirectWithReify(vm, globalObject, asObject(baseValue), ident, JSValue::decode(encodedValue), slot);

LOG_IC((ICEvent::OperationPutByIdDirectStrict, baseValue.classInfoOrNull(vm), ident, slot.base() == baseValue));

}

JSC_DEFINE_JIT_OPERATION(operationPutByIdDirectNonStrict, void, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t rawCacheableIdentifier))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

stubInfo->tookSlowPath = true;

JSValue baseValue = JSValue::decode(encodedBase);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

PutPropertySlot slot(baseValue, false, callFrame->codeBlock()->putByIdContext());

CommonSlowPaths::putDirectWithReify(vm, globalObject, asObject(baseValue), ident, JSValue::decode(encodedValue), slot);

LOG_IC((ICEvent::OperationPutByIdDirectNonStrict, baseValue.classInfoOrNull(vm), ident, slot.base() == baseValue));

}

JSC_DEFINE_JIT_OPERATION(operationPutByIdStrictOptimize, void, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t rawCacheableIdentifier))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

AccessType accessType = static_cast<AccessType>(stubInfo->accessType);

JSValue value = JSValue::decode(encodedValue);

JSValue baseValue = JSValue::decode(encodedBase);

CodeBlock* codeBlock = callFrame->codeBlock();

PutPropertySlot slot(baseValue, true, codeBlock->putByIdContext());

Structure* structure = CommonSlowPaths::originalStructureBeforePut(vm, baseValue);

baseValue.putInline(globalObject, ident, value, slot);

LOG_IC((ICEvent::OperationPutByIdStrictOptimize, baseValue.classInfoOrNull(vm), ident, slot.base() == baseValue));

RETURN_IF_EXCEPTION(scope, void());

if (accessType != static_cast<AccessType>(stubInfo->accessType))

return;

if (stubInfo->considerCachingBy(vm, codeBlock, structure, identifier))

repatchPutBy(globalObject, codeBlock, baseValue, structure, identifier, slot, *stubInfo, PutByKind::ById, PutKind::NotDirect);

}

JSC_DEFINE_JIT_OPERATION(operationPutByIdNonStrictOptimize, void, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t rawCacheableIdentifier))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

AccessType accessType = static_cast<AccessType>(stubInfo->accessType);

JSValue value = JSValue::decode(encodedValue);

JSValue baseValue = JSValue::decode(encodedBase);

CodeBlock* codeBlock = callFrame->codeBlock();

PutPropertySlot slot(baseValue, false, codeBlock->putByIdContext());

Structure* structure = CommonSlowPaths::originalStructureBeforePut(vm, baseValue);

baseValue.putInline(globalObject, ident, value, slot);

LOG_IC((ICEvent::OperationPutByIdNonStrictOptimize, baseValue.classInfoOrNull(vm), ident, slot.base() == baseValue));

RETURN_IF_EXCEPTION(scope, void());

if (accessType != static_cast<AccessType>(stubInfo->accessType))

return;

if (stubInfo->considerCachingBy(vm, codeBlock, structure, identifier))

repatchPutBy(globalObject, codeBlock, baseValue, structure, identifier, slot, *stubInfo, PutByKind::ById, PutKind::NotDirect);

}

JSC_DEFINE_JIT_OPERATION(operationPutByIdDirectStrictOptimize, void, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t rawCacheableIdentifier))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

AccessType accessType = static_cast<AccessType>(stubInfo->accessType);

JSValue value = JSValue::decode(encodedValue);

JSObject* baseObject = asObject(JSValue::decode(encodedBase));

CodeBlock* codeBlock = callFrame->codeBlock();

PutPropertySlot slot(baseObject, true, codeBlock->putByIdContext());

Structure* structure = nullptr;

CommonSlowPaths::putDirectWithReify(vm, globalObject, baseObject, ident, value, slot, &structure);

LOG_IC((ICEvent::OperationPutByIdDirectStrictOptimize, baseObject->classInfo(vm), ident, slot.base() == baseObject));

RETURN_IF_EXCEPTION(scope, void());

if (accessType != static_cast<AccessType>(stubInfo->accessType))

return;

if (stubInfo->considerCachingBy(vm, codeBlock, structure, identifier))

repatchPutBy(globalObject, codeBlock, baseObject, structure, identifier, slot, *stubInfo, PutByKind::ById, PutKind::Direct);

}

JSC_DEFINE_JIT_OPERATION(operationPutByIdDirectNonStrictOptimize, void, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t rawCacheableIdentifier))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

auto scope = DECLARE_THROW_SCOPE(vm);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

AccessType accessType = static_cast<AccessType>(stubInfo->accessType);

JSValue value = JSValue::decode(encodedValue);

JSObject* baseObject = asObject(JSValue::decode(encodedBase));

CodeBlock* codeBlock = callFrame->codeBlock();

PutPropertySlot slot(baseObject, false, codeBlock->putByIdContext());

Structure* structure = nullptr;

CommonSlowPaths::putDirectWithReify(vm, globalObject, baseObject, ident, value, slot, &structure);

LOG_IC((ICEvent::OperationPutByIdDirectNonStrictOptimize, baseObject->classInfo(vm), ident, slot.base() == baseObject));

RETURN_IF_EXCEPTION(scope, void());

if (accessType != static_cast<AccessType>(stubInfo->accessType))

return;

if (stubInfo->considerCachingBy(vm, codeBlock, structure, identifier))

repatchPutBy(globalObject, codeBlock, baseObject, structure, identifier, slot, *stubInfo, PutByKind::ById, PutKind::Direct);

}

template<typename PutPrivateFieldCallback>

ALWAYS_INLINE static void setPrivateField(VM& vm, JSGlobalObject* globalObject, CallFrame* callFrame, JSValue baseValue, CacheableIdentifier identifier, JSValue value, PutPrivateFieldCallback callback)

{

auto scope = DECLARE_THROW_SCOPE(vm);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

ASSERT(ident.isPrivateName());

JSObject* baseObject = baseValue.toObject(globalObject);

RETURN_IF_EXCEPTION(scope, void());

CodeBlock* codeBlock = callFrame->codeBlock();

Structure* oldStructure = baseObject->structure(vm);

PutPropertySlot putSlot(baseObject, true, codeBlock->putByIdContext());

baseObject->setPrivateField(globalObject, ident, value, putSlot);

RETURN_IF_EXCEPTION(scope, void());

callback(vm, codeBlock, oldStructure, putSlot, ident);

}

template<typename PutPrivateFieldCallback>

ALWAYS_INLINE static void definePrivateField(VM& vm, JSGlobalObject* globalObject, CallFrame* callFrame, JSValue baseValue, CacheableIdentifier identifier, JSValue value, PutPrivateFieldCallback callback)

{

auto scope = DECLARE_THROW_SCOPE(vm);

Identifier ident = Identifier::fromUid(vm, identifier.uid());

ASSERT(ident.isPrivateName());

JSObject* baseObject = baseValue.toObject(globalObject);

RETURN_IF_EXCEPTION(scope, void());

CodeBlock* codeBlock = callFrame->codeBlock();

Structure* oldStructure = baseObject->structure(vm);

PutPropertySlot putSlot(baseObject, true, codeBlock->putByIdContext());

baseObject->definePrivateField(globalObject, ident, value, putSlot);

RETURN_IF_EXCEPTION(scope, void());

callback(vm, codeBlock, oldStructure, putSlot, ident);

}

JSC_DEFINE_JIT_OPERATION(operationPutByIdDefinePrivateFieldStrict, void, (JSGlobalObject* globalObject, StructureStubInfo*, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t rawCacheableIdentifier))

{

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

JSValue value = JSValue::decode(encodedValue);

JSValue baseValue = JSValue::decode(encodedBase);

definePrivateField(vm, globalObject, callFrame, baseValue, identifier, value, [](VM&, CodeBlock*, Structure*, PutPropertySlot&, const Identifier&) { });

}

JSC_DEFINE_JIT_OPERATION(operationPutByIdDefinePrivateFieldStrictOptimize, void, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t rawCacheableIdentifier))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

AccessType accessType = static_cast<AccessType>(stubInfo->accessType);

JSValue value = JSValue::decode(encodedValue);

JSValue baseValue = JSValue::decode(encodedBase);

definePrivateField(vm, globalObject, callFrame, baseValue, identifier, value, [=](VM& vm, CodeBlock* codeBlock, Structure* oldStructure, PutPropertySlot& putSlot, const Identifier& ident) {

JSObject* baseObject = asObject(baseValue);

LOG_IC((ICEvent::OperationPutByIdDefinePrivateFieldFieldStrictOptimize, baseObject->classInfo(vm), ident, putSlot.base() == baseObject));

ASSERT_UNUSED(accessType, accessType == static_cast<AccessType>(stubInfo->accessType));

if (stubInfo->considerCachingBy(vm, codeBlock, oldStructure, identifier))

repatchPutBy(globalObject, codeBlock, baseObject, oldStructure, identifier, putSlot, *stubInfo, PutByKind::ById, PutKind::DirectPrivateFieldDefine);

});

}

JSC_DEFINE_JIT_OPERATION(operationPutByIdSetPrivateFieldStrict, void, (JSGlobalObject* globalObject, StructureStubInfo*, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t rawCacheableIdentifier))

{

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

JSValue value = JSValue::decode(encodedValue);

JSValue baseValue = JSValue::decode(encodedBase);

setPrivateField(vm, globalObject, callFrame, baseValue, identifier, value, [](VM&, CodeBlock*, Structure*, PutPropertySlot&, const Identifier&) { });

}

JSC_DEFINE_JIT_OPERATION(operationPutByIdSetPrivateFieldStrictOptimize, void, (JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t rawCacheableIdentifier))

{

SuperSamplerScope superSamplerScope(false);

VM& vm = globalObject->vm();

CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

AccessType accessType = static_cast<AccessType>(stubInfo->accessType);

JSValue value = JSValue::decode(encodedValue);

JSValue baseValue = JSValue::decode(encodedBase);

setPrivateField(vm, globalObject, callFrame, baseValue, identifier, value, [&](VM& vm, CodeBlock* codeBlock, Structure* oldStructure, PutPropertySlot& putSlot, const Identifier& ident) {

JSObject* baseObject = asObject(baseValue);

LOG_IC((ICEvent::OperationPutByIdPutPrivateFieldFieldStrictOptimize, baseObject->classInfo(vm), ident, putSlot.base() == baseObject));

ASSERT_UNUSED(accessType, accessType == static_cast<AccessType>(stubInfo->accessType));

if (stubInfo->considerCachingBy(vm, codeBlock, oldStructure, identifier))

repatchPutBy(globalObject, codeBlock, baseObject, oldStructure, identifier, putSlot, *stubInfo, PutByKind::ById, PutKind::DirectPrivateFieldSet);

});

}

static void putByVal(JSGlobalObject* globalObject, JSValue baseValue, JSValue subscript, JSValue value, ArrayProfile* arrayProfile, ECMAMode ecmaMode)

{

VM& vm = globalObject->vm();

auto scope = DECLARE_THROW_SCOPE(vm);

if (std::optional<uint32_t> index = subscript.tryGetAsUint32Index()) {

uint32_t i = *index;

if (baseValue.isObject()) {

JSObject* object = asObject(baseValue);

if (object->trySetIndexQuickly(vm, i, value, arrayProfile))

return;

if (arrayProfile)

arrayProfile->setOutOfBounds();

scope.release();

object->methodTable(vm)->putByIndex(object, globalObject, i, value, ecmaMode.isStrict());

return;

}

scope.release();

baseValue.putByIndex(globalObject, i, value, ecmaMode.isStrict());

return;

}

if (subscript.isNumber()) {

if (baseValue.isObject()) {

if (arrayProfile)

arrayProfile->setOutOfBounds();

}

}

auto property = subscript.toPropertyKey(globalObject);

// Don't put to an object if toString threw an exception.

RETURN_IF_EXCEPTION(scope, void());

scope.release();

PutPropertySlot slot(baseValue, ecmaMode.isStrict());

baseValue.putInline(globalObject, property, value, slot);

}

static void directPutByVal(JSGlobalObject* globalObject, JSObject* baseObject, JSValue subscript, JSValue value, ArrayProfile* arrayProfile, ECMAMode ecmaMode)

{

VM& vm = globalObject->vm();

auto scope = DECLARE_THROW_SCOPE(vm);

if (std::optional<uint32_t> maybeIndex = subscript.tryGetAsUint32Index()) {

uint32_t index = *maybeIndex;

switch (baseObject->indexingType()) {

case ALL_INT32_INDEXING_TYPES:

case ALL_DOUBLE_INDEXING_TYPES:

case ALL_CONTIGUOUS_INDEXING_TYPES:

case ALL_ARRAY_STORAGE_INDEXING_TYPES:

if (index < baseObject->butterfly()->vectorLength())

break;

FALLTHROUGH;

default:

if (arrayProfile)

arrayProfile->setOutOfBounds();

break;

}

scope.release();

baseObject->putDirectIndex(globalObject, index, value, 0, ecmaMode.isStrict() ? PutDirectIndexShouldThrow : PutDirectIndexShouldNotThrow);

return;

}

// Don't put to an object if toString threw an exception.

auto property = subscript.toPropertyKey(globalObject);

RETURN_IF_EXCEPTION(scope, void());