mirror of
https://gitee.com/openharmony/arkcompiler_ets_runtime
synced 2024-11-27 12:10:47 +00:00
f86405e0ca
Issue: https://gitee.com/openharmony/arkcompiler_runtime_core/issues/IA8WK8 1. adapt interpreter for the new isa callruntime.SuperCallForwardAllArgs 2. adapt asm-interpreter for callruntime.SuperCallForwardAllArgs 3. adapt jit/aot for callruntime.SuperCallForwardAllArgs 4. adapt baseline jit for callruntime.SuperCallForwardAllArgs 5. remove the constraint for functions with zero icSlotSize so that the default ctor for derivative class can be compiled into native code. Signed-off-by: qiuyu <qiuyu22@huawei.com> Change-Id: I346da77403de0d14f53532bc51c40a3ca27fc689
1292 lines
52 KiB
C++
1292 lines
52 KiB
C++
/*
|
|
* Copyright (c) 2021 Huawei Device Co., Ltd.
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "ecmascript/interpreter/slow_runtime_stub.h"
|
|
|
|
#include "ecmascript/interpreter/interpreter-inl.h"
|
|
#include "ecmascript/stubs/runtime_stubs-inl.h"
|
|
|
|
namespace panda::ecmascript {
|
|
JSTaggedValue SlowRuntimeStub::CallSpread(JSThread *thread, JSTaggedValue func, JSTaggedValue obj,
|
|
JSTaggedValue array)
|
|
{
|
|
INTERPRETER_TRACE(thread, CallSpread);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> jsFunc(thread, func);
|
|
JSHandle<JSTaggedValue> jsArray(thread, array);
|
|
JSHandle<JSTaggedValue> taggedObj(thread, obj);
|
|
return RuntimeStubs::RuntimeCallSpread(thread, jsFunc, taggedObj, jsArray);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Neg(JSThread *thread, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, Neg);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> inputTag(thread, value);
|
|
return RuntimeStubs::RuntimeNeg(thread, inputTag);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::AsyncFunctionEnter(JSThread *thread)
|
|
{
|
|
INTERPRETER_TRACE(thread, AsyncFunctionEnter);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
return RuntimeStubs::RuntimeAsyncFunctionEnter(thread);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::ToNumber(JSThread *thread, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, Tonumber);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> number(thread, value);
|
|
// may return exception
|
|
return RuntimeStubs::RuntimeToNumber(thread, number);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::ToNumeric(JSThread *thread, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, Tonumeric);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> numeric(thread, value);
|
|
// may return exception
|
|
return RuntimeStubs::RuntimeToNumeric(thread, numeric);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Not(JSThread *thread, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, Not);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> inputTag(thread, value);
|
|
return RuntimeStubs::RuntimeNot(thread, inputTag);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Inc(JSThread *thread, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, Inc);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> inputTag(thread, value);
|
|
return RuntimeStubs::RuntimeInc(thread, inputTag);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Dec(JSThread *thread, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, Dec);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> inputTag(thread, value);
|
|
return RuntimeStubs::RuntimeDec(thread, inputTag);
|
|
}
|
|
|
|
void SlowRuntimeStub::Throw(JSThread *thread, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, Throw);
|
|
RuntimeStubs::RuntimeThrow(thread, value);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::GetPropIterator(JSThread *thread, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, GetPropIterator);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objHandle(thread, value);
|
|
return RuntimeStubs::RuntimeGetPropIterator(thread, objHandle);
|
|
}
|
|
|
|
void SlowRuntimeStub::ThrowConstAssignment(JSThread *thread, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, ThrowConstAssignment);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<EcmaString> name(thread, value.GetTaggedObject());
|
|
return RuntimeStubs::RuntimeThrowConstAssignment(thread, name);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Add2(JSThread *thread, JSTaggedValue left, JSTaggedValue right)
|
|
{
|
|
INTERPRETER_TRACE(thread, Add2);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> leftValue(thread, left);
|
|
JSHandle<JSTaggedValue> rightValue(thread, right);
|
|
return RuntimeStubs::RuntimeAdd2(thread, leftValue, rightValue);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Sub2(JSThread *thread, JSTaggedValue left, JSTaggedValue right)
|
|
{
|
|
INTERPRETER_TRACE(thread, Sub2);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> leftTag(thread, left);
|
|
JSHandle<JSTaggedValue> rightTag(thread, right);
|
|
return RuntimeStubs::RuntimeSub2(thread, leftTag, rightTag);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Mul2(JSThread *thread, JSTaggedValue left, JSTaggedValue right)
|
|
{
|
|
INTERPRETER_TRACE(thread, Mul2);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> leftTag(thread, left);
|
|
JSHandle<JSTaggedValue> rightTag(thread, right);
|
|
return RuntimeStubs::RuntimeMul2(thread, leftTag, rightTag);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Div2(JSThread *thread, JSTaggedValue left, JSTaggedValue right)
|
|
{
|
|
INTERPRETER_TRACE(thread, Div2);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> leftTag(thread, left);
|
|
JSHandle<JSTaggedValue> rightTag(thread, right);
|
|
return RuntimeStubs::RuntimeDiv2(thread, leftTag, rightTag);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Mod2(JSThread *thread, JSTaggedValue left, JSTaggedValue right)
|
|
{
|
|
INTERPRETER_TRACE(thread, Mod2);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> leftTag(thread, left);
|
|
JSHandle<JSTaggedValue> rightTag(thread, right);
|
|
return RuntimeStubs::RuntimeMod2(thread, leftTag, rightTag);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Eq(JSThread *thread, JSTaggedValue left, JSTaggedValue right)
|
|
{
|
|
INTERPRETER_TRACE(thread, Eq);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> leftValue(thread, left);
|
|
JSHandle<JSTaggedValue> rightValue(thread, right);
|
|
return RuntimeStubs::RuntimeEq(thread, leftValue, rightValue);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::NotEq(JSThread *thread, JSTaggedValue left, JSTaggedValue right)
|
|
{
|
|
INTERPRETER_TRACE(thread, NotEq);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> leftValue(thread, left);
|
|
JSHandle<JSTaggedValue> rightValue(thread, right);
|
|
return RuntimeStubs::RuntimeNotEq(thread, leftValue, rightValue);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Less(JSThread *thread, JSTaggedValue left, JSTaggedValue right)
|
|
{
|
|
INTERPRETER_TRACE(thread, Less);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> leftValue(thread, left);
|
|
JSHandle<JSTaggedValue> rightValue(thread, right);
|
|
return RuntimeStubs::RuntimeLess(thread, leftValue, rightValue);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::LessEq(JSThread *thread, JSTaggedValue left, JSTaggedValue right)
|
|
{
|
|
INTERPRETER_TRACE(thread, LessEq);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> leftValue(thread, left);
|
|
JSHandle<JSTaggedValue> rightValue(thread, right);
|
|
return RuntimeStubs::RuntimeLessEq(thread, leftValue, rightValue);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Greater(JSThread *thread, JSTaggedValue left, JSTaggedValue right)
|
|
{
|
|
INTERPRETER_TRACE(thread, Greater);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> leftValue(thread, left);
|
|
JSHandle<JSTaggedValue> rightValue(thread, right);
|
|
return RuntimeStubs::RuntimeGreater(thread, leftValue, rightValue);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::GreaterEq(JSThread *thread, JSTaggedValue left, JSTaggedValue right)
|
|
{
|
|
INTERPRETER_TRACE(thread, GreaterEq);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> leftValue(thread, left);
|
|
JSHandle<JSTaggedValue> rightValue(thread, right);
|
|
return RuntimeStubs::RuntimeGreaterEq(thread, leftValue, rightValue);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Shl2(JSThread *thread, JSTaggedValue left, JSTaggedValue right)
|
|
{
|
|
INTERPRETER_TRACE(thread, Shl2);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> leftTag(thread, left);
|
|
JSHandle<JSTaggedValue> rightTag(thread, right);
|
|
return RuntimeStubs::RuntimeShl2(thread, leftTag, rightTag);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Shr2(JSThread *thread, JSTaggedValue left, JSTaggedValue right)
|
|
{
|
|
INTERPRETER_TRACE(thread, Shr2);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> leftTag(thread, left);
|
|
JSHandle<JSTaggedValue> rightTag(thread, right);
|
|
return RuntimeStubs::RuntimeShr2(thread, leftTag, rightTag);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Ashr2(JSThread *thread, JSTaggedValue left, JSTaggedValue right)
|
|
{
|
|
INTERPRETER_TRACE(thread, Ashr2);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> leftTag(thread, left);
|
|
JSHandle<JSTaggedValue> rightTag(thread, right);
|
|
return RuntimeStubs::RuntimeAshr2(thread, leftTag, rightTag);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::And2(JSThread *thread, JSTaggedValue left, JSTaggedValue right)
|
|
{
|
|
INTERPRETER_TRACE(thread, And2);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
JSHandle<JSTaggedValue> leftTag(thread, left);
|
|
JSHandle<JSTaggedValue> rightTag(thread, right);
|
|
return RuntimeStubs::RuntimeAnd2(thread, leftTag, rightTag);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Or2(JSThread *thread, JSTaggedValue left, JSTaggedValue right)
|
|
{
|
|
INTERPRETER_TRACE(thread, Or2);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> leftTag(thread, left);
|
|
JSHandle<JSTaggedValue> rightTag(thread, right);
|
|
return RuntimeStubs::RuntimeOr2(thread, leftTag, rightTag);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Xor2(JSThread *thread, JSTaggedValue left, JSTaggedValue right)
|
|
{
|
|
INTERPRETER_TRACE(thread, Xor2);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> leftTag(thread, left);
|
|
JSHandle<JSTaggedValue> rightTag(thread, right);
|
|
return RuntimeStubs::RuntimeXor2(thread, leftTag, rightTag);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::ToJSTaggedValueWithInt32(JSThread *thread, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, ToJSTaggedValueWithInt32);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
return RuntimeStubs::RuntimeToJSTaggedValueWithInt32(thread, valueHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::ToJSTaggedValueWithUint32(JSThread *thread, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, ToJSTaggedValueWithUint32);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
return RuntimeStubs::RuntimeToJSTaggedValueWithUint32(thread, valueHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::DelObjProp(JSThread *thread, JSTaggedValue obj, JSTaggedValue prop)
|
|
{
|
|
INTERPRETER_TRACE(thread, Delobjprop);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objHandle(thread, obj);
|
|
JSHandle<JSTaggedValue> propHandle(thread, prop);
|
|
return RuntimeStubs::RuntimeDelObjProp(thread, objHandle, propHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::NewObjRange(JSThread *thread, JSTaggedValue func, JSTaggedValue newTarget,
|
|
uint16_t firstArgIdx, uint16_t length)
|
|
{
|
|
INTERPRETER_TRACE(thread, NewobjRange);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> funcHandle(thread, func);
|
|
JSHandle<JSTaggedValue> newTargetHandle(thread, newTarget);
|
|
return RuntimeStubs::RuntimeNewObjRange(thread, funcHandle, newTargetHandle, firstArgIdx, length);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::CreateObjectWithExcludedKeys(JSThread *thread, uint16_t numKeys, JSTaggedValue objVal,
|
|
uint16_t firstArgRegIdx)
|
|
{
|
|
INTERPRETER_TRACE(thread, CreateObjectWithExcludedKeys);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> obj(thread, objVal);
|
|
return RuntimeStubs::RuntimeCreateObjectWithExcludedKeys(thread, numKeys, obj, firstArgRegIdx);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Exp(JSThread *thread, JSTaggedValue base, JSTaggedValue exponent)
|
|
{
|
|
INTERPRETER_TRACE(thread, Exp);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
return RuntimeStubs::RuntimeExp(thread, base, exponent);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::IsIn(JSThread *thread, JSTaggedValue prop, JSTaggedValue obj)
|
|
{
|
|
INTERPRETER_TRACE(thread, IsIn);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> propHandle(thread, prop);
|
|
JSHandle<JSTaggedValue> objHandle(thread, obj);
|
|
return RuntimeStubs::RuntimeIsIn(thread, propHandle, objHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::Instanceof(JSThread *thread, JSTaggedValue obj, JSTaggedValue target)
|
|
{
|
|
INTERPRETER_TRACE(thread, Instanceof);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objHandle(thread, obj);
|
|
JSHandle<JSTaggedValue> targetHandle(thread, target);
|
|
return RuntimeStubs::RuntimeInstanceof(thread, objHandle, targetHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::InstanceofByHandler(JSThread *thread, JSTaggedValue target, JSTaggedValue object,
|
|
JSTaggedValue instOfHandler)
|
|
{
|
|
INTERPRETER_TRACE(thread, InstanceofByHandler);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objectHandle(thread, object);
|
|
JSHandle<JSTaggedValue> targetHandle(thread, target);
|
|
JSHandle<JSTaggedValue> instOfHandle(thread, instOfHandler);
|
|
|
|
return RuntimeStubs::RuntimeInstanceofByHandler(thread, targetHandle, objectHandle, instOfHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::NewLexicalEnv(JSThread *thread, uint16_t numVars)
|
|
{
|
|
INTERPRETER_TRACE(thread, Newlexenv);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
return RuntimeStubs::RuntimeNewLexicalEnv(thread, numVars);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::NewSendableEnv(JSThread *thread, uint16_t numVars)
|
|
{
|
|
INTERPRETER_TRACE(thread, NewSendableEnv);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
return RuntimeStubs::RuntimeNewSendableEnv(thread, numVars);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::NewLexicalEnvWithName(JSThread *thread, uint16_t numVars, uint16_t scopeId)
|
|
{
|
|
INTERPRETER_TRACE(thread, NewlexenvwithName);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
return RuntimeStubs::RuntimeNewLexicalEnvWithName(thread, numVars, scopeId);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::CreateIterResultObj(JSThread *thread, JSTaggedValue value, JSTaggedValue flag)
|
|
{
|
|
INTERPRETER_TRACE(thread, CreateIterResultObj);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
return RuntimeStubs::RuntimeCreateIterResultObj(thread, valueHandle, flag);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::CreateGeneratorObj(JSThread *thread, JSTaggedValue genFunc)
|
|
{
|
|
INTERPRETER_TRACE(thread, CreateGeneratorObj);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> generatorFunction(thread, genFunc);
|
|
return RuntimeStubs::RuntimeCreateGeneratorObj(thread, generatorFunction);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::CreateAsyncGeneratorObj(JSThread *thread, JSTaggedValue genFunc)
|
|
{
|
|
INTERPRETER_TRACE(thread, CreateAsyncGeneratorObj);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> asyncGeneratorFunction(thread, genFunc);
|
|
return RuntimeStubs::RuntimeCreateAsyncGeneratorObj(thread, asyncGeneratorFunction);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::SuspendGenerator(JSThread *thread, JSTaggedValue genObj, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, SuspendGenerator);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> genObjHandle(thread, genObj);
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
return RuntimeStubs::RuntimeSuspendGenerator(thread, genObjHandle, valueHandle);
|
|
}
|
|
|
|
void SlowRuntimeStub::SetGeneratorState(JSThread *thread, JSTaggedValue genObj, int32_t index)
|
|
{
|
|
INTERPRETER_TRACE(thread, SetGeneratorState);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> genObjHandle(thread, genObj);
|
|
return RuntimeStubs::RuntimeSetGeneratorState(thread, genObjHandle, index);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::AsyncFunctionAwaitUncaught(JSThread *thread, JSTaggedValue asyncFuncObj,
|
|
JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, AsyncFunctionAwaitUncaught);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
JSHandle<JSTaggedValue> asyncFuncObjHandle(thread, asyncFuncObj);
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
|
|
return RuntimeStubs::RuntimeAsyncFunctionAwaitUncaught(thread, asyncFuncObjHandle, valueHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::AsyncFunctionResolveOrReject(JSThread *thread, JSTaggedValue asyncFuncObj,
|
|
JSTaggedValue value, bool is_resolve)
|
|
{
|
|
INTERPRETER_TRACE(thread, AsyncFunctionResolveOrReject);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> asyncFuncObjHandle(thread, asyncFuncObj);
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
return RuntimeStubs::RuntimeAsyncFunctionResolveOrReject(thread, asyncFuncObjHandle, valueHandle, is_resolve);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::NewObjApply(JSThread *thread, JSTaggedValue func, JSTaggedValue array)
|
|
{
|
|
INTERPRETER_TRACE(thread, NewObjApply);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> funcHandle(thread, func);
|
|
JSHandle<JSTaggedValue> jsArray(thread, array);
|
|
return RuntimeStubs::RuntimeNewObjApply(thread, funcHandle, jsArray);
|
|
}
|
|
|
|
void SlowRuntimeStub::ThrowUndefinedIfHole(JSThread *thread, JSTaggedValue obj)
|
|
{
|
|
INTERPRETER_TRACE(thread, ThrowUndefinedIfHole);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<EcmaString> name(thread, obj);
|
|
return RuntimeStubs::RuntimeThrowUndefinedIfHole(thread, name);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::ThrowIfSuperNotCorrectCall(JSThread *thread, uint16_t index, JSTaggedValue thisValue)
|
|
{
|
|
INTERPRETER_TRACE(thread, ThrowIfSuperNotCorrectCall);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
return RuntimeStubs::RuntimeThrowIfSuperNotCorrectCall(thread, index, thisValue);
|
|
}
|
|
|
|
void SlowRuntimeStub::ThrowIfNotObject(JSThread *thread)
|
|
{
|
|
INTERPRETER_TRACE(thread, ThrowIfNotObject);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
THROW_TYPE_ERROR(thread, "Inner return result is not object");
|
|
}
|
|
|
|
void SlowRuntimeStub::ThrowThrowNotExists(JSThread *thread)
|
|
{
|
|
INTERPRETER_TRACE(thread, ThrowThrowNotExists);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
return RuntimeStubs::RuntimeThrowIfNotObject(thread);
|
|
}
|
|
|
|
void SlowRuntimeStub::ThrowPatternNonCoercible(JSThread *thread)
|
|
{
|
|
INTERPRETER_TRACE(thread, ThrowPatternNonCoercible);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
return RuntimeStubs::RuntimeThrowPatternNonCoercible(thread);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::StOwnByName(JSThread *thread, JSTaggedValue obj, JSTaggedValue prop, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, StOwnByName);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objHandle(thread, obj);
|
|
JSHandle<JSTaggedValue> propHandle(thread, prop);
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
return RuntimeStubs::RuntimeStOwnByName(thread, objHandle, propHandle, valueHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::StOwnByNameWithNameSet(JSThread *thread, JSTaggedValue obj, JSTaggedValue prop,
|
|
JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, StOwnByName);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objHandle(thread, obj);
|
|
JSHandle<JSTaggedValue> propHandle(thread, prop);
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
return RuntimeStubs::RuntimeStOwnByNameWithNameSet(thread, objHandle, propHandle, valueHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::StOwnByIndex(JSThread *thread, JSTaggedValue obj, uint32_t idx, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, StOwnById);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objHandle(thread, obj);
|
|
JSHandle<JSTaggedValue> idxHandle(thread, JSTaggedValue(idx));
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
return RuntimeStubs::RuntimeStOwnByIndex(thread, objHandle, idxHandle, valueHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::StOwnByValue(JSThread *thread, JSTaggedValue obj, JSTaggedValue key, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, StOwnByValue);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objHandle(thread, obj);
|
|
JSHandle<JSTaggedValue> keyHandle(thread, key);
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
return RuntimeStubs::RuntimeStOwnByValue(thread, objHandle, keyHandle, valueHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::StOwnByValueWithNameSet(JSThread *thread, JSTaggedValue obj, JSTaggedValue key,
|
|
JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, StOwnByValue);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objHandle(thread, obj);
|
|
JSHandle<JSTaggedValue> keyHandle(thread, key);
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
return RuntimeStubs::RuntimeStOwnByValueWithNameSet(thread, objHandle, keyHandle, valueHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::CreateEmptyArray(JSThread *thread, ObjectFactory *factory, JSHandle<GlobalEnv> globalEnv)
|
|
{
|
|
INTERPRETER_TRACE(thread, CreateEmptyArray);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
return RuntimeStubs::RuntimeCreateEmptyArray(thread, factory, globalEnv);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::CreateEmptyObject(JSThread *thread, ObjectFactory *factory,
|
|
JSHandle<GlobalEnv> globalEnv)
|
|
{
|
|
INTERPRETER_TRACE(thread, CreateEmptyObject);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
return RuntimeStubs::RuntimeCreateEmptyObject(thread, factory, globalEnv);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::CreateObjectWithBuffer(JSThread *thread, ObjectFactory *factory, JSObject *literal)
|
|
{
|
|
INTERPRETER_TRACE(thread, CreateObjectWithBuffer);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSObject> obj(thread, literal);
|
|
return RuntimeStubs::RuntimeCreateObjectWithBuffer(thread, factory, obj);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::CreateObjectHavingMethod(JSThread *thread, ObjectFactory *factory, JSObject *literal,
|
|
JSTaggedValue env)
|
|
{
|
|
INTERPRETER_TRACE(thread, CreateObjectHavingMethod);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSObject> obj(thread, literal);
|
|
JSHandle<JSTaggedValue> envi(thread, env);
|
|
return RuntimeStubs::RuntimeCreateObjectHavingMethod(thread, factory, obj, envi);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::SetObjectWithProto(JSThread *thread, JSTaggedValue proto, JSTaggedValue obj)
|
|
{
|
|
INTERPRETER_TRACE(thread, SetObjectWithProto);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> protoHandle(thread, proto);
|
|
JSHandle<JSObject> objHandle(thread, obj);
|
|
return RuntimeStubs::RuntimeSetObjectWithProto(thread, protoHandle, objHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::IterNext(JSThread *thread, JSTaggedValue iter)
|
|
{
|
|
INTERPRETER_TRACE(thread, IterNext);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> iterHandle(thread, iter);
|
|
return RuntimeStubs::RuntimeIterNext(thread, iterHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::CloseIterator(JSThread *thread, JSTaggedValue iter)
|
|
{
|
|
INTERPRETER_TRACE(thread, CloseIterator);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> iterHandle(thread, iter);
|
|
return RuntimeStubs::RuntimeCloseIterator(thread, iterHandle);
|
|
}
|
|
|
|
void SlowRuntimeStub::StModuleVar(JSThread *thread, int32_t index, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, StModuleVar);
|
|
[[maybe_unused]] EcmaHandleScope scope(thread);
|
|
|
|
return RuntimeStubs::RuntimeStModuleVar(thread, index, value);
|
|
}
|
|
|
|
void SlowRuntimeStub::StModuleVar(JSThread *thread, JSTaggedValue key, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, StModuleVar);
|
|
[[maybe_unused]] EcmaHandleScope scope(thread);
|
|
|
|
return RuntimeStubs::RuntimeStModuleVar(thread, key, value);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::LdLocalModuleVar(JSThread *thread, int32_t index)
|
|
{
|
|
RUNTIME_TRACE(thread, LdLocalModuleVarByIndex);
|
|
[[maybe_unused]] EcmaHandleScope scope(thread);
|
|
|
|
return RuntimeStubs::RuntimeLdLocalModuleVar(thread, index);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::LdExternalModuleVar(JSThread *thread, int32_t index)
|
|
{
|
|
RUNTIME_TRACE(thread, LdExternalModuleVarByIndex);
|
|
[[maybe_unused]] EcmaHandleScope scope(thread);
|
|
|
|
return RuntimeStubs::RuntimeLdExternalModuleVar(thread, index);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::LdModuleVar(JSThread *thread, JSTaggedValue key, bool inner)
|
|
{
|
|
INTERPRETER_TRACE(thread, LdModuleVar);
|
|
[[maybe_unused]] EcmaHandleScope scope(thread);
|
|
|
|
return RuntimeStubs::RuntimeLdModuleVar(thread, key, inner);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::CreateRegExpWithLiteral(JSThread *thread, JSTaggedValue pattern, uint8_t flags)
|
|
{
|
|
INTERPRETER_TRACE(thread, CreateRegExpWithLiteral);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> patternHandle(thread, pattern);
|
|
return RuntimeStubs::RuntimeCreateRegExpWithLiteral(thread, patternHandle, flags);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::CreateArrayWithBuffer(JSThread *thread, ObjectFactory *factory, JSArray *literal)
|
|
{
|
|
INTERPRETER_TRACE(thread, CreateArrayWithBuffer);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> array(thread, literal);
|
|
return RuntimeStubs::RuntimeCreateArrayWithBuffer(thread, factory, array);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::GetTemplateObject(JSThread *thread, JSTaggedValue literal)
|
|
{
|
|
INTERPRETER_TRACE(thread, GetTemplateObject);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> templateLiteral(thread, literal);
|
|
return RuntimeStubs::RuntimeGetTemplateObject(thread, templateLiteral);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::GetNextPropName(JSThread *thread, JSTaggedValue iter)
|
|
{
|
|
INTERPRETER_TRACE(thread, GetNextPropName);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> iterator(thread, iter);
|
|
return RuntimeStubs::RuntimeGetNextPropName(thread, iterator);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::CopyDataProperties(JSThread *thread, JSTaggedValue dst, JSTaggedValue src)
|
|
{
|
|
INTERPRETER_TRACE(thread, CopyDataProperties);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> dstHandle(thread, dst);
|
|
JSHandle<JSTaggedValue> srcHandle(thread, src);
|
|
return RuntimeStubs::RuntimeCopyDataProperties(thread, dstHandle, srcHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::GetIteratorNext(JSThread *thread, JSTaggedValue obj, JSTaggedValue method)
|
|
{
|
|
RUNTIME_TRACE(thread, GetIteratorNext);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> iter(thread, obj);
|
|
JSHandle<JSTaggedValue> next(thread, method);
|
|
return RuntimeStubs::RuntimeGetIteratorNext(thread, iter, next);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::GetUnmapedArgs(JSThread *thread, JSTaggedType *sp, uint32_t actualNumArgs,
|
|
uint32_t startIdx)
|
|
{
|
|
INTERPRETER_TRACE(thread, GetUnmapedArgs);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
return RuntimeStubs::RuntimeGetUnmapedArgs(thread, sp, actualNumArgs, startIdx);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::CopyRestArgs(JSThread *thread, JSTaggedType *sp, uint32_t restNumArgs, uint32_t startIdx)
|
|
{
|
|
INTERPRETER_TRACE(thread, Copyrestargs);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
return RuntimeStubs::RuntimeCopyRestArgs(thread, sp, restNumArgs, startIdx);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::GetIterator(JSThread *thread, JSTaggedValue obj)
|
|
{
|
|
INTERPRETER_TRACE(thread, GetIterator);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objHandle(thread, obj);
|
|
return RuntimeStubs::RuntimeGetIterator(thread, objHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::GetAsyncIterator(JSThread *thread, JSTaggedValue obj)
|
|
{
|
|
INTERPRETER_TRACE(thread, GetAsyncIterator);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objHandle(thread, obj);
|
|
return RuntimeStubs::RuntimeGetAsyncIterator(thread, objHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::DefineGetterSetterByValue(JSThread *thread, JSTaggedValue obj, JSTaggedValue prop,
|
|
JSTaggedValue getter, JSTaggedValue setter, bool flag)
|
|
{
|
|
INTERPRETER_TRACE(thread, DefineGetterSetterByValue);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSObject> objHandle(thread, obj);
|
|
JSHandle<JSTaggedValue> propHandle(thread, prop);
|
|
JSHandle<JSTaggedValue> getterHandle(thread, getter);
|
|
JSHandle<JSTaggedValue> setterHandle(thread, setter);
|
|
JSHandle<JSTaggedValue> func(thread, JSTaggedValue::Undefined());
|
|
return RuntimeStubs::RuntimeDefineGetterSetterByValue(thread, objHandle, propHandle,
|
|
getterHandle, setterHandle, flag,
|
|
func, 0);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::LdObjByIndex(JSThread *thread, JSTaggedValue obj, uint32_t idx, bool callGetter,
|
|
JSTaggedValue receiver)
|
|
{
|
|
INTERPRETER_TRACE(thread, LdObjByIndex);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objHandle(thread, obj);
|
|
return RuntimeStubs::RuntimeLdObjByIndex(thread, objHandle, idx, callGetter, receiver);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::StObjByIndex(JSThread *thread, JSTaggedValue obj, uint32_t idx, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, StObjByIndex);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objHandle(thread, obj);
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
return RuntimeStubs::RuntimeStObjByIndex(thread, objHandle, idx, valueHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::LdObjByName(JSThread *thread, JSTaggedValue obj, JSTaggedValue prop, bool callGetter,
|
|
JSTaggedValue receiver)
|
|
{
|
|
INTERPRETER_TRACE(thread, LdObjByName);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
return RuntimeStubs::RuntimeLdObjByName(thread, obj, prop, callGetter, receiver);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::StObjByName(JSThread *thread, JSTaggedValue obj, JSTaggedValue prop, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, StObjByName);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objHandle(thread, obj);
|
|
JSHandle<JSTaggedValue> propHandle(thread, prop);
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
return RuntimeStubs::RuntimeStObjByName(thread, objHandle, propHandle, valueHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::LdObjByValue(JSThread *thread, JSTaggedValue obj, JSTaggedValue prop, bool callGetter,
|
|
JSTaggedValue receiver)
|
|
{
|
|
INTERPRETER_TRACE(thread, LdObjByValue);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objHandle(thread, obj);
|
|
JSHandle<JSTaggedValue> propHandle(thread, prop);
|
|
return RuntimeStubs::RuntimeLdObjByValue(thread, objHandle, propHandle, callGetter, receiver);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::StObjByValue(JSThread *thread, JSTaggedValue obj, JSTaggedValue prop,
|
|
JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, StObjByValue);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objHandle(thread, obj);
|
|
JSHandle<JSTaggedValue> propHandle(thread, prop);
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
return RuntimeStubs::RuntimeStObjByValue(thread, objHandle, propHandle, valueHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::TryLdGlobalByNameFromGlobalProto(JSThread *thread, JSTaggedValue global,
|
|
JSTaggedValue prop)
|
|
{
|
|
INTERPRETER_TRACE(thread, Trygetobjprop);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> obj(thread, global.GetTaggedObject()->GetClass()->GetPrototype());
|
|
JSHandle<JSTaggedValue> propHandle(thread, prop);
|
|
return RuntimeStubs::RuntimeTryLdGlobalByName(thread, obj, propHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::TryStGlobalByName(JSThread *thread, JSTaggedValue prop)
|
|
{
|
|
INTERPRETER_TRACE(thread, TryStGlobalByName);
|
|
// If fast path is fail, not need slow path, just throw error.
|
|
return ThrowReferenceError(thread, prop, " is not defined");
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::LdGlobalVarFromGlobalProto(JSThread *thread, JSTaggedValue global, JSTaggedValue prop)
|
|
{
|
|
INTERPRETER_TRACE(thread, LdGlobalVar);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objHandle(thread, global);
|
|
JSHandle<JSTaggedValue> propHandle(thread, prop);
|
|
return RuntimeStubs::RuntimeLdGlobalVarFromProto(thread, objHandle, propHandle); // After checked global itself.
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::StGlobalVar(JSThread *thread, JSTaggedValue prop, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, StGlobalVar);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> propHandle(thread, prop);
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
return RuntimeStubs::RuntimeStGlobalVar(thread, propHandle, valueHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::TryUpdateGlobalRecord(JSThread *thread, JSTaggedValue prop, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, TryUpdateGlobalRecord);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
return RuntimeStubs::RuntimeTryUpdateGlobalRecord(thread, prop, value);
|
|
}
|
|
|
|
// return box
|
|
JSTaggedValue SlowRuntimeStub::LdGlobalRecord(JSThread *thread, JSTaggedValue key)
|
|
{
|
|
INTERPRETER_TRACE(thread, LdGlobalRecord);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
return RuntimeStubs::RuntimeLdGlobalRecord(thread, key);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::StGlobalRecord(JSThread *thread, JSTaggedValue prop, JSTaggedValue value, bool isConst)
|
|
{
|
|
INTERPRETER_TRACE(thread, StGlobalRecord);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> propHandle(thread, prop);
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
return RuntimeStubs::RuntimeStGlobalRecord(thread, propHandle, valueHandle, isConst);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::ThrowReferenceError(JSThread *thread, JSTaggedValue prop, const char *desc)
|
|
{
|
|
INTERPRETER_TRACE(thread, ThrowReferenceError);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> propHandle(thread, prop);
|
|
return RuntimeStubs::RuntimeThrowReferenceError(thread, propHandle, desc);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::ThrowTypeError(JSThread *thread, const char *message)
|
|
{
|
|
INTERPRETER_TRACE(thread, ThrowTypeError);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
return RuntimeStubs::RuntimeThrowTypeError(thread, message);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::ThrowSyntaxError(JSThread *thread, const char *message)
|
|
{
|
|
INTERPRETER_TRACE(thread, ThrowSyntaxError);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
return RuntimeStubs::RuntimeThrowSyntaxError(thread, message);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::StArraySpread(JSThread *thread, JSTaggedValue dst, JSTaggedValue index,
|
|
JSTaggedValue src)
|
|
{
|
|
INTERPRETER_TRACE(thread, StArraySpread);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> dstHandle(thread, dst);
|
|
JSHandle<JSTaggedValue> srcHandle(thread, src);
|
|
return RuntimeStubs::RuntimeStArraySpread(thread, dstHandle, index, srcHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::DefineFunc(JSThread *thread, JSTaggedValue constPool, uint16_t methodId,
|
|
JSTaggedValue module, uint16_t length, JSTaggedValue env,
|
|
JSTaggedValue homeObject)
|
|
{
|
|
INTERPRETER_TRACE(thread, DefineFunc);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
JSHandle<JSTaggedValue> constpoolHandle(thread, constPool);
|
|
JSHandle<JSTaggedValue> moduleHandle(thread, module);
|
|
JSHandle<JSTaggedValue> envHandle(thread, env);
|
|
JSHandle<JSTaggedValue> homeObjectHandle(thread, homeObject);
|
|
return RuntimeStubs::RuntimeDefinefunc(thread, constpoolHandle, methodId, moduleHandle,
|
|
length, envHandle, homeObjectHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::GetSuperConstructor(JSThread *thread, JSTaggedValue ctor)
|
|
{
|
|
INTERPRETER_TRACE(thread, GetSuperConstructor);
|
|
JSHandle<JSTaggedValue> ctorHandle(thread, ctor);
|
|
JSHandle<JSTaggedValue> superConstructor(thread, JSTaggedValue::GetPrototype(thread, ctorHandle));
|
|
RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
|
|
return superConstructor.GetTaggedValue();
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::SuperCall(JSThread *thread, JSTaggedValue func, JSTaggedValue newTarget,
|
|
uint16_t firstVRegIdx, uint16_t length)
|
|
{
|
|
INTERPRETER_TRACE(thread, SuperCall);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> funcHandle(thread, func);
|
|
JSHandle<JSTaggedValue> newTargetHandle(thread, newTarget);
|
|
return RuntimeStubs::RuntimeSuperCall(thread, funcHandle, newTargetHandle, firstVRegIdx, length);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::DynamicImport(JSThread *thread, JSTaggedValue specifier, JSTaggedValue currentFunc)
|
|
{
|
|
INTERPRETER_TRACE(thread, DynamicImport);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> specifierHandle(thread, specifier);
|
|
JSHandle<JSTaggedValue> currentFuncHandle(thread, currentFunc);
|
|
return RuntimeStubs::RuntimeDynamicImport(thread, specifierHandle, currentFuncHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::SuperCallSpread(JSThread *thread, JSTaggedValue func, JSTaggedValue newTarget,
|
|
JSTaggedValue array)
|
|
{
|
|
INTERPRETER_TRACE(thread, SuperCallSpread);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> funcHandle(thread, func);
|
|
JSHandle<JSTaggedValue> newTargetHandle(thread, newTarget);
|
|
JSHandle<JSTaggedValue> jsArray(thread, array);
|
|
return RuntimeStubs::RuntimeSuperCallSpread(thread, funcHandle, newTargetHandle, jsArray);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::SuperCallForwardAllArgs(JSThread *thread, JSTaggedType *sp, JSTaggedValue func,
|
|
JSTaggedValue newTarget, uint32_t restNumArgs, uint32_t startIdx)
|
|
{
|
|
JSHandle<JSTaggedValue> superFunc(thread, GetSuperConstructor(thread, func));
|
|
JSHandle<JSTaggedValue> newTargetHandle(thread, newTarget);
|
|
return RuntimeStubs::RuntimeSuperCallForwardAllArgs(thread, sp, superFunc, newTargetHandle, restNumArgs, startIdx);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::DefineMethod(JSThread *thread, Method *method, JSTaggedValue homeObject,
|
|
uint16_t length, JSTaggedValue env, JSTaggedValue module)
|
|
{
|
|
INTERPRETER_TRACE(thread, DefineMethod);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
JSHandle<Method> methodHandle(thread, method);
|
|
JSHandle<JSTaggedValue> homeObjectHandle(thread, homeObject);
|
|
JSHandle<JSTaggedValue> envHandle(thread, env);
|
|
JSHandle<JSTaggedValue> moduleHandle(thread, module);
|
|
return RuntimeStubs::RuntimeDefineMethod(thread, methodHandle, homeObjectHandle, length, envHandle, moduleHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::LdSendableClass(JSThread *thread, JSTaggedValue env, uint16_t level)
|
|
{
|
|
INTERPRETER_TRACE(thread, LdSendableClass);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
JSHandle<JSTaggedValue> envHandle(thread, env);
|
|
return RuntimeStubs::RuntimeLdSendableClass(envHandle, level);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::LdSendableExternalModuleVar(JSThread *thread, int32_t index, JSTaggedValue thisFunc)
|
|
{
|
|
RUNTIME_TRACE(thread, LdSendableExternalModuleVarByIndex);
|
|
[[maybe_unused]] EcmaHandleScope scope(thread);
|
|
|
|
return RuntimeStubs::RuntimeLdSendableExternalModuleVar(thread, index, thisFunc);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::LdLazyExternalModuleVar(JSThread *thread, int32_t index, JSTaggedValue thisFunc)
|
|
{
|
|
RUNTIME_TRACE(thread, LdLazyExternalModuleVarByIndex);
|
|
[[maybe_unused]] EcmaHandleScope scope(thread);
|
|
return RuntimeStubs::RuntimeLdLazyExternalModuleVar(thread, index, thisFunc);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::LdLazySendableExternalModuleVar(JSThread *thread, int32_t index, JSTaggedValue thisFunc)
|
|
{
|
|
RUNTIME_TRACE(thread, LdLazySendableExternalModuleVarByIndex);
|
|
[[maybe_unused]] EcmaHandleScope scope(thread);
|
|
|
|
return RuntimeStubs::RuntimeLdLazySendableExternalModuleVar(thread, index, thisFunc);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::LdSuperByValue(JSThread *thread, JSTaggedValue obj, JSTaggedValue key,
|
|
JSTaggedValue thisFunc)
|
|
{
|
|
INTERPRETER_TRACE(thread, LdSuperByValue);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objHandle(thread, obj);
|
|
JSHandle<JSTaggedValue> propHandle(thread, key);
|
|
return RuntimeStubs::RuntimeLdSuperByValue(thread, objHandle, propHandle, thisFunc);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::StSuperByValue(JSThread *thread, JSTaggedValue obj, JSTaggedValue key,
|
|
JSTaggedValue value, JSTaggedValue thisFunc)
|
|
{
|
|
INTERPRETER_TRACE(thread, StSuperByValue);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> objHandle(thread, obj);
|
|
JSHandle<JSTaggedValue> propHandle(thread, key);
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
return RuntimeStubs::RuntimeStSuperByValue(thread, objHandle, propHandle, valueHandle, thisFunc);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::GetCallSpreadArgs(JSThread *thread, JSTaggedValue array)
|
|
{
|
|
INTERPRETER_TRACE(thread, GetCallSpreadArgs);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> jsArray(thread, array);
|
|
return RuntimeStubs::RuntimeGetCallSpreadArgs(thread, jsArray);
|
|
}
|
|
|
|
void SlowRuntimeStub::ThrowDeleteSuperProperty(JSThread *thread)
|
|
{
|
|
INTERPRETER_TRACE(thread, ThrowDeleteSuperProperty);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
return RuntimeStubs::RuntimeThrowDeleteSuperProperty(thread);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::NotifyInlineCache(JSThread *thread, JSFunction *function)
|
|
{
|
|
INTERPRETER_TRACE(thread, NotifyInlineCache);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSFunction> functionHandle(thread, function);
|
|
uint32_t slotSize = functionHandle->GetCallTarget()->GetSlotSize();
|
|
return RuntimeStubs::RuntimeNotifyInlineCache(thread, functionHandle, slotSize);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::ResolveClass(JSThread *thread, JSTaggedValue ctor, TaggedArray *literal,
|
|
JSTaggedValue base, JSTaggedValue lexenv)
|
|
{
|
|
JSHandle<JSFunction> cls(thread, ctor);
|
|
JSHandle<TaggedArray> literalBuffer(thread, literal);
|
|
JSHandle<JSTaggedValue> baseHandle(thread, base);
|
|
JSHandle<JSTaggedValue> lexicalEnv(thread, lexenv);
|
|
return RuntimeStubs::RuntimeResolveClass(thread, cls, literalBuffer, baseHandle, lexicalEnv);
|
|
}
|
|
|
|
// clone class may need re-set inheritance relationship due to extends may be a variable.
|
|
JSTaggedValue SlowRuntimeStub::CloneClassFromTemplate(JSThread *thread, JSTaggedValue ctor, JSTaggedValue base,
|
|
JSTaggedValue lexenv)
|
|
{
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> lexenvHandle(thread, lexenv);
|
|
JSHandle<JSTaggedValue> baseHandle(thread, base);
|
|
JSHandle<JSFunction> cls(thread, ctor);
|
|
return RuntimeStubs::RuntimeCloneClassFromTemplate(thread, cls, baseHandle, lexenvHandle);
|
|
}
|
|
|
|
// clone class may need re-set inheritance relationship due to extends may be a variable.
|
|
JSTaggedValue SlowRuntimeStub::CreateClassWithBuffer(JSThread *thread, JSTaggedValue base,
|
|
JSTaggedValue lexenv, JSTaggedValue constpool,
|
|
uint16_t methodId, uint16_t literalId, JSTaggedValue module,
|
|
JSTaggedValue length)
|
|
{
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
JSHandle<JSTaggedValue> baseHandle(thread, base);
|
|
JSHandle<JSTaggedValue> lexenvHandle(thread, lexenv);
|
|
JSHandle<JSTaggedValue> constpoolHandle(thread, constpool);
|
|
JSHandle<JSTaggedValue> moduleHandle(thread, module);
|
|
JSHandle<JSTaggedValue> lengthHandle(thread, length);
|
|
return RuntimeStubs::RuntimeCreateClassWithBuffer(thread, baseHandle, lexenvHandle,
|
|
constpoolHandle, methodId, literalId,
|
|
moduleHandle, lengthHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::CreateSharedClass(JSThread *thread, JSTaggedValue base,
|
|
JSTaggedValue constpool, uint16_t methodId, uint16_t literalId,
|
|
uint16_t length, JSTaggedValue module)
|
|
{
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
JSHandle<JSTaggedValue> baseHandle(thread, base);
|
|
JSHandle<JSTaggedValue> constpoolHandle(thread, constpool);
|
|
JSHandle<JSTaggedValue> moduleHandle(thread, module);
|
|
return RuntimeStubs::RuntimeCreateSharedClass(thread, baseHandle, constpoolHandle, methodId,
|
|
literalId, length, moduleHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::SetClassInheritanceRelationship(JSThread *thread, JSTaggedValue ctor, JSTaggedValue base)
|
|
{
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> cls(thread, ctor);
|
|
JSHandle<JSTaggedValue> parent(thread, base);
|
|
return RuntimeStubs::RuntimeSetClassInheritanceRelationship(thread, cls, parent);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::SetClassConstructorLength(JSThread *thread, JSTaggedValue ctor, JSTaggedValue length)
|
|
{
|
|
return RuntimeStubs::RuntimeSetClassConstructorLength(thread, ctor, length);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::GetModuleNamespace(JSThread *thread, int32_t index)
|
|
{
|
|
return RuntimeStubs::RuntimeGetModuleNamespace(thread, index);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::GetModuleNamespace(JSThread *thread, JSTaggedValue localName)
|
|
{
|
|
return RuntimeStubs::RuntimeGetModuleNamespace(thread, localName);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::LdBigInt(JSThread *thread, JSTaggedValue numberBigInt)
|
|
{
|
|
INTERPRETER_TRACE(thread, LdBigInt);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
JSHandle<JSTaggedValue> bigint(thread, numberBigInt);
|
|
return RuntimeStubs::RuntimeLdBigInt(thread, bigint);
|
|
}
|
|
JSTaggedValue SlowRuntimeStub::AsyncGeneratorResolve(JSThread *thread, JSTaggedValue asyncFuncObj,
|
|
const JSTaggedValue value, JSTaggedValue flag)
|
|
{
|
|
INTERPRETER_TRACE(thread, AsyncGeneratorResolve);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> genObjHandle(thread, asyncFuncObj);
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
|
|
return RuntimeStubs::RuntimeAsyncGeneratorResolve(thread, genObjHandle, valueHandle, flag);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::AsyncGeneratorReject(JSThread *thread, JSTaggedValue asyncFuncObj,
|
|
const JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, AsyncGeneratorReject);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSAsyncGeneratorObject> asyncFuncObjHandle(thread, asyncFuncObj);
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
|
|
return JSAsyncGeneratorObject::AsyncGeneratorReject(thread, asyncFuncObjHandle, valueHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::LdPatchVar(JSThread *thread, uint32_t index)
|
|
{
|
|
INTERPRETER_TRACE(thread, LdPatchVar);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
return RuntimeStubs::RuntimeLdPatchVar(thread, index);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::StPatchVar(JSThread *thread, uint32_t index, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, StPatchVar);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
|
|
JSHandle<JSTaggedValue> valueHandle(thread, value);
|
|
return RuntimeStubs::RuntimeStPatchVar(thread, index, valueHandle);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::NotifyConcurrentResult(JSThread *thread, JSTaggedValue result, JSTaggedValue hint)
|
|
{
|
|
INTERPRETER_TRACE(thread, NotifyConcurrentResult);
|
|
return RuntimeStubs::RuntimeNotifyConcurrentResult(thread, result, hint);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::UpdateAOTHClass(JSThread *thread, JSTaggedValue jshclass,
|
|
JSTaggedValue newjshclass, JSTaggedValue key)
|
|
{
|
|
INTERPRETER_TRACE(thread, UpdateAOTHClass);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
JSHandle<JSHClass> oldhclass(thread, jshclass);
|
|
JSHandle<JSHClass> newhclass(thread, newjshclass);
|
|
return RuntimeStubs::RuntimeUpdateAOTHClass(thread, oldhclass, newhclass, key);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::DefineField(JSThread *thread, JSTaggedValue obj,
|
|
JSTaggedValue propKey, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, DefineField);
|
|
return RuntimeStubs::RuntimeDefineField(thread, obj, propKey, value);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::CreatePrivateProperty(JSThread *thread, JSTaggedValue lexicalEnv,
|
|
uint32_t count, JSTaggedValue constpool, uint32_t literalId, JSTaggedValue module)
|
|
{
|
|
INTERPRETER_TRACE(thread, CreatePrivateProperty);
|
|
return RuntimeStubs::RuntimeCreatePrivateProperty(thread, lexicalEnv, count, constpool, literalId, module);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::DefinePrivateProperty(JSThread *thread, JSTaggedValue lexicalEnv,
|
|
uint32_t levelIndex, uint32_t slotIndex, JSTaggedValue obj, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, DefinePrivateProperty);
|
|
return RuntimeStubs::RuntimeDefinePrivateProperty(thread, lexicalEnv, levelIndex, slotIndex, obj, value);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::LdPrivateProperty(JSThread *thread, JSTaggedValue lexicalEnv,
|
|
uint32_t levelIndex, uint32_t slotIndex, JSTaggedValue obj)
|
|
{
|
|
INTERPRETER_TRACE(thread, LdPrivateProperty);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
return RuntimeStubs::RuntimeLdPrivateProperty(thread, lexicalEnv, levelIndex, slotIndex, obj);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::StPrivateProperty(JSThread *thread, JSTaggedValue lexicalEnv,
|
|
uint32_t levelIndex, uint32_t slotIndex, JSTaggedValue obj, JSTaggedValue value)
|
|
{
|
|
INTERPRETER_TRACE(thread, StPrivateProperty);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
return RuntimeStubs::RuntimeStPrivateProperty(thread, lexicalEnv, levelIndex, slotIndex, obj, value);
|
|
}
|
|
|
|
JSTaggedValue SlowRuntimeStub::TestIn(JSThread *thread, JSTaggedValue lexicalEnv,
|
|
uint32_t levelIndex, uint32_t slotIndex, JSTaggedValue obj)
|
|
{
|
|
INTERPRETER_TRACE(thread, TestIn);
|
|
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
|
return RuntimeStubs::RuntimeTestIn(thread, lexicalEnv, levelIndex, slotIndex, obj);
|
|
}
|
|
} // namespace panda::ecmascript
|