* Copyright (c) 2024 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/compiler/builtins/builtins_proxy_stub_builder.h"
#include "ecmascript/compiler/call_stub_builder.h"
#include "ecmascript/compiler/new_object_stub_builder.h"
namespace panda::ecmascript::kungfu {
void BuiltinsProxyStubBuilder::GenProxyConstructor(GateRef nativeCode, GateRef func, GateRef newTarget)
{
auto env = GetEnvironment();
DEFVARIABLE(res, VariableType::JS_ANY(), Undefined());
Label thisCollectionObj(env);
Label slowPath(env);
Label slowPath1(env);
Label exit(env);
Label handleIsEcma(env);
Label targetIsEcma(env);
Label newTargetNotUndefined(env);
BRANCH(TaggedIsUndefined(newTarget), &slowPath, &newTargetNotUndefined);
Bind(&newTargetNotUndefined);
GateRef target = GetArgFromArgv(glue_, IntPtr(0), numArgs_, true);
GateRef handler = GetArgFromArgv(glue_, IntPtr(1), numArgs_, true);
BRANCH(IsEcmaObject(glue_, target), &targetIsEcma, &slowPath);
Bind(&targetIsEcma);
BRANCH(IsEcmaObject(glue_, handler), &handleIsEcma, &slowPath);
Bind(&handleIsEcma);
{
NewObjectStubBuilder newBuilder(this, GetCurrentGlobalEnv());
newBuilder.SetParameters(glue_, IntPtr(0));
res = newBuilder.NewJSProxy(glue_, target, handler);
Jump(&exit);
}
Bind(&slowPath);
{
GateRef argv = GetArgv();
res = CallBuiltinRuntime(glue_, { glue_, nativeCode, func, thisValue_, numArgs_, argv }, true);
Jump(&exit);
}
Bind(&exit);
Return(*res);
}
void BuiltinsProxyStubBuilder::CheckGetTrapResult(GateRef target, GateRef key, Variable *result, Label *exit)
{
auto env = GetEnvironment();
Label callRuntime(env);
Label isFoundData(env);
Label isFoundAccessor(env);
DEFVARIABLE(value, VariableType::JS_ANY(), Hole());
DEFVARIABLE(attr, VariableType::INT64(), Int64(0));
TryGetOwnProperty(glue_, target, key, Circuit::NullGate(), &value, &attr,
&isFoundData, &isFoundAccessor, exit, &callRuntime);
Bind(&isFoundData);
{
Label trapResultTypeError(env);
GateRef rAttr = attr.ReadVariable();
GateRef rValue = value.ReadVariable();
GateRef rResult = result->ReadVariable();
GateRef trapResultCheck = LogicOrBuilder(env).Or(IsConfigable(rAttr))
.Or(IsWritable(rAttr))
.Or(SameValue(glue_, rResult, rValue))
.Done();
BRANCH(BoolNot(trapResultCheck), &trapResultTypeError, exit);
Bind(&trapResultTypeError);
{
GateRef taggedId = Int32(GET_MESSAGE_STRING_ID(ProxyGetPropertyResultTypeError));
CallRuntimeWithGlobalEnv(glue_, GetCurrentGlobalEnv(),
RTSTUB_ID(ThrowTypeError), { IntToTaggedInt(taggedId) });
result->WriteVariable(Exception());
Jump(exit);
}
}
Bind(&isFoundAccessor);
{
Label trapResultIsUndefined(env);
Label trapResultIsNotUndefined(env);
GateRef rAttr = attr.ReadVariable();
GateRef rValue = value.ReadVariable();
GateRef rResult = result->ReadVariable();
GateRef getter = Load(VariableType::JS_ANY(), glue_, rValue, IntPtr(AccessorData::GETTER_OFFSET));
GateRef trapResultCheck = LogicAndBuilder(env).And(BoolNot(IsConfigable(rAttr)))
.And(TaggedIsUndefined(getter))
.And(BoolNot(TaggedIsUndefined(rResult)))
.Done();
BRANCH(trapResultCheck, &trapResultIsNotUndefined, exit);
Bind(&trapResultIsNotUndefined);
{
GateRef taggedId = Int32(GET_MESSAGE_STRING_ID(ProxyGetPropertyResultNotUndefined));
CallRuntimeWithGlobalEnv(glue_, GetCurrentGlobalEnv(),
RTSTUB_ID(ThrowTypeError), { IntToTaggedInt(taggedId) });
result->WriteVariable(Exception());
Jump(exit);
}
}
Bind(&callRuntime);
{
result->WriteVariable(CallRuntimeWithGlobalEnv(glue_, GetCurrentGlobalEnv(),
RTSTUB_ID(CheckGetTrapResult), { target, key, result->ReadVariable() }));
Jump(exit);
}
}
void BuiltinsProxyStubBuilder::CheckSetTrapResult(GateRef target, GateRef key, GateRef value,
Variable *result, Label *exit)
{
auto env = GetEnvironment();
Label callRuntime(env);
Label isFoundData(env);
Label isFoundAccessor(env);
DEFVARIABLE(tValue, VariableType::JS_ANY(), Hole());
DEFVARIABLE(attr, VariableType::INT64(), Int64(0));
TryGetOwnProperty(glue_, target, key, Circuit::NullGate(), &tValue, &attr,
&isFoundData, &isFoundAccessor, exit, &callRuntime);
Bind(&isFoundData);
{
Label trapResultTypeError(env);
GateRef rAttr = attr.ReadVariable();
GateRef rValue = tValue.ReadVariable();
GateRef trapResultCheck = LogicOrBuilder(env).Or(IsConfigable(rAttr))
.Or(IsWritable(rAttr))
.Or(SameValue(glue_, value, rValue))
.Done();
BRANCH(BoolNot(trapResultCheck), &trapResultTypeError, exit);
Bind(&trapResultTypeError);
{
GateRef taggedId = Int32(GET_MESSAGE_STRING_ID(ProxySetPropertyResultTypeError));
CallRuntimeWithGlobalEnv(glue_, GetCurrentGlobalEnv(),
RTSTUB_ID(ThrowTypeError), { IntToTaggedInt(taggedId) });
result->WriteVariable(TaggedFalse());
Jump(exit);
}
}
Bind(&isFoundAccessor);
{
Label trapResultIsUndefined(env);
Label trapResultIsNotUndefined(env);
GateRef rAttr = attr.ReadVariable();
GateRef rValue = tValue.ReadVariable();
GateRef setter = Load(VariableType::JS_ANY(), glue_, rValue, IntPtr(AccessorData::SETTER_OFFSET));
GateRef trapResultCheck = LogicAndBuilder(env).And(BoolNot(IsConfigable(rAttr)))
.And(TaggedIsUndefined(setter))
.Done();
BRANCH(trapResultCheck, &trapResultIsNotUndefined, exit);
Bind(&trapResultIsNotUndefined);
{
GateRef taggedId = Int32(GET_MESSAGE_STRING_ID(ProxySetPropertyResultNotAccessor));
CallRuntimeWithGlobalEnv(glue_, GetCurrentGlobalEnv(),
RTSTUB_ID(ThrowTypeError), { IntToTaggedInt(taggedId) });
result->WriteVariable(TaggedFalse());
Jump(exit);
}
}
Bind(&callRuntime);
{
result->WriteVariable(CallRuntimeWithGlobalEnv(glue_, GetCurrentGlobalEnv(),
RTSTUB_ID(CheckSetTrapResult), { target, key, value }));
Jump(exit);
}
}
GateRef BuiltinsProxyStubBuilder::GetProperty(GateRef proxy, GateRef key, GateRef receiver)
{
auto env = GetEnvironment();
DEFVARIABLE(result, VariableType::JS_ANY(), Undefined());
Label stackOverflow(env);
Label dispatch(env);
Label checkGetTrapResult(env);
Label exit(env);
Label handlerIsNull(env);
Label handlerIsNotNull(env);
Label slowPath(env);
Label trapIsCallable(env);
Label trapFastPath(env);
BRANCH_UNLIKELY(CheckStackOverflow(glue_), &stackOverflow, &dispatch);
Bind(&stackOverflow);
{
CallRuntimeWithGlobalEnv(glue_, GetCurrentGlobalEnv(), RTSTUB_ID(ThrowStackOverflowException), {});
result = Exception();
Jump(&exit);
}
Bind(&dispatch);
GateRef handler = GetHandler(glue_, proxy);
BRANCH(TaggedIsNull(handler), &handlerIsNull, &handlerIsNotNull);
Bind(&handlerIsNull);
{
GateRef taggedId = Int32(GET_MESSAGE_STRING_ID(ProxyGetPropertyHandlerIsNull));
CallRuntimeWithGlobalEnv(glue_, GetCurrentGlobalEnv(), RTSTUB_ID(ThrowTypeError), { IntToTaggedInt(taggedId) });
result = Exception();
Jump(&exit);
}
Bind(&handlerIsNotNull);
{
GateRef target = GetTarget(glue_, proxy);
GateRef name = GetGlobalConstantValue(VariableType::JS_POINTER(), glue_,
ConstantIndex::GET_STRING_INDEX);
GateRef trap = GetPropertyByName(glue_, handler, name);
Label isPendingException(env);
Label noPendingException(env);
BRANCH_UNLIKELY(HasPendingException(glue_), &isPendingException, &noPendingException);
Bind(&isPendingException);
{
result = Exception();
Jump(&exit);
}
Bind(&noPendingException);
BRANCH(TaggedIsHeapObject(trap), &trapFastPath, &slowPath);
Bind(&trapFastPath);
{
BRANCH(IsCallable(glue_, trap), &trapIsCallable, &slowPath);
Bind(&trapIsCallable);
{
JSCallArgs callArgs(JSCallMode::CALL_THIS_ARG3_WITH_RETURN);
callArgs.callThisArg3WithReturnArgs = { handler, target, key, receiver };
CallStubBuilder callBuilder(this, glue_, trap,
Int32(3), 0, nullptr, Circuit::NullGate(), callArgs);
result = callBuilder.JSCallDispatch();
Jump(&checkGetTrapResult);
}
}
Bind(&checkGetTrapResult);
{
CheckGetTrapResult(target, key, &result, &exit);
}
Bind(&slowPath);
{
result = CallRuntimeWithGlobalEnv(glue_, GetCurrentGlobalEnv(),
RTSTUB_ID(JSProxyGetProperty), { proxy, key, receiver });
Jump(&exit);
}
}
Bind(&exit);
auto ret = *result;
return ret;
}
GateRef BuiltinsProxyStubBuilder::SetProperty(GateRef proxy, GateRef key, GateRef value, GateRef receiver,
bool mayThrow)
{
auto env = GetEnvironment();
DEFVARIABLE(result, VariableType::JS_ANY(), TaggedTrue());
Label stackOverflow(env);
Label dispatch(env);
Label trapResultIsFalse(env);
Label checkSetTrapResult(env);
Label exit(env);
Label handlerIsNull(env);
Label handlerIsNotNull(env);
Label slowPath(env);
Label trapIsCallable(env);
Label trapFastPath(env);
BRANCH_UNLIKELY(CheckStackOverflow(glue_), &stackOverflow, &dispatch);
Bind(&stackOverflow);
{
CallRuntimeWithGlobalEnv(glue_, GetCurrentGlobalEnv(), RTSTUB_ID(ThrowStackOverflowException), {});
result = TaggedFalse();
Jump(&exit);
}
Bind(&dispatch);
GateRef handler = GetHandler(glue_, proxy);
BRANCH(TaggedIsNull(handler), &handlerIsNull, &handlerIsNotNull);
Bind(&handlerIsNull);
{
GateRef taggedId = Int32(GET_MESSAGE_STRING_ID(ProxySetPropertyHandlerIsNull));
CallRuntimeWithGlobalEnv(glue_, GetCurrentGlobalEnv(), RTSTUB_ID(ThrowTypeError), { IntToTaggedInt(taggedId) });
result = TaggedFalse();
Jump(&exit);
}
Bind(&handlerIsNotNull);
{
GateRef target = GetTarget(glue_, proxy);
GateRef name = GetGlobalConstantValue(VariableType::JS_POINTER(), glue_,
ConstantIndex::SET_STRING_INDEX);
GateRef trap = GetPropertyByName(glue_, handler, name);
Label isPendingException(env);
Label noPendingException(env);
BRANCH_UNLIKELY(HasPendingException(glue_), &isPendingException, &noPendingException);
Bind(&isPendingException);
{
result = TaggedFalse();
Jump(&exit);
}
Bind(&noPendingException);
BRANCH(TaggedIsHeapObject(trap), &trapFastPath, &slowPath);
Bind(&trapFastPath);
{
BRANCH(IsCallable(glue_, trap), &trapIsCallable, &slowPath);
Bind(&trapIsCallable);
{
GateRef argsLength = Int32(4);
NewObjectStubBuilder newBuilder(this);
GateRef argList = newBuilder.NewTaggedArray(glue_, argsLength);
SetValueToTaggedArray(VariableType::JS_ANY(), glue_, argList, Int32(0), target);
SetValueToTaggedArray(VariableType::JS_ANY(), glue_, argList, Int32(1), key);
SetValueToTaggedArray(VariableType::JS_ANY(), glue_, argList, Int32(2), value);
SetValueToTaggedArray(VariableType::JS_ANY(), glue_, argList, Int32(3), receiver);
GateRef argv = PtrAdd(argList, IntPtr(TaggedArray::DATA_OFFSET));
JSCallArgs callArgs(JSCallMode::CALL_THIS_ARGV_WITH_RETURN);
callArgs.callThisArgvWithReturnArgs = { argsLength, argv, handler };
CallStubBuilder callBuilder(this, glue_, trap, argsLength, 0, nullptr,
Circuit::NullGate(), callArgs);
GateRef trapResult = callBuilder.JSCallDispatch();
BRANCH(TaggedIsFalse(FastToBoolean(glue_, trapResult)), &trapResultIsFalse, &checkSetTrapResult);
Bind(&trapResultIsFalse);
{
if (mayThrow) {
GateRef taggedId = Int32(GET_MESSAGE_STRING_ID(ProxySetPropertyReturnFalse));
CallRuntimeWithGlobalEnv(glue_, GetCurrentGlobalEnv(),
RTSTUB_ID(ThrowTypeError), {IntToTaggedInt(taggedId)});
}
result = TaggedFalse();
Jump(&exit);
}
}
}
Bind(&checkSetTrapResult);
{
CheckSetTrapResult(target, key, value, &result, &exit);
}
Bind(&slowPath);
{
result = CallRuntimeWithGlobalEnv(glue_, GetCurrentGlobalEnv(), RTSTUB_ID(JSProxySetProperty),
{proxy, key, value, receiver, mayThrow ? TaggedTrue() : TaggedFalse()});
Jump(&exit);
}
}
Bind(&exit);
auto ret = *result;
return ret;
}
}
