openharmony/arkcompiler_ets_runtime
1
0
Fork 0
mirror of https://gitee.com/openharmony/arkcompiler_ets_runtime synced 2024-10-07 08:03:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[Inline Call part3] Remove Aot Function Env Arg

Browse Source 
1. Remove env in aot call signature.
2. Remove env in optimizedJSFunctionFrame.
3. Modify x64 and arm64 asm bridge.

Issue:https://gitee.com/openharmony/arkcompiler_ets_runtime/issues/I6RR4F

Signed-off-by: xujie <xujie101@huawei.com>
Change-Id: I5fbb63c662d82a41073e2ff4456fdc42fb651f6a
This commit is contained in:
xujie 2023-03-30 20:39:26 +08:00
parent a9a7a88f88
commit 14878d00f9
16 changed files with 215 additions and 347 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
ecmascript/compiler/argument_accessor.h
View File

@ -25,7 +25,6 @@
namespace panda::ecmascript::kungfu {
enum class CommonArgIdx : uint8_t {
GLUE = 0,
LEXENV,
ACTUAL_ARGC,
FUNC,
NEW_TARGET,

1
ecmascript/compiler/bytecode_circuit_builder.cpp
View File

@ -528,7 +528,6 @@ void BytecodeCircuitBuilder::UpdateCFG()
void BytecodeCircuitBuilder::BuildCircuitArgs()
{
argAcc_.NewCommonArg(CommonArgIdx::GLUE, MachineType::I64, GateType::NJSValue());
argAcc_.NewCommonArg(CommonArgIdx::LEXENV, MachineType::I64, GateType::TaggedValue());
argAcc_.NewCommonArg(CommonArgIdx::ACTUAL_ARGC, MachineType::I64, GateType::NJSValue());
auto funcIdx = static_cast<size_t>(CommonArgIdx::FUNC);
const size_t actualNumArgs = argAcc_.GetActualNumArgs();

16
ecmascript/compiler/call_signature.cpp
View File

@ -904,12 +904,11 @@ DEF_CALL_SIGNATURE(OptimizedCallOptimized)
DEF_CALL_SIGNATURE(JSCall)
{
// 6 : 6 input parameters
CallSignature jSCall("JSCall", 0, 6,
CallSignature jSCall("JSCall", 0, 5,
ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
*callSign = jSCall;
std::array<VariableType, 6> params = { // 6 : 6 input parameters
std::array<VariableType, 5> params = { // 5 : 5 input parameters
VariableType::NATIVE_POINTER(), // glue
VariableType::JS_ANY(), // lexenv
VariableType::INT64(), // actual argC
VariableType::JS_ANY(), // call target
VariableType::JS_ANY(), // new target
@ -924,12 +923,11 @@ DEF_CALL_SIGNATURE(JSCall)
DEF_CALL_SIGNATURE(JSAotCall)
{
// 6 : 6 input parameters
CallSignature jSCall("JSAotCall", 0, 6,
CallSignature jSCall("JSAotCall", 0, 5,
ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
*callSign = jSCall;
std::array<VariableType, 6> params = { // 6 : 6 input parameters
std::array<VariableType, 5> params = { // 5 : 5 input parameters
VariableType::NATIVE_POINTER(), // glue
VariableType::JS_ANY(), // lexenv
VariableType::INT64(), // actual argC
VariableType::JS_ANY(), // call target
VariableType::JS_ANY(), // new target
@ -944,12 +942,11 @@ DEF_CALL_SIGNATURE(JSAotCall)
DEF_CALL_SIGNATURE(JSCallNew)
{
// 6 : 6 input parameters
CallSignature jSCallNew("JSCallNew", 0, 6,
CallSignature jSCallNew("JSCallNew", 0, 5,
ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
*callSign = jSCallNew;
std::array<VariableType, 6> params = { // 6 : 6 input parameters
std::array<VariableType, 5> params = { // 5 : 5 input parameters
VariableType::NATIVE_POINTER(), // glue
VariableType::JS_ANY(), // lexenv
VariableType::INT64(), // actual argC
VariableType::JS_ANY(), // call target
VariableType::JS_ANY(), // new target
@ -969,7 +966,6 @@ DEF_CALL_SIGNATURE(ConstructorJSCall)
*callSign = constructorJsCall;
std::array<VariableType, 6> params = { // 6 : 6 input parameters
VariableType::NATIVE_POINTER(), // glue
VariableType::JS_ANY(), // lexenv
VariableType::INT64(), // actual argC
VariableType::JS_ANY(), // call target
VariableType::JS_ANY(), // new target

3
ecmascript/compiler/common_stubs.cpp
View File

@ -729,9 +729,8 @@ void JsProxyCallInternalStubBuilder::GenerateCircuit()
// 2: this offset
GateRef thisArg = Load(VariableType::JS_POINTER(), argv, IntPtr(2 * sizeof(JSTaggedValue)));
GateRef numArgs = Int64(JSPROXY_NUM_ARGS + NUM_MANDATORY_JSFUNC_ARGS);
GateRef lexEnv = Load(VariableType::JS_POINTER(), method, IntPtr(JSFunction::LEXICAL_ENV_OFFSET));
result = CallNGCRuntime(glue, RTSTUB_ID(JSCall),
{glue, lexEnv, numArgs, method, Undefined(), handler, target, thisArg, arrHandle});
{glue, numArgs, method, Undefined(), handler, target, thisArg, arrHandle});
Jump(&exit);
}
}

3
ecmascript/compiler/llvm_ir_builder.cpp
View File

@ -2304,9 +2304,8 @@ LLVMValueRef LLVMModule::AddFunc(const panda::ecmascript::MethodLiteral *methodL
{
LLVMTypeRef returnType = NewLType(MachineType::I64, GateType::TaggedValue()); // possibly get it for circuit
LLVMTypeRef glue = NewLType(MachineType::I64, GateType::NJSValue());
LLVMTypeRef lexEnv = NewLType(MachineType::I64, GateType::TaggedValue());
LLVMTypeRef actualArgc = NewLType(MachineType::I64, GateType::NJSValue());
std::vector<LLVMTypeRef> paramTys = { glue, lexEnv, actualArgc };
std::vector<LLVMTypeRef> paramTys = { glue, actualArgc };
auto funcIndex = static_cast<uint32_t>(CommonArgIdx::FUNC);
auto numOfComArgs = static_cast<uint32_t>(CommonArgIdx::NUM_OF_ARGS);
auto paramCount = methodLiteral->GetNumArgs() + numOfComArgs;

38
ecmascript/compiler/slowpath_lowering.cpp
View File

@ -910,8 +910,7 @@ void SlowPathLowering::LowerCallArg0(GateRef gate)
GateRef newTarget = builder_.Undefined();
GateRef thisObj = builder_.Undefined();
GateRef func = acc_.GetValueIn(gate, 0);
GateRef env = builder_.Undefined();
LowerToJSCall(gate, {glue_, env, actualArgc, func, newTarget, thisObj});
LowerToJSCall(gate, {glue_, actualArgc, func, newTarget, thisObj});
}
void SlowPathLowering::LowerCallthisrangeImm8Imm8V8(GateRef gate)
@ -927,9 +926,7 @@ void SlowPathLowering::LowerCallthisrangeImm8Imm8V8(GateRef gate)
GateRef callTarget = acc_.GetValueIn(gate, numIns - callTargetIndex); // acc
GateRef thisObj = acc_.GetValueIn(gate, 0);
GateRef newTarget = builder_.Undefined();
GateRef env = builder_.Undefined();
vec.emplace_back(glue_);
vec.emplace_back(env);
vec.emplace_back(actualArgc);
vec.emplace_back(callTarget);
vec.emplace_back(newTarget);
@ -953,8 +950,7 @@ void SlowPathLowering::LowerWideCallthisrangePrefImm16V8(GateRef gate)
GateRef callTarget = acc_.GetValueIn(gate, numIns - callTargetIndex);
GateRef thisObj = acc_.GetValueIn(gate, 0);
GateRef newTarget = builder_.Undefined();
GateRef env = builder_.Undefined();
std::vector<GateRef> vec {glue_, env, actualArgc, callTarget, newTarget, thisObj};
std::vector<GateRef> vec {glue_, actualArgc, callTarget, newTarget, thisObj};
// add common args
for (size_t i = fixedInputsNum; i < numIns - callTargetIndex; i++) {
vec.emplace_back(acc_.GetValueIn(gate, i));
@ -984,9 +980,7 @@ void SlowPathLowering::LowerCallrangeImm8Imm8V8(GateRef gate)
GateRef callTarget = acc_.GetValueIn(gate, numArgs - callTargetIndex);
GateRef newTarget = builder_.Undefined();
GateRef thisObj = builder_.Undefined();
GateRef env = builder_.Undefined();
vec.emplace_back(glue_);
vec.emplace_back(env);
vec.emplace_back(actualArgc);
vec.emplace_back(callTarget);
vec.emplace_back(newTarget);
@ -1689,14 +1683,13 @@ void SlowPathLowering::LowerNewObjRange(GateRef gate)
builder_.Branch(builder_.TaggedIsHole(thisObj), &slowPath, &fastPath);
builder_.Bind(&fastPath);
{
const int extra = 5; // 5: add glue, lexEnv, argc, new-target and this
const int extra = 4; // 4: add glue, argc, new-target and this
GateRef actualArgc = builder_.Int64(BytecodeCallArgc::ComputeCallArgc(acc_.GetNumValueIn(gate),
EcmaOpcode::NEWOBJRANGE_IMM8_IMM8_V8));
size_t range = acc_.GetNumValueIn(gate);
std::vector<GateRef> args;
args.reserve((range + extra));
args.emplace_back(glue_);
args.emplace_back(builder_.Undefined());
args.emplace_back(actualArgc);
args.emplace_back(ctor);
args.emplace_back(ctor);
@ -2922,8 +2915,7 @@ void SlowPathLowering::LowerCallthis0Imm8V8(GateRef gate)
GateRef newTarget = builder_.Undefined();
GateRef thisObj = acc_.GetValueIn(gate, 0);
GateRef func = acc_.GetValueIn(gate, 1);
GateRef env = builder_.Undefined();
LowerToJSCall(gate, {glue_, env, actualArgc, func, newTarget, thisObj});
LowerToJSCall(gate, {glue_, actualArgc, func, newTarget, thisObj});
}
void SlowPathLowering::LowerCallArg1Imm8V8(GateRef gate)
@ -2937,8 +2929,7 @@ void SlowPathLowering::LowerCallArg1Imm8V8(GateRef gate)
GateRef a0Value = acc_.GetValueIn(gate, 0);
GateRef thisObj = builder_.Undefined();
GateRef func = acc_.GetValueIn(gate, 1); // acc
GateRef env = builder_.Undefined();
LowerToJSCall(gate, {glue_, env, actualArgc, func, newTarget, thisObj, a0Value});
LowerToJSCall(gate, {glue_, actualArgc, func, newTarget, thisObj, a0Value});
}
void SlowPathLowering::LowerWideCallrangePrefImm16V8(GateRef gate)
@ -2952,10 +2943,8 @@ void SlowPathLowering::LowerWideCallrangePrefImm16V8(GateRef gate)
GateRef callTarget = acc_.GetValueIn(gate, numIns - fixedInputsNum); // acc
GateRef newTarget = builder_.Undefined();
GateRef thisObj = builder_.Undefined();
GateRef env = builder_.Undefined();
vec.emplace_back(glue_);
vec.emplace_back(env);
vec.emplace_back(actualArgc);
vec.emplace_back(callTarget);
vec.emplace_back(newTarget);
@ -2977,8 +2966,7 @@ void SlowPathLowering::LowerCallThisArg1(GateRef gate)
GateRef thisObj = acc_.GetValueIn(gate, 0);
GateRef a0 = acc_.GetValueIn(gate, 1); // 1:first parameter
GateRef func = acc_.GetValueIn(gate, 2); // 2:function
GateRef env = builder_.Undefined();
LowerToJSCall(gate, {glue_, env, actualArgc, func, newTarget, thisObj, a0});
LowerToJSCall(gate, {glue_, actualArgc, func, newTarget, thisObj, a0});
}
void SlowPathLowering::LowerCallargs2Imm8V8V8(GateRef gate)
@ -2992,9 +2980,8 @@ void SlowPathLowering::LowerCallargs2Imm8V8V8(GateRef gate)
GateRef a0 = acc_.GetValueIn(gate, 0);
GateRef a1 = acc_.GetValueIn(gate, 1); // 1:first parameter
GateRef func = acc_.GetValueIn(gate, 2); // 2:function
GateRef env = builder_.Undefined();
LowerToJSCall(gate, {glue_, env, actualArgc, func, newTarget, thisObj, a0, a1});
LowerToJSCall(gate, {glue_, actualArgc, func, newTarget, thisObj, a0, a1});
}
void SlowPathLowering::LowerCallargs3Imm8V8V8(GateRef gate)
@ -3009,9 +2996,8 @@ void SlowPathLowering::LowerCallargs3Imm8V8V8(GateRef gate)
GateRef a1 = acc_.GetValueIn(gate, 1);
GateRef a2 = acc_.GetValueIn(gate, 2);
GateRef func = acc_.GetValueIn(gate, 3);
GateRef env = builder_.Undefined();
LowerToJSCall(gate, {glue_, env, actualArgc, func, newTarget, thisObj, a0, a1, a2});
LowerToJSCall(gate, {glue_, actualArgc, func, newTarget, thisObj, a0, a1, a2});
}
void SlowPathLowering::LowerCallthis2Imm8V8V8V8(GateRef gate)
@ -3025,9 +3011,8 @@ void SlowPathLowering::LowerCallthis2Imm8V8V8V8(GateRef gate)
GateRef a0Value = acc_.GetValueIn(gate, 1);
GateRef a1Value = acc_.GetValueIn(gate, 2);
GateRef func = acc_.GetValueIn(gate, 3); //acc
GateRef env = builder_.Undefined();
LowerToJSCall(gate, {glue_, env, actualArgc, func, newTarget, thisObj, a0Value, a1Value});
LowerToJSCall(gate, {glue_, actualArgc, func, newTarget, thisObj, a0Value, a1Value});
}
void SlowPathLowering::LowerCallthis3Imm8V8V8V8V8(GateRef gate)
@ -3042,8 +3027,7 @@ void SlowPathLowering::LowerCallthis3Imm8V8V8V8V8(GateRef gate)
GateRef a1Value = acc_.GetValueIn(gate, 2);
GateRef a2Value = acc_.GetValueIn(gate, 3);
GateRef func = acc_.GetValueIn(gate, 4);
GateRef env = builder_.Undefined();
LowerToJSCall(gate, {glue_, env, actualArgc, func, newTarget, thisObj, a0Value, a1Value, a2Value});
LowerToJSCall(gate, {glue_, actualArgc, func, newTarget, thisObj, a0Value, a1Value, a2Value});
}
void SlowPathLowering::LowerLdThisByName(GateRef gate)
@ -3137,7 +3121,7 @@ void SlowPathLowering::LowerConstruct(GateRef gate)
void SlowPathLowering::LowerTypedAotCall(GateRef gate)
{
Environment env(gate, circuit_, &builder_);
GateRef func = acc_.GetValueIn(gate, 3); // 3: argv func
GateRef func = acc_.GetValueIn(gate, static_cast<size_t>(CommonArgIdx::FUNC));
GateRef method = builder_.GetMethodFromFunction(func);
GateRef code = builder_.GetCodeAddr(method);
size_t num = acc_.GetNumValueIn(gate);

15
ecmascript/compiler/stub_builder.cpp
View File

@ -4686,7 +4686,6 @@ GateRef StubBuilder::JSCallDispatch(GateRef glue, GateRef func, GateRef actualNu
{
GateRef newTarget = Undefined();
GateRef thisValue = Undefined();
GateRef lexEnv = env_->GetBuilder()->GetFunctionLexicalEnv(func);
GateRef realNumArgs = Int64Add(ZExtInt32ToInt64(actualNumArgs), Int64(NUM_MANDATORY_JSFUNC_ARGS));
switch (mode) {
case JSCallMode::CALL_THIS_ARG0:
@ -4695,7 +4694,7 @@ GateRef StubBuilder::JSCallDispatch(GateRef glue, GateRef func, GateRef actualNu
case JSCallMode::CALL_ARG0:
case JSCallMode::DEPRECATED_CALL_ARG0:
result = CallNGCRuntime(glue, RTSTUB_ID(JSCall),
{ glue, lexEnv, realNumArgs, func, newTarget, thisValue});
{ glue, realNumArgs, func, newTarget, thisValue});
Jump(&exit);
break;
case JSCallMode::CALL_THIS_ARG1:
@ -4704,7 +4703,7 @@ GateRef StubBuilder::JSCallDispatch(GateRef glue, GateRef func, GateRef actualNu
case JSCallMode::CALL_ARG1:
case JSCallMode::DEPRECATED_CALL_ARG1:
result = CallNGCRuntime(glue, RTSTUB_ID(JSCall),
{ glue, lexEnv, realNumArgs, func, newTarget, thisValue, data[0] });
{ glue, realNumArgs, func, newTarget, thisValue, data[0] });
Jump(&exit);
break;
case JSCallMode::CALL_THIS_ARG2:
@ -4713,7 +4712,7 @@ GateRef StubBuilder::JSCallDispatch(GateRef glue, GateRef func, GateRef actualNu
case JSCallMode::CALL_ARG2:
case JSCallMode::DEPRECATED_CALL_ARG2:
result = CallNGCRuntime(glue, RTSTUB_ID(JSCall),
{ glue, lexEnv, realNumArgs, func, newTarget, thisValue, data[0], data[1] });
{ glue, realNumArgs, func, newTarget, thisValue, data[0], data[1] });
Jump(&exit);
break;
case JSCallMode::CALL_THIS_ARG3:
@ -4722,7 +4721,7 @@ GateRef StubBuilder::JSCallDispatch(GateRef glue, GateRef func, GateRef actualNu
case JSCallMode::CALL_ARG3:
case JSCallMode::DEPRECATED_CALL_ARG3:
result = CallNGCRuntime(glue, RTSTUB_ID(JSCall),
{ glue, lexEnv, realNumArgs, func, newTarget, thisValue,
{ glue, realNumArgs, func, newTarget, thisValue,
data[0], data[1], data[2] }); // 2: args2
Jump(&exit);
break;
@ -4745,17 +4744,17 @@ GateRef StubBuilder::JSCallDispatch(GateRef glue, GateRef func, GateRef actualNu
break;
case JSCallMode::CALL_GETTER:
result = CallNGCRuntime(glue, RTSTUB_ID(JSCall),
{ glue, lexEnv, realNumArgs, func, newTarget, data[0]});
{ glue, realNumArgs, func, newTarget, data[0]});
Jump(&exit);
break;
case JSCallMode::CALL_SETTER:
result = CallNGCRuntime(glue, RTSTUB_ID(JSCall),
{ glue, lexEnv, realNumArgs, func, newTarget, data[0], data[1]});
{ glue, realNumArgs, func, newTarget, data[0], data[1]});
Jump(&exit);
break;
case JSCallMode::CALL_THIS_ARG3_WITH_RETURN:
result = CallNGCRuntime(glue, RTSTUB_ID(JSCall),
{ glue, lexEnv, realNumArgs, func, newTarget, data[0], data[1], data[2], data[3] });
{ glue, realNumArgs, func, newTarget, data[0], data[1], data[2], data[3] });
Jump(&exit);
break;
default:

145
ecmascript/compiler/test_stubs.cpp
View File

@ -26,33 +26,31 @@ using namespace panda::ecmascript;
void FooAOTStubBuilder::GenerateCircuit()
{
GateRef glue = PtrArgument(0);
GateRef env = TaggedArgument(1);
GateRef argc = Int64Argument(2);
GateRef calltarget = TaggedArgument(3);
GateRef newtarget = TaggedArgument(4);
GateRef thisObj = TaggedArgument(5);
GateRef a = TaggedArgument(6);
GateRef b = TaggedArgument(7);
GateRef argc = Int32Argument(1);
GateRef calltarget = TaggedArgument(2);
GateRef newtarget = TaggedArgument(3);
GateRef thisObj = TaggedArgument(4);
GateRef a = TaggedArgument(5);
GateRef b = TaggedArgument(6);
GateRef pcOffset = Int32(1);
(void)calltarget;
GateRef barIndex = IntToTaggedInt(Int32(CommonStubCSigns::BarAOT));
GateRef numArgs = IntToTaggedInt(Int32(2));
GateRef barfunc = CallRuntime(glue, RTSTUB_ID(DefineAotFunc), {barIndex, numArgs});
GateRef result =
CallNGCRuntime(glue, RTSTUB_ID(JSCall), {glue, env, argc, barfunc, newtarget, thisObj, a, b, pcOffset});
CallNGCRuntime(glue, RTSTUB_ID(JSCall), {glue, argc, barfunc, newtarget, thisObj, a, b, pcOffset});
Return(result);
}
void BarAOTStubBuilder::GenerateCircuit()
{
GateRef glue = PtrArgument(0);
[[maybe_unused]] GateRef env = TaggedArgument(1);
[[maybe_unused]] GateRef argc = Int64Argument(2);
[[maybe_unused]] GateRef calltarget = TaggedArgument(3);
[[maybe_unused]] GateRef newtarget = TaggedArgument(4);
[[maybe_unused]] GateRef thisObj = TaggedArgument(5);
GateRef a = TaggedArgument(6);
GateRef b = TaggedArgument(7);
[[maybe_unused]] GateRef argc = Int32Argument(1);
[[maybe_unused]] GateRef calltarget = TaggedArgument(2);
[[maybe_unused]] GateRef newtarget = TaggedArgument(3);
[[maybe_unused]] GateRef thisObj = TaggedArgument(4);
GateRef a = TaggedArgument(5);
GateRef b = TaggedArgument(6);
GateRef result = CallRuntime(glue, RTSTUB_ID(Add2), {a, b});
Return(result);
}
@ -60,39 +58,36 @@ void BarAOTStubBuilder::GenerateCircuit()
void Foo1AOTStubBuilder::GenerateCircuit()
{
GateRef glue = PtrArgument(0);
GateRef env = TaggedArgument(1);
GateRef argc = Int64Argument(2);
GateRef calltarget = TaggedArgument(3);
GateRef newtarget = TaggedArgument(4);
GateRef thisObj = TaggedArgument(5);
GateRef a = TaggedArgument(6);
GateRef b = TaggedArgument(7);
GateRef argc = Int32Argument(1);
GateRef calltarget = TaggedArgument(2);
GateRef newtarget = TaggedArgument(3);
GateRef thisObj = TaggedArgument(4);
GateRef a = TaggedArgument(5);
GateRef b = TaggedArgument(6);
GateRef pcOffset = Int32(1);
(void)calltarget;
GateRef barIndex = IntToTaggedInt(Int32(CommonStubCSigns::Bar1AOT));
GateRef numArgs = IntToTaggedInt(Int32(3));
GateRef barfunc = CallRuntime(glue, RTSTUB_ID(DefineAotFunc), {barIndex, numArgs});
GateRef result =
CallNGCRuntime(glue, RTSTUB_ID(JSCall), {glue, env, argc, barfunc, newtarget, thisObj, a, b, pcOffset});
CallNGCRuntime(glue, RTSTUB_ID(JSCall), {glue, argc, barfunc, newtarget, thisObj, a, b, pcOffset});
Return(result);
}
void Bar1AOTStubBuilder::GenerateCircuit()
{
GateRef glue = PtrArgument(0);
GateRef env = TaggedArgument(1);
GateRef argc = Int64Argument(2);
GateRef calltarget = TaggedArgument(3);
GateRef newtarget = TaggedArgument(4);
GateRef thisObj = TaggedArgument(5);
(void)env;
GateRef argc = Int32Argument(1);
GateRef calltarget = TaggedArgument(2);
GateRef newtarget = TaggedArgument(3);
GateRef thisObj = TaggedArgument(4);
(void)argc;
(void)calltarget;
(void)newtarget;
(void)thisObj;
GateRef a = TaggedArgument(6);
GateRef b = TaggedArgument(7);
GateRef c = TaggedArgument(8);
GateRef a = TaggedArgument(5);
GateRef b = TaggedArgument(6);
GateRef c = TaggedArgument(7);
GateRef result = CallRuntime(glue, RTSTUB_ID(Add2), {a, b});
GateRef result2 = CallRuntime(glue, RTSTUB_ID(Add2), {result, c});
Return(result2);
@ -101,20 +96,19 @@ void Bar1AOTStubBuilder::GenerateCircuit()
void Foo2AOTStubBuilder::GenerateCircuit()
{
GateRef glue = PtrArgument(0);
GateRef env = TaggedArgument(1);
GateRef argc = Int64Argument(2);
GateRef calltarget = TaggedArgument(3);
GateRef newtarget = TaggedArgument(4);
GateRef thisObj = TaggedArgument(5);
GateRef a = TaggedArgument(6);
GateRef b = TaggedArgument(7);
GateRef argc = Int32Argument(1);
GateRef calltarget = TaggedArgument(2);
GateRef newtarget = TaggedArgument(3);
GateRef thisObj = TaggedArgument(4);
GateRef a = TaggedArgument(5);
GateRef b = TaggedArgument(6);
GateRef pcOffset = Int32(1);
(void)calltarget;
GateRef actualArgC = Int64Add(argc, Int64(1));
GateRef barIndex = IntToTaggedInt(Int32(CommonStubCSigns::BarAOT));
GateRef numArgs = IntToTaggedInt(Int32(2));
GateRef barfunc = CallRuntime(glue, RTSTUB_ID(DefineAotFunc), {barIndex, numArgs});
GateRef result = CallNGCRuntime(glue, RTSTUB_ID(JSCall), {glue, env, actualArgC, barfunc, newtarget, thisObj,
GateRef result = CallNGCRuntime(glue, RTSTUB_ID(JSCall), {glue, actualArgC, barfunc, newtarget, thisObj,
a, b, Undefined(), pcOffset});
Return(result);
}
@ -122,18 +116,17 @@ void Foo2AOTStubBuilder::GenerateCircuit()
void FooNativeAOTStubBuilder::GenerateCircuit()
{
GateRef glue = PtrArgument(0);
GateRef env = TaggedArgument(1);
GateRef argc = Int64Argument(2);
GateRef calltarget = TaggedArgument(3);
GateRef newtarget = TaggedArgument(4);
GateRef thisObj = TaggedArgument(5);
GateRef a = TaggedArgument(6);
GateRef b = TaggedArgument(7);
GateRef argc = Int32Argument(1);
GateRef calltarget = TaggedArgument(2);
GateRef newtarget = TaggedArgument(3);
GateRef thisObj = TaggedArgument(4);
GateRef a = TaggedArgument(5);
GateRef b = TaggedArgument(6);
GateRef pcOffset = Int32(1);
(void)calltarget;
GateRef actualArgC = Int64Add(argc, Int64(1));
GateRef printfunc = CallRuntime(glue, RTSTUB_ID(GetPrintFunc), {});
GateRef result = CallNGCRuntime(glue, RTSTUB_ID(JSCall), {glue, env, actualArgC, printfunc, newtarget, thisObj,
GateRef result = CallNGCRuntime(glue, RTSTUB_ID(JSCall), {glue, actualArgC, printfunc, newtarget, thisObj,
a, b, Undefined(), pcOffset});
Return(result);
}
@ -141,13 +134,12 @@ void FooNativeAOTStubBuilder::GenerateCircuit()
void FooBoundAOTStubBuilder::GenerateCircuit()
{
GateRef glue = PtrArgument(0);
GateRef env = TaggedArgument(1);
GateRef argc = Int64Argument(2);
GateRef calltarget = TaggedArgument(3);
GateRef newtarget = TaggedArgument(4);
GateRef thisObj = TaggedArgument(5);
GateRef a = TaggedArgument(6);
GateRef b = TaggedArgument(7);
GateRef argc = Int32Argument(1);
GateRef calltarget = TaggedArgument(2);
GateRef newtarget = TaggedArgument(3);
GateRef thisObj = TaggedArgument(4);
GateRef a = TaggedArgument(5);
GateRef b = TaggedArgument(6);
GateRef bindArguments = IntToTaggedInt(Int32(37));
GateRef pcOffset = Int32(1);
(void)calltarget;
@ -155,9 +147,9 @@ void FooBoundAOTStubBuilder::GenerateCircuit()
GateRef barIndex = IntToTaggedInt(Int32(CommonStubCSigns::BarAOT));
GateRef barfunc = CallRuntime(glue, RTSTUB_ID(DefineAotFunc), {barIndex, numArgs});
GateRef bindfunc = CallRuntime(glue, RTSTUB_ID(GetBindFunc), {barfunc});
GateRef newjsfunc = CallNGCRuntime(glue, RTSTUB_ID(JSCall), {glue, env, Int64(5), bindfunc, newtarget, barfunc,
GateRef newjsfunc = CallNGCRuntime(glue, RTSTUB_ID(JSCall), {glue, Int64(5), bindfunc, newtarget, barfunc,
Int64(0x02), bindArguments, pcOffset});
GateRef result = CallNGCRuntime(glue, RTSTUB_ID(JSCall), {glue, env, argc, newjsfunc, newtarget, thisObj,
GateRef result = CallNGCRuntime(glue, RTSTUB_ID(JSCall), {glue, argc, newjsfunc, newtarget, thisObj,
a, b, pcOffset});
Return(result);
}
@ -165,13 +157,12 @@ void FooBoundAOTStubBuilder::GenerateCircuit()
void FooProxyAOTStubBuilder::GenerateCircuit()
{
GateRef glue = PtrArgument(0);
GateRef env = TaggedArgument(1);
GateRef argc = Int64Argument(2);
[[maybe_unused]] GateRef calltarget = TaggedArgument(3);
GateRef newtarget = TaggedArgument(4);
GateRef thisObj = TaggedArgument(5);
GateRef a = TaggedArgument(6);
GateRef b = TaggedArgument(7);
GateRef argc = Int32Argument(1);
[[maybe_unused]] GateRef calltarget = TaggedArgument(2);
GateRef newtarget = TaggedArgument(3);
GateRef thisObj = TaggedArgument(4);
GateRef a = TaggedArgument(5);
GateRef b = TaggedArgument(6);
GateRef pcOffset = Int32(1);
GateRef barIndex = IntToTaggedInt(Int32(CommonStubCSigns::BarAOT));
@ -180,20 +171,19 @@ void FooProxyAOTStubBuilder::GenerateCircuit()
GateRef proxyfunc = CallRuntime(glue, RTSTUB_ID(DefineProxyFunc), {barfunc});
GateRef result =
CallNGCRuntime(glue, RTSTUB_ID(JSCall), {glue, env, argc, proxyfunc, newtarget, thisObj, a, b, pcOffset});
CallNGCRuntime(glue, RTSTUB_ID(JSCall), {glue, argc, proxyfunc, newtarget, thisObj, a, b, pcOffset});
Return(result);
}
void FooProxy2AOTStubBuilder::GenerateCircuit()
{
GateRef glue = PtrArgument(0);
GateRef env = TaggedArgument(1);
GateRef argc = Int64Argument(2);
[[maybe_unused]] GateRef calltarget = TaggedArgument(3);
GateRef newtarget = TaggedArgument(4);
GateRef thisObj = TaggedArgument(5);
GateRef a = TaggedArgument(6);
GateRef b = TaggedArgument(7);
GateRef argc = Int32Argument(1);
[[maybe_unused]] GateRef calltarget = TaggedArgument(2);
GateRef newtarget = TaggedArgument(3);
GateRef thisObj = TaggedArgument(4);
GateRef a = TaggedArgument(5);
GateRef b = TaggedArgument(6);
GateRef pcOffset = Int32(1);
GateRef barIndex = IntToTaggedInt(Int32(CommonStubCSigns::Bar2AOT));
@ -203,18 +193,17 @@ void FooProxy2AOTStubBuilder::GenerateCircuit()
GateRef proxyfunc = CallRuntime(glue, RTSTUB_ID(DefineProxyFunc2), {barfunc, proxyHandler});
GateRef result =
CallNGCRuntime(glue, RTSTUB_ID(JSCall), {glue, env, argc, proxyfunc, newtarget, thisObj, a, b, pcOffset});
CallNGCRuntime(glue, RTSTUB_ID(JSCall), {glue, argc, proxyfunc, newtarget, thisObj, a, b, pcOffset});
Return(result);
}
void Bar2AOTStubBuilder::GenerateCircuit()
{
[[maybe_unused]] GateRef glue = PtrArgument(0);
[[maybe_unused]] GateRef env = TaggedArgument(1);
[[maybe_unused]] GateRef argc = Int64Argument(2);
[[maybe_unused]] GateRef calltarget = TaggedArgument(3);
[[maybe_unused]] GateRef newtarget = TaggedArgument(4);
[[maybe_unused]] GateRef thisObj = TaggedArgument(5);
[[maybe_unused]] GateRef argc = Int32Argument(1);
[[maybe_unused]] GateRef calltarget = TaggedArgument(2);
[[maybe_unused]] GateRef newtarget = TaggedArgument(3);
[[maybe_unused]] GateRef thisObj = TaggedArgument(4);
CallRuntime(glue, RTSTUB_ID(DumpTaggedType), {thisObj});
Return(thisObj);
}

54
ecmascript/compiler/test_stubs_signature.cpp
View File

@ -19,12 +19,11 @@ namespace panda::ecmascript::kungfu {
DEF_CALL_SIGNATURE(FooAOT)
{
// 7 : 7 input parameters
CallSignature fooAot("FooAOT", 0, 8,
CallSignature fooAot("FooAOT", 0, 7,
ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
*callSign = fooAot;
std::array<VariableType, 8> params = { // 8 : 8 input parameters
std::array<VariableType, 7> params = { // 7 : 7 input parameters
VariableType::NATIVE_POINTER(),
VariableType::JS_ANY(), // lexenv
VariableType::INT64(),
VariableType::JS_ANY(), // calltarget
VariableType::JS_ANY(), // newTarget
@ -39,12 +38,11 @@ DEF_CALL_SIGNATURE(FooAOT)
DEF_CALL_SIGNATURE(Foo1AOT)
{
// 7 : 7 input parameters
CallSignature foo1Aot("Foo1AOT", 0, 8,
CallSignature foo1Aot("Foo1AOT", 0, 7,
ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
*callSign = foo1Aot;
std::array<VariableType, 8> params = { // 8 : 8 input parameters
std::array<VariableType, 7> params = { // 7 : 7 input parameters
VariableType::NATIVE_POINTER(),
VariableType::JS_ANY(), // lexenv
VariableType::INT64(),
VariableType::JS_ANY(), // calltarget
VariableType::JS_ANY(), // newTarget
@ -59,12 +57,11 @@ DEF_CALL_SIGNATURE(Foo1AOT)
DEF_CALL_SIGNATURE(Foo2AOT)
{
// 7 : 7 input parameters
CallSignature foo2Aot("Foo2AOT", 0, 8,
CallSignature foo2Aot("Foo2AOT", 0, 7,
ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
*callSign = foo2Aot;
std::array<VariableType, 8> params = { // 8 : 8 input parameters
std::array<VariableType, 7> params = { // 7 : 7 input parameters
VariableType::NATIVE_POINTER(),
VariableType::JS_ANY(), // lexenv
VariableType::INT64(),
VariableType::JS_ANY(), // calltarget
VariableType::JS_ANY(), // newTarget
@ -79,12 +76,11 @@ DEF_CALL_SIGNATURE(Foo2AOT)
DEF_CALL_SIGNATURE(FooNativeAOT)
{
// 7 : 7 input parameters
CallSignature foo2Aot("FooNativeAOT", 0, 8,
CallSignature foo2Aot("FooNativeAOT", 0, 7,
ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
*callSign = foo2Aot;
std::array<VariableType, 8> params = { // 8 : 8 input parameters
std::array<VariableType, 7> params = { // 7 : 7 input parameters
VariableType::NATIVE_POINTER(),
VariableType::JS_ANY(), // lexenv
VariableType::INT64(),
VariableType::JS_ANY(), // calltarget
VariableType::JS_ANY(), // newTarget
@ -99,12 +95,11 @@ DEF_CALL_SIGNATURE(FooNativeAOT)
DEF_CALL_SIGNATURE(FooBoundAOT)
{
// 7 : 7 input parameters
CallSignature foo2Aot("FooBoundAOT", 0, 8,
CallSignature foo2Aot("FooBoundAOT", 0, 7,
ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
*callSign = foo2Aot;
std::array<VariableType, 8> params = { // 8 : 8 input parameters
std::array<VariableType, 7> params = { // 7 : 7 input parameters
VariableType::NATIVE_POINTER(),
VariableType::JS_ANY(), // lexenv
VariableType::INT64(),
VariableType::JS_ANY(), // calltarget
VariableType::JS_ANY(), // newTarget
@ -119,12 +114,11 @@ DEF_CALL_SIGNATURE(FooBoundAOT)
DEF_CALL_SIGNATURE(Bar1AOT)
{
// 8 : 8 input parameters
CallSignature barAot("Bar1AOT", 0, 9,
CallSignature barAot("Bar1AOT", 0, 8,
ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
*callSign = barAot;
std::array<VariableType, 9> params = { // 9 : 9 input parameters
std::array<VariableType, 8> params = { // 8 : 8 input parameters
VariableType::NATIVE_POINTER(),
VariableType::JS_ANY(), // lexenv
VariableType::INT64(),
VariableType::JS_ANY(), // calltarget
VariableType::JS_ANY(), // newTarget
@ -140,12 +134,11 @@ DEF_CALL_SIGNATURE(Bar1AOT)
DEF_CALL_SIGNATURE(BarAOT)
{
// 7 : 7 input parameters
CallSignature barAot("BarAOT", 0, 8,
CallSignature barAot("BarAOT", 0, 7,
ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
*callSign = barAot;
std::array<VariableType, 8> params = { // 8 : 8 input parameters
std::array<VariableType, 7> params = { // 7 : 7 input parameters
VariableType::NATIVE_POINTER(),
VariableType::JS_ANY(), // lexEnv
VariableType::INT64(),
VariableType::JS_ANY(), // calltarget
VariableType::JS_ANY(), // newTarget
@ -160,12 +153,11 @@ DEF_CALL_SIGNATURE(BarAOT)
DEF_CALL_SIGNATURE(FooProxyAOT)
{
// 8 : 8 input parameters
CallSignature fooProxyAot("FooProxyAOT", 0, 8,
CallSignature fooProxyAot("FooProxyAOT", 0, 7,
ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
*callSign = fooProxyAot;
std::array<VariableType, 8> params = { // 8 : 8 input parameters
std::array<VariableType, 7> params = { // 7 : 7 input parameters
VariableType::NATIVE_POINTER(),
VariableType::JS_ANY(), // lexEnv
VariableType::INT64(),
VariableType::JS_ANY(), // calltarget
VariableType::JS_ANY(), // newTarget
@ -179,13 +171,12 @@ DEF_CALL_SIGNATURE(FooProxyAOT)
DEF_CALL_SIGNATURE(FooProxy2AOT)
{
// 8 : 8 input parameters
CallSignature FooProxy2AOT("FooProxy2AOT", 0, 8,
// 7 : 7 input parameters
CallSignature FooProxy2AOT("FooProxy2AOT", 0, 7,
ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
*callSign = FooProxy2AOT;
std::array<VariableType, 8> params = { // 8 : 8 input parameters
std::array<VariableType, 7> params = { // 7 : 7 input parameters
VariableType::NATIVE_POINTER(),
VariableType::JS_ANY(), // lexEnv
VariableType::INT64(),
VariableType::JS_ANY(), // calltarget
VariableType::JS_ANY(), // newTarget
@ -199,13 +190,12 @@ DEF_CALL_SIGNATURE(FooProxy2AOT)
DEF_CALL_SIGNATURE(Bar2AOT)
{
// 7 : 7 input parameters
CallSignature bar2Aot("Bar2AOT", 0, 6,
// 5 : 5 input parameters
CallSignature bar2Aot("Bar2AOT", 0, 5,
ArgumentsOrder::DEFAULT_ORDER, VariableType::JS_ANY());
*callSign = bar2Aot;
std::array<VariableType, 6> params = { // 6 : 6 input parameters
std::array<VariableType, 5> params = { // 5 : 5 input parameters
VariableType::NATIVE_POINTER(),
VariableType::JS_ANY(), // lexenv
VariableType::INT64(),
VariableType::JS_ANY(), // calltarget
VariableType::JS_ANY(), // newTarget

2
ecmascript/compiler/trampoline/aarch64/asm_interpreter_call.cpp
View File

@ -614,7 +614,7 @@ void AsmInterpreterCall::PushBuiltinFrame(ExtendedAssembler *assembler, Register
// 16: type & next
__ Stp(next, op, MemoryOperand(sp, -2 * FRAME_SLOT_SIZE, AddrMode::PREINDEX));
__ Add(Register(FP), sp, Immediate(2 * FRAME_SLOT_SIZE)); // 16: skip next and frame type
} else if (type == FrameType::BUILTIN_ENTRY_FRAME || type == FrameType::BUILTIN_CALL_LEAVE_FRAME) {
} else if (type == FrameType::BUILTIN_ENTRY_FRAME) {
// 16: type & next
__ Stp(next, op, MemoryOperand(sp, -2 * FRAME_SLOT_SIZE, AddrMode::PREINDEX));
__ Add(Register(FP), sp, Immediate(2 * FRAME_SLOT_SIZE)); // 16: skip next and frame type

91
ecmascript/compiler/trampoline/aarch64/optimized_call.cpp
View File

@ -101,7 +101,7 @@ void OptimizedCall::IncreaseStackForArguments(ExtendedAssembler *assembler, Regi
{
Register sp(SP);
__ Mov(currentSp, sp);
// add extra aguments, env and numArgs
// add extra aguments, numArgs
__ Add(argc, argc, Immediate(static_cast<int64_t>(CommonArgIdx::ACTUAL_ARGC)));
__ Sub(currentSp, currentSp, Operand(argc, UXTW, FRAME_SLOT_SIZE_LOG2));
Label aligned;
@ -171,14 +171,13 @@ void OptimizedCall::JSFunctionEntry(ExtendedAssembler *assembler)
}
// * uint64_t OptimizedCallOptimized(uintptr_t glue, uint32_t expectedNumArgs, uint32_t actualNumArgs,
// uintptr_t codeAddr, uintptr_t argv, uintptr_t lexEnv)
// uintptr_t codeAddr, uintptr_t argv)
// * Arguments wil CC calling convention:
// %x0 - glue
// %x1 - codeAddr
// %x2 - actualNumArgs
// %x3 - expectedNumArgs
// %x4 - argv
// %x5 - lexEnv
//
// * The OptimizedJSFunctionArgsConfig Frame's structure is illustrated as the following:
// +--------------------------+
@ -205,8 +204,7 @@ void OptimizedCall::OptimizedCallOptimized(ExtendedAssembler *assembler)
Register actualNumArgs(X2);
Register codeAddr(X3);
Register argV(X4);
Register env(X5);
Register currentSp(X6);
Register currentSp(X5);
Register sp(SP);
Label copyArguments;
Label invokeCompiledJSFunction;
@ -239,14 +237,13 @@ void OptimizedCall::OptimizedCallOptimized(ExtendedAssembler *assembler)
__ Bind(&invokeCompiledJSFunction);
{
__ Mov(Register(X19), expectedNumArgs);
__ Str(actualNumArgs, MemoryOperand(sp, FRAME_SLOT_SIZE));
__ Str(env, MemoryOperand(sp, 0)); // 0: means zero size
__ Str(actualNumArgs, MemoryOperand(sp, 0));
__ Blr(codeAddr);
}
// pop argV argC
// 3 : 3 means argC * 8
__ Ldr(actualNumArgs, MemoryOperand(sp, FRAME_SLOT_SIZE));
__ Ldr(actualNumArgs, MemoryOperand(sp, 0));
PopJSFunctionArgs(assembler, Register(X19), actualNumArgs);
// pop prevLeaveFrameFp to restore thread->currentFrame_
PopOptimizedArgsConfigFrame(assembler);
@ -303,20 +300,25 @@ void OptimizedCall::CallBuiltinTrampoline(ExtendedAssembler *assembler)
Register glue(X0);
Register sp(SP);
Register nativeFuncAddr(X4);
Register glueTemp(X2);
Register temp(X1);
Register zero(Zero);
__ Mov(glueTemp, glue);
__ Str(glue, MemoryOperand(sp, 0)); // thread (instead of env)
__ Add(Register(X0), sp, Immediate(0));
AsmInterpreterCall::PushBuiltinFrame(assembler, glueTemp, FrameType::BUILTIN_CALL_LEAVE_FRAME, temp, zero);
__ Stp(Register(X30), glue, MemoryOperand(sp, -DOUBLE_SLOT_SIZE, AddrMode::PREINDEX));
__ Mov(temp, Immediate(static_cast<int32_t>(FrameType::BUILTIN_CALL_LEAVE_FRAME)));
__ Stp(temp, Register(X29), MemoryOperand(sp, -DOUBLE_SLOT_SIZE, AddrMode::PREINDEX));
__ Add(temp, sp, Immediate(FRAME_SLOT_SIZE));
__ Str(temp, MemoryOperand(glue, JSThread::GlueData::GetLeaveFrameOffset(false)));
__ Mov(Register(X29), temp);
__ Add(Register(X0), sp, Immediate(TRIPLE_SLOT_SIZE));
AsmInterpreterCall::CallNativeInternal(assembler, nativeFuncAddr);
__ Blr(nativeFuncAddr);
__ Mov(temp, Register(FP));
__ Ldp(Register(X29), Register(X30), MemoryOperand(temp, DOUBLE_SLOT_SIZE, AddrMode::POSTINDEX));
__ Add(temp, temp, Immediate(FRAME_SLOT_SIZE));
__ Mov(sp, temp);
__ Ret();
}
// * uint64_t JSCall(uintptr_t glue, JSTaggedType env, uint32_t argc, JSTaggedType calltarget, JSTaggedType new,
// * uint64_t JSCall(uintptr_t glue, uint32_t argc, JSTaggedType calltarget, JSTaggedType new,
// JSTaggedType this, arg[0], arg[1], arg[2], ..., arg[N-1])
// * webkit_jscc calling convention call js function()
//
@ -337,8 +339,6 @@ void OptimizedCall::CallBuiltinTrampoline(ExtendedAssembler *assembler)
// | call-target |
// |--------------------------|
// | argc |
// |--------------------------|
// | lexEnv |
// sp ----> |--------------------------| ---------------
// | returnAddr | ^
// |--------------------------| |
@ -353,7 +353,7 @@ void OptimizedCall::GenJSCall(ExtendedAssembler *assembler, bool isNew)
{
Register jsfunc(X1);
Register sp(SP);
__ Ldr(jsfunc, MemoryOperand(sp, FRAME_SLOT_SIZE * 2)); // 2: skip env and argc
__ Ldr(jsfunc, MemoryOperand(sp, FRAME_SLOT_SIZE));
JSCallInternal(assembler, jsfunc, isNew);
}
@ -387,12 +387,10 @@ void OptimizedCall::JSCallInternal(ExtendedAssembler *assembler, Register jsfunc
Label lCallBuiltinStub;
Label lCallNativeCpp;
__ Ldr(Register(X5), MemoryOperand(jsfunc, JSFunction::LEXICAL_ENV_OFFSET));
__ Str(Register(X5), MemoryOperand(sp, 0));
__ Ldr(Register(X5), MemoryOperand(jsfunc, 0));
__ Ldr(Register(X5), MemoryOperand(Register(X5), JSHClass::BIT_FIELD_OFFSET));
__ Ldr(method, MemoryOperand(jsfunc, JSFunction::METHOD_OFFSET));
__ Ldr(actualArgC, MemoryOperand(sp, FRAME_SLOT_SIZE));
__ Ldr(actualArgC, MemoryOperand(sp, 0));
__ Ldr(callField, MemoryOperand(method, Method::CALL_FIELD_OFFSET));
__ Tbnz(callField, MethodLiteral::IsNativeBit::START_BIT, &callNativeMethod);
if (!isNew) {
@ -401,8 +399,8 @@ void OptimizedCall::JSCallInternal(ExtendedAssembler *assembler, Register jsfunc
__ Tbnz(callField, MethodLiteral::IsAotCodeBit::START_BIT, &callOptimizedMethod);
{
Register argV(X5);
// aot argV = sp + 16
__ Add(argV, sp, Immediate(DOUBLE_SLOT_SIZE));
// aot argV = sp + 8
__ Add(argV, sp, Immediate(FRAME_SLOT_SIZE));
// asm interpreter argV = argv + 24
__ Add(argV, argV, Immediate(kungfu::ArgumentAccessor::GetFixArgsNum() * FRAME_SLOT_SIZE));
__ Sub(actualArgC, actualArgC, Immediate(kungfu::ArgumentAccessor::GetFixArgsNum()));
@ -439,15 +437,15 @@ void OptimizedCall::JSCallInternal(ExtendedAssembler *assembler, Register jsfunc
__ Ldr(builtinStub, MemoryOperand(builtinStub, JSThread::GlueData::GetBuiltinsStubEntriesOffset(false)));
__ Ldr(Register(X1), MemoryOperand(method, Method::NATIVE_POINTER_OR_BYTECODE_ARRAY_OFFSET));
__ Ldr(Register(X2), MemoryOperand(sp, DOUBLE_SLOT_SIZE)); // get jsfunc
__ Ldr(Register(X3), MemoryOperand(sp, TRIPLE_SLOT_SIZE)); // get newtarget
__ Ldr(Register(X4), MemoryOperand(sp, QUADRUPLE_SLOT_SIZE)); // get this
__ Ldr(Register(X5), MemoryOperand(sp, FRAME_SLOT_SIZE)); // get number args
__ Ldr(Register(X2), MemoryOperand(sp, FRAME_SLOT_SIZE)); // get jsfunc
__ Ldr(Register(X3), MemoryOperand(sp, DOUBLE_SLOT_SIZE)); // get newtarget
__ Ldr(Register(X4), MemoryOperand(sp, TRIPLE_SLOT_SIZE)); // get this
__ Ldr(Register(X5), MemoryOperand(sp, 0)); // get number args
__ Sub(Register(X5), Register(X5), Immediate(NUM_MANDATORY_JSFUNC_ARGS));
if (!isNew) {
Label lTailCall;
Register fp(X29);
__ Ldp(Register(X6), Register(X7), MemoryOperand(sp, QUINTUPLE_SLOT_SIZE)); // get arg0 arg1
__ Ldp(Register(X6), Register(X7), MemoryOperand(sp, QUADRUPLE_SLOT_SIZE)); // get arg0 arg1
__ Cmp(Register(X5), Immediate(3)); // 3: callarg3
__ B(Condition::NE, &lTailCall);
PushAsmBridgeFrame(assembler);
@ -467,7 +465,7 @@ void OptimizedCall::JSCallInternal(ExtendedAssembler *assembler, Register jsfunc
__ Br(builtinStub);
}
} else {
__ Add(Register(X6), sp, Immediate(QUINTUPLE_SLOT_SIZE)); // get argV
__ Add(Register(X6), sp, Immediate(QUADRUPLE_SLOT_SIZE)); // get argV
__ Br(builtinStub);
}
}
@ -529,7 +527,7 @@ void OptimizedCall::ConstructorJSCall(ExtendedAssembler *assembler)
__ BindAssemblerStub(RTSTUB_ID(ConstructorJSCall));
Register jsfunc(X1);
Register sp(SP);
__ Ldr(jsfunc, MemoryOperand(sp, FRAME_SLOT_SIZE * 2)); // 2: skip env and argc
__ Ldr(jsfunc, MemoryOperand(sp, FRAME_SLOT_SIZE)); // 2: skip argc
ConstructorJSCallInternal(assembler, jsfunc);
}
@ -547,8 +545,6 @@ void OptimizedCall::ConstructorJSCallInternal(ExtendedAssembler *assembler, Regi
Register actualArgC(X4);
Label callNativeMethod;
Label callOptimizedMethod;
__ Ldr(Register(X5), MemoryOperand(jsfunc, JSFunction::LEXICAL_ENV_OFFSET));
__ Str(Register(X5), MemoryOperand(sp, 0));
__ Ldr(Register(X5), MemoryOperand(jsfunc, JSFunction::HCLASS_OFFSET));
__ Ldr(Register(X5), MemoryOperand(Register(X5), JSHClass::BIT_FIELD_OFFSET));
__ Ldr(method, MemoryOperand(jsfunc, JSFunction::METHOD_OFFSET));
@ -663,8 +659,7 @@ void OptimizedCall::CallOptimziedMethodInternal(ExtendedAssembler *assembler, Re
Register arg2(X2);
Register codeAddress(X3);
Register argV(X4);
Register env(X5);
Register method(X6);
Register method(X5);
Label directCallCodeEntry;
const int64_t argoffsetSlot = static_cast<int64_t>(CommonArgIdx::FUNC) - 1;
__ Mov(Register(X5), jsfunc);
@ -675,10 +670,9 @@ void OptimizedCall::CallOptimziedMethodInternal(ExtendedAssembler *assembler, Re
MethodLiteral::NumArgsBits::Mask() >> MethodLiteral::NumArgsBits::START_BIT, RegWSize));
__ Add(expectedNumArgs, callField.W(), Immediate(NUM_MANDATORY_JSFUNC_ARGS));
__ Cmp(arg2.W(), expectedNumArgs);
__ Add(argV, sp, Immediate(argoffsetSlot * FRAME_SLOT_SIZE)); // skip env and numArgs
__ Add(argV, sp, Immediate(argoffsetSlot * FRAME_SLOT_SIZE)); // skip numArgs
__ Ldr(method, MemoryOperand(Register(X5), JSFunctionBase::METHOD_OFFSET)); // get method
__ Ldr(codeAddress, MemoryOperand(method, Method::CODE_ENTRY_OFFSET)); // get codeAddress
__ Ldr(env, MemoryOperand(sp, 0));
__ B(Condition::HS, &directCallCodeEntry);
__ CallAssemblerStub(RTSTUB_ID(OptimizedCallOptimized), true);
__ Bind(&directCallCodeEntry);
@ -692,12 +686,10 @@ void OptimizedCall::JSBoundFunctionCallInternal(ExtendedAssembler *assembler, Re
PushOptimizedArgsConfigFrame(assembler);
Register basefp(X29);
Register fp = __ AvailableRegister1();
Register env(X5);
Register argV(X6);
Register argV(X5);
__ Add(argV, basefp, Immediate(GetStackArgOffSetToFp(0))); // 0: first index id
__ Ldr(actualArgC, MemoryOperand(argV, FRAME_SLOT_SIZE));
__ Ldr(env, MemoryOperand(argV, 0));
__ Ldr(actualArgC, MemoryOperand(argV, 0));
Register boundLength(X2);
Register realArgC(X7, W);
@ -745,7 +737,6 @@ void OptimizedCall::JSBoundFunctionCallInternal(ExtendedAssembler *assembler, Re
__ Ldr(boundTarget, MemoryOperand(jsfunc, JSBoundFunction::BOUND_TARGET_OFFSET));
// 2 : 2 means pair
__ Stp(Register(X19), boundTarget, MemoryOperand(fp, -FRAME_SLOT_SIZE * 2, AddrMode::PREINDEX));
__ Str(env, MemoryOperand(fp, -FRAME_SLOT_SIZE, AddrMode::PREINDEX));
}
__ CallAssemblerStub(stubId, false);
@ -759,8 +750,8 @@ void OptimizedCall::JSProxyCallInternal(ExtendedAssembler *assembler, Register s
// input: x1(calltarget)
// output: glue:x0 argc:x1 calltarget:x2 argv:x3
__ Mov(Register(X2), jsfunc);
__ Ldr(Register(X1), MemoryOperand(sp, FRAME_SLOT_SIZE)); // 8: skip env
__ Add(X3, sp, Immediate(FRAME_SLOT_SIZE * 2)); // 2: get argv
__ Ldr(Register(X1), MemoryOperand(sp, 0));
__ Add(X3, sp, Immediate(FRAME_SLOT_SIZE)); // get argv
Register proxyCallInternalId(X9);
Register baseAddress(X8);
@ -826,12 +817,12 @@ void OptimizedCall::CallRuntimeWithArgv(ExtendedAssembler *assembler)
__ Str(runtimeId, MemoryOperand(sp, -FRAME_SLOT_SIZE, AddrMode::PREINDEX));
__ PushFpAndLr();
Register fp(X29);
__ Str(fp, MemoryOperand(glue, JSThread::GlueData::GetLeaveFrameOffset(false)));
// construct leave frame
Register frameType(X9);
__ Mov(frameType, Immediate(static_cast<int64_t>(FrameType::LEAVE_FRAME_WITH_ARGV)));
__ Str(frameType, MemoryOperand(sp, -FRAME_SLOT_SIZE, AddrMode::PREINDEX));
__ Add(Register(FP), sp, Immediate(FRAME_SLOT_SIZE));
__ Str(fp, MemoryOperand(glue, JSThread::GlueData::GetLeaveFrameOffset(false)));
// load runtime trampoline address
Register tmp(X9);
@ -1042,7 +1033,6 @@ void OptimizedCall::GenJSCallWithArgV(ExtendedAssembler *assembler, bool isNew)
Register newTarget(X3);
Register thisObj(X4);
Register argV(X5);
Register env(X6);
Register currentSp = __ AvailableRegister1();
Register callsiteSp = __ AvailableRegister2();
Label pushCallThis;
@ -1064,8 +1054,6 @@ void OptimizedCall::GenJSCallWithArgV(ExtendedAssembler *assembler, bool isNew)
__ Bind(&pushCallThis);
PushMandatoryJSArgs(assembler, jsfunc, thisObj, newTarget, currentSp);
__ Str(actualNumArgs, MemoryOperand(currentSp, -FRAME_SLOT_SIZE, AddrMode::PREINDEX));
__ Ldr(env, MemoryOperand(jsfunc, JSFunction::LEXICAL_ENV_OFFSET));
__ Str(env, MemoryOperand(currentSp, -FRAME_SLOT_SIZE, AddrMode::PREINDEX));
if (isNew) {
__ CallAssemblerStub(RTSTUB_ID(JSCallNew), false);
@ -1073,7 +1061,7 @@ void OptimizedCall::GenJSCallWithArgV(ExtendedAssembler *assembler, bool isNew)
__ CallAssemblerStub(RTSTUB_ID(JSCall), false);
}
__ Ldr(actualNumArgs, MemoryOperand(sp, FRAME_SLOT_SIZE));
__ Ldr(actualNumArgs, MemoryOperand(sp, 0));
PopJSFunctionArgs(assembler, actualNumArgs, actualNumArgs);
PopOptimizedUnfoldArgVFrame(assembler);
__ Ret();
@ -1101,7 +1089,6 @@ void OptimizedCall::ConstructorJSCallWithArgV([[maybe_unused]] ExtendedAssembler
Register newTarget(X3);
Register thisObj(X4);
Register argV(X5);
Register env(X6);
Register currentSp = __ AvailableRegister1();
Register callsiteSp = __ AvailableRegister2();
Label pushCallThis;
@ -1123,12 +1110,10 @@ void OptimizedCall::ConstructorJSCallWithArgV([[maybe_unused]] ExtendedAssembler
__ Bind(&pushCallThis);
PushMandatoryJSArgs(assembler, jsfunc, thisObj, newTarget, currentSp);
__ Str(actualNumArgs, MemoryOperand(currentSp, -FRAME_SLOT_SIZE, AddrMode::PREINDEX));
__ Ldr(env, MemoryOperand(jsfunc, JSFunction::LEXICAL_ENV_OFFSET));
__ Str(env, MemoryOperand(currentSp, -FRAME_SLOT_SIZE, AddrMode::PREINDEX));
__ CallAssemblerStub(RTSTUB_ID(ConstructorJSCall), false);
__ Ldr(actualNumArgs, MemoryOperand(sp, FRAME_SLOT_SIZE));
__ Ldr(actualNumArgs, MemoryOperand(sp, 0));
PopJSFunctionArgs(assembler, actualNumArgs, actualNumArgs);
PopOptimizedUnfoldArgVFrame(assembler);
__ Ret();

125
ecmascript/compiler/trampoline/x64/optimized_call.cpp
View File

@ -97,14 +97,13 @@ void OptimizedCall::JSFunctionEntry(ExtendedAssembler *assembler)
}
// * uint64_t OptimizedCallOptimized(uintptr_t glue, uint32_t expectedNumArgs, uint32_t actualNumArgs,
// uintptr_t codeAddr, uintptr_t argv, uintptr_t lexEnv)
// uintptr_t codeAddr, uintptr_t argv)
// * Arguments wil CC calling convention:
// %rdi - glue
// %rsi - codeAddr
// %rdx - actualNumArgs
// %rcx - expectedNumArgs
// %r8 - argv
// %r9 - lexEnv
//
// * The OptimizedJSFunctionArgsConfig Frame's structure is illustrated as the following:
// +--------------------------+
@ -131,18 +130,14 @@ void OptimizedCall::OptimizedCallOptimized(ExtendedAssembler *assembler)
Register actualNumArgsReg = rdx;
Register codeAddrReg = rsi;
Register argvReg = r8;
Register envReg = r9;
Label lAlign16Bytes1;
Label lCopyExtraAument1;
Label lCopyArguments1;
Label lCopyLoop1;
Label lPopFrame1;
__ Pushq(rbp);
__ Pushq(static_cast<int32_t>(FrameType::OPTIMIZED_JS_FUNCTION_ARGS_CONFIG_FRAME));
__ Pushq(envReg);
// 2: skip envReg and frameType
__ Leaq(Operand(rsp, 2 * FRAME_SLOT_SIZE), rbp);
// 2: skip jsFunc and frameType
__ Leaq(Operand(rsp, FRAME_SLOT_SIZE), rbp);
// callee save
__ Pushq(r14);
__ Pushq(rbx);
@ -151,41 +146,27 @@ void OptimizedCall::OptimizedCallOptimized(ExtendedAssembler *assembler)
// 16 bytes align check
__ Movl(expectedNumArgsReg, r14);
__ Testb(1, r14);
__ Jne(&lAlign16Bytes1);
__ Jne(&lCopyExtraAument1);
__ Pushq(0);
__ Bind(&lAlign16Bytes1);
// expectedNumArgs > actualNumArgs
__ Movl(expectedNumArgsReg, rbx);
__ Cmpl(actualNumArgsReg, expectedNumArgsReg); // save expectedNumArgs
__ Jbe(&lCopyArguments1);
__ Movl(actualNumArgsReg, rax);
__ Movl(rbx, expectedNumArgsReg);
__ Bind(&lCopyExtraAument1); // copy undefined value to stack
__ Pushq(JSTaggedValue::VALUE_UNDEFINED);
__ Addq(-1, expectedNumArgsReg);
__ Cmpq(rax, expectedNumArgsReg);
__ Cmpq(actualNumArgsReg, expectedNumArgsReg);
__ Ja(&lCopyExtraAument1);
__ Bind(&lCopyArguments1);
__ Cmpl(actualNumArgsReg, rbx);
__ CMovbe(rbx, actualNumArgsReg);
__ Movl(actualNumArgsReg, rax); // rax = actualNumArgsReg
__ Bind(&lCopyLoop1);
__ Movq(Operand(argvReg, rax, Scale::Times8, -FRAME_SLOT_SIZE), rbx); // -8: stack index
__ Movq(Operand(argvReg, expectedNumArgsReg, Scale::Times8, -FRAME_SLOT_SIZE), rbx); // -8: stack index
__ Pushq(rbx);
__ Addq(-1, rax);
__ Addq(-1, expectedNumArgsReg);
__ Jne(&lCopyLoop1);
__ Pushq(actualNumArgsReg); // actual argc
__ Pushq(envReg);
__ Movq(glueReg, rax); // mov glue to rax
__ Callq(codeAddrReg); // then call jsFunction
__ Leaq(Operand(r14, Scale::Times8, 0), codeAddrReg);
__ Addq(codeAddrReg, rsp);
__ Addq(DOUBLE_SLOT_SIZE, rsp); // skip actualNumArgsReg and envReg
__ Addq(FRAME_SLOT_SIZE, rsp); // skip actualNumArgsReg
__ Testb(1, r14); // stack 16bytes align check
__ Jne(&lPopFrame1);
__ Addq(8, rsp); // 8: align byte
@ -194,7 +175,7 @@ void OptimizedCall::OptimizedCallOptimized(ExtendedAssembler *assembler)
__ Addq(8, rsp); // 8: skip rax
__ Popq(rbx);
__ Popq(r14);
__ Addq(DOUBLE_SLOT_SIZE, rsp); // skip frame type, env reg
__ Addq(FRAME_SLOT_SIZE, rsp); // skip frame type
__ Pop(rbp);
__ Ret();
}
@ -245,12 +226,15 @@ void OptimizedCall::CallBuiltinTrampoline(ExtendedAssembler *assembler)
Register glueReg = rax;
Register nativeCode = rsi;
__ Movq(glueReg, Operand(rsp, FRAME_SLOT_SIZE)); // thread (instead of env)
__ Movq(Operand(rsp, 0), rdx);
__ Movq(rax, Operand(rsp, 0));
__ Push(rdx);
AsmInterpreterCall::PushBuiltinFrame(assembler, glueReg, FrameType::BUILTIN_CALL_LEAVE_FRAME);
__ Leaq(Operand(rbp, 2 * FRAME_SLOT_SIZE), rdi); // 16: skip argc & env
__ PushAlignBytes();
__ Leaq(Operand(rbp, 2 * FRAME_SLOT_SIZE), rdi); // 16: skip rbp & return Addr
AsmInterpreterCall::CallNativeInternal(assembler, nativeCode);
__ Pop(rdx);
__ Movq(rdx, Operand(rsp, 0));
__ Ret();
}
@ -356,10 +340,8 @@ void OptimizedCall::JSProxyCallInternalWithArgV(ExtendedAssembler *assembler)
Register method = rdx;
Register argV = r9;
{
__ Movq(Operand(jsFuncReg, JSFunction::LEXICAL_ENV_OFFSET), rdx);
__ Movq(rdx, Operand(rsp, FRAME_SLOT_SIZE));
__ Mov(Operand(jsFuncReg, JSFunctionBase::METHOD_OFFSET), method); // get method
__ Movl(Operand(rsp, DOUBLE_SLOT_SIZE), argc); // sp + 16 actual argc
__ Movl(Operand(rsp, FRAME_SLOT_SIZE), argc); // sp + 8 actual argc
__ Mov(Operand(method, Method::CALL_FIELD_OFFSET), methodCallField); // get call field
__ Btq(MethodLiteral::IsNativeBit::START_BIT, methodCallField); // is native
__ Jb(&lCallNativeMethod);
@ -383,10 +365,8 @@ void OptimizedCall::JSProxyCallInternalWithArgV(ExtendedAssembler *assembler)
__ Andl(((1LU << MethodLiteral::NumArgsBits::SIZE) - 1), methodCallField);
__ Addl(NUM_MANDATORY_JSFUNC_ARGS, methodCallField); // add mandatory argument
__ Movq(rsp, r8);
Register envReg = r9;
__ Movq(Operand(r8, FRAME_SLOT_SIZE), envReg); // get env
argvReg = r8;
__ Addq(TRIPLE_SLOT_SIZE, argvReg); // get argv
__ Addq(DOUBLE_SLOT_SIZE, argvReg); // get argv
__ Cmpl(expectedNumArgsReg, rdx); // expectedNumArgs <= actualNumArgs
__ Jg(&lDirectCallCodeEntry);
__ CallAssemblerStub(RTSTUB_ID(OptimizedCallOptimized), true);
@ -414,10 +394,8 @@ void OptimizedCall::JSProxyCallInternalWithArgV(ExtendedAssembler *assembler)
__ Leaq(Operand(rsp, FRAME_SLOT_SIZE), rbp);
__ Pushq(r10); // callee save
__ Movq(rsp, rdx);
__ Addq(QUINTUPLE_SLOT_SIZE, rdx); // sp + 40 argv
__ Addq(QUADRUPLE_SLOT_SIZE, rdx); // sp + 32 argv
__ Mov(Operand(rdx, 0), rax); // get origin argc
Register envReg = r9;
__ Mov(Operand(rdx, -FRAME_SLOT_SIZE), envReg); // get env
__ Movq(rax, r10);
// get bound target
__ Mov(Operand(jsFuncReg, JSBoundFunction::BOUND_ARGUMENTS_OFFSET), rcx);
@ -427,7 +405,7 @@ void OptimizedCall::JSProxyCallInternalWithArgV(ExtendedAssembler *assembler)
// 16 bytes align check
__ Testb(1, r10);
__ Je(&lAlign16Bytes2);
__ Jne(&lAlign16Bytes2);
__ PushAlignBytes(); // push zero to align 16 bytes stack
}
@ -470,16 +448,13 @@ void OptimizedCall::JSProxyCallInternalWithArgV(ExtendedAssembler *assembler)
__ Mov(Operand(jsFuncReg, JSBoundFunction::BOUND_TARGET_OFFSET), rax); // callTarget
__ Pushq(rax);
__ Pushq(r10); // push actual arguments
Register envReg = r9;
__ Pushq(envReg);
__ Movq(rdi, rax);
__ Callq(&jsCall); // call JSCall
__ Addq(FRAME_SLOT_SIZE, rsp); // skip env
__ Pop(r10);
__ Leaq(Operand(r10, Scale::Times8, 0), rcx); // 8: offset
__ Addq(rcx, rsp);
__ Testb(1, r10); // stack 16bytes align check
__ Je(&lPopFrame2);
__ Jne(&lPopFrame2);
__ Addq(FRAME_SLOT_SIZE, rsp); // 8: sp + 8
}
@ -502,7 +477,7 @@ void OptimizedCall::JSProxyCallInternalWithArgV(ExtendedAssembler *assembler)
__ Ret();
}
// * uint64_t JSCall(uintptr_t glue, JSTaggedType env, uint32_t argc, JSTaggedType calltarget, JSTaggedType new,
// * uint64_t JSCall(uintptr_t glue, uint32_t argc, JSTaggedType calltarget, JSTaggedType new,
// JSTaggedType this, arg[0], arg[1], arg[2], ..., arg[N-1])
// * webkit_jscc calling convention call js function()
//
@ -523,8 +498,6 @@ void OptimizedCall::JSProxyCallInternalWithArgV(ExtendedAssembler *assembler)
// | call-target |
// |--------------------------|
// | argc |
// |--------------------------|
// | lexEnv |
// |--------------------------| ---------------
// | returnAddr | ^
// sp ----> |--------------------------| |
@ -564,7 +537,7 @@ void OptimizedCall::GenJSCall(ExtendedAssembler *assembler, bool isNew)
{
__ Movq(glueReg, rdi);
glueReg = rdi;
__ Movq(Operand(rsp, TRIPLE_SLOT_SIZE), rax); // sp + 24 get jsFunc
__ Movq(Operand(rsp, DOUBLE_SLOT_SIZE), rax); // sp + 16 get jsFunc
}
__ Bind(&lJSCallStart);
Register jsFuncReg = rax;
@ -593,10 +566,8 @@ void OptimizedCall::GenJSCall(ExtendedAssembler *assembler, bool isNew)
Register argV = r9;
{
Label lCallConstructor;
__ Movq(Operand(jsFuncReg, JSFunction::LEXICAL_ENV_OFFSET), rdx);
__ Movq(rdx, Operand(rsp, FRAME_SLOT_SIZE));
__ Mov(Operand(jsFuncReg, JSFunctionBase::METHOD_OFFSET), method); // get method
__ Movl(Operand(rsp, DOUBLE_SLOT_SIZE), argc); // sp + 16 actual argc
__ Movl(Operand(rsp, FRAME_SLOT_SIZE), argc); // sp + 8 actual argc
__ Mov(Operand(method, Method::CALL_FIELD_OFFSET), methodCallField); // get call field
__ Btq(MethodLiteral::IsNativeBit::START_BIT, methodCallField); // is native
__ Jb(&lCallNativeMethod);
@ -607,7 +578,7 @@ void OptimizedCall::GenJSCall(ExtendedAssembler *assembler, bool isNew)
__ Btq(MethodLiteral::IsAotCodeBit::START_BIT, methodCallField); // is aot
__ Jb(&lCallOptimziedMethod);
__ Movq(rsp, argV);
__ Addq(TRIPLE_SLOT_SIZE, argV); // sp + 24 get aot argv
__ Addq(DOUBLE_SLOT_SIZE, argV); // sp + 16 get aot argv
__ Subq(Immediate(kungfu::ArgumentAccessor::GetFixArgsNum()), argc);
// argv + 24 get asm interpreter argv
__ Addq(kungfu::ArgumentAccessor::GetFixArgsNum() * FRAME_SLOT_SIZE, argV);
@ -679,8 +650,8 @@ void OptimizedCall::GenJSCall(ExtendedAssembler *assembler, bool isNew)
__ Movq(Operand(glueReg, r10, Times8, JSThread::GlueData::GetBuiltinsStubEntriesOffset(false)), r10);
__ Movq(argc, r9);
__ Movq(Operand(rsp, QUADRUPLE_SLOT_SIZE), rcx); // newTarget
__ Movq(Operand(rsp, QUINTUPLE_SLOT_SIZE), r8); // this
__ Movq(Operand(rsp, TRIPLE_SLOT_SIZE), rcx); // newTarget
__ Movq(Operand(rsp, QUADRUPLE_SLOT_SIZE), r8); // this
__ Subq(NUM_MANDATORY_JSFUNC_ARGS, r9); // argc
Label lCall0;
@ -691,7 +662,7 @@ void OptimizedCall::GenJSCall(ExtendedAssembler *assembler, bool isNew)
argV = rax;
__ Movq(rsp, argV);
__ Addq(SEXTUPLE_SLOT_SIZE, argV);
__ Addq(QUINTUPLE_SLOT_SIZE, argV);
__ Pushq(rbp);
__ Pushq(static_cast<int32_t>(FrameType::ASM_BRIDGE_FRAME));
__ Leaq(Operand(rsp, FRAME_SLOT_SIZE), rbp);
@ -784,7 +755,7 @@ void OptimizedCall::ConstructorJSCall(ExtendedAssembler *assembler)
{
__ Movq(glueReg, rdi);
glueReg = rdi;
__ Movq(Operand(rsp, TRIPLE_SLOT_SIZE), rax); // sp + 24 get jsFunc
__ Movq(Operand(rsp, DOUBLE_SLOT_SIZE), rax); // sp + 16 get jsFunc
}
__ Bind(&lConstructorJSCallStart);
Register jsFuncReg = rax;
@ -812,10 +783,8 @@ void OptimizedCall::ConstructorJSCall(ExtendedAssembler *assembler)
Register method = rdx;
Register argV = r9;
{
__ Movq(Operand(jsFuncReg, JSFunction::LEXICAL_ENV_OFFSET), rdx);
__ Movq(rdx, Operand(rsp, FRAME_SLOT_SIZE));
__ Mov(Operand(jsFuncReg, JSFunctionBase::METHOD_OFFSET), method); // get method
__ Movl(Operand(rsp, DOUBLE_SLOT_SIZE), argc); // sp + 16 actual argc
__ Movl(Operand(rsp, FRAME_SLOT_SIZE), argc); // sp + 8 actual argc
__ Mov(Operand(method, Method::CALL_FIELD_OFFSET), methodCallField); // get call field
__ Btq(MethodLiteral::IsNativeBit::START_BIT, methodCallField); // is native
__ Jb(&lCallNativeMethod);
@ -914,10 +883,8 @@ void OptimizedCall::CallOptimziedMethodInternal(ExtendedAssembler *assembler, Re
__ Andl(((1LU << MethodLiteral::NumArgsBits::SIZE) - 1), methodCallField);
__ Addl(NUM_MANDATORY_JSFUNC_ARGS, methodCallField); // add mandatory argumentr
__ Movq(rsp, r8);
Register envReg = r9;
__ Movq(Operand(r8, FRAME_SLOT_SIZE), envReg); // get env
Register argvReg = r8;
__ Addq(3 * FRAME_SLOT_SIZE, argvReg); // 3 : sp + 3 * 8 argv
__ Addq(2 * FRAME_SLOT_SIZE, argvReg); // 2 : sp + 2 * 8 argv
__ Cmpl(expectedNumArgsReg, rdx); // expectedNumArgs <= actualNumArgs
__ Jge(&lDirectCallCodeEntry);
__ CallAssemblerStub(RTSTUB_ID(OptimizedCallOptimized), true);
@ -941,10 +908,8 @@ void OptimizedCall::JSBoundFunctionCallInternal(ExtendedAssembler *assembler, Re
__ Leaq(Operand(rsp, FRAME_SLOT_SIZE), rbp);
__ Pushq(r10); // callee save
__ Movq(rsp, rdx);
__ Addq(QUINTUPLE_SLOT_SIZE, rdx); // sp + 40 argv
__ Addq(QUADRUPLE_SLOT_SIZE, rdx); // sp + 32 argv
__ Mov(Operand(rdx, 0), rax); // get origin argc
Register envReg = r9;
__ Mov(Operand(rdx, -FRAME_SLOT_SIZE), envReg); // get env
__ Movq(rax, r10);
// get bound target
__ Mov(Operand(jsFuncReg, JSBoundFunction::BOUND_ARGUMENTS_OFFSET), rcx);
@ -954,7 +919,7 @@ void OptimizedCall::JSBoundFunctionCallInternal(ExtendedAssembler *assembler, Re
// 16 bytes align check
__ Testb(1, r10);
__ Je(&lAlign16Bytes2);
__ Jne(&lAlign16Bytes2);
__ PushAlignBytes(); // push zero to align 16 bytes stack
__ Bind(&lAlign16Bytes2);
@ -997,16 +962,13 @@ void OptimizedCall::JSBoundFunctionCallInternal(ExtendedAssembler *assembler, Re
__ Mov(Operand(jsFuncReg, JSBoundFunction::BOUND_TARGET_OFFSET), rax); // callTarget
__ Pushq(rax);
__ Pushq(r10); // push actual arguments
envReg = r9;
__ Pushq(envReg);
__ Movq(rdi, rax);
__ Callq(jsCall); // call JSCall
__ Addq(8, rsp); // 8: sp + 8
__ Pop(r10);
__ Leaq(Operand(r10, Scale::Times8, 0), rcx); // 8: disp
__ Addq(rcx, rsp);
__ Testb(1, r10); // stack 16bytes align check
__ Je(&lPopFrame2);
__ Jne(&lPopFrame2);
__ Addq(8, rsp); // 8: align byte
}
@ -1023,7 +985,7 @@ void OptimizedCall::JSProxyCallInternal(ExtendedAssembler *assembler, Register j
{
__ Movq(jsFuncReg, rdx); // calltarget
__ Movq(rsp, rcx);
__ Addq(DOUBLE_SLOT_SIZE, rcx); // sp + 16 skip returnAddr
__ Addq(FRAME_SLOT_SIZE, rcx); // sp + 8 skip returnAddr
__ Mov(Operand(rcx, 0), rsi); // get origin argc
__ Addq(FRAME_SLOT_SIZE, rcx); // 8: sp + 8 argv
__ Movq(kungfu::CommonStubCSigns::JsProxyCallInternal, r9);
@ -1196,8 +1158,11 @@ void OptimizedCall::PushArgsWithArgV(ExtendedAssembler *assembler, Register jsfu
void OptimizedCall::PopJSFunctionArgs(ExtendedAssembler *assembler, Register expectedNumArgs)
{
__ Addq(1, expectedNumArgs);
__ Andq(~1, expectedNumArgs);
Label align16Bytes;
__ Testb(1, expectedNumArgs);
__ Jne(&align16Bytes);
__ Addq(FRAME_SLOT_SIZE, rsp);
__ Bind(&align16Bytes);
__ Leaq(Operand(expectedNumArgs, Scale::Times8, 0), expectedNumArgs);
__ Addq(expectedNumArgs, rsp);
__ Addq(FRAME_SLOT_SIZE, rsp); // 8: skip expectedNumArgs
@ -1293,8 +1258,6 @@ void OptimizedCall::PopOptimizedUnfoldArgVFrame(ExtendedAssembler *assembler)
// | call-target |
// |--------------------------|
// | argc |
// |--------------------------|
// | lexEnv |
// sp ----> |--------------------------| ---------------
// | returnAddr | ^
// |--------------------------| |
@ -1322,7 +1285,7 @@ void OptimizedCall::GenJSCallWithArgV(ExtendedAssembler *assembler, bool isNew)
__ Addq(Immediate(FRAME_SLOT_SIZE), callsiteSp); // 8 : 8 means skip pc to get last callsitesp
PushOptimizedUnfoldArgVFrame(assembler, callsiteSp);
__ Testb(1, actualNumArgs);
__ Jne(&align16Bytes);
__ Je(&align16Bytes);
__ PushAlignBytes();
__ Bind(&align16Bytes);
__ Cmp(Immediate(0), actualNumArgs);
@ -1333,15 +1296,12 @@ void OptimizedCall::GenJSCallWithArgV(ExtendedAssembler *assembler, bool isNew)
PushMandatoryJSArgs(assembler, jsfunc, thisObj, newTarget);
__ Addq(Immediate(NUM_MANDATORY_JSFUNC_ARGS), actualNumArgs);
__ Pushq(actualNumArgs);
__ Movq(Operand(jsfunc, JSFunction::LEXICAL_ENV_OFFSET), rax);
__ Pushq(rax);
__ Movq(glue, rax);
if (isNew) {
__ CallAssemblerStub(RTSTUB_ID(JSCallNew), false);
} else {
__ CallAssemblerStub(RTSTUB_ID(JSCall), false);
}
__ Addq(FRAME_SLOT_SIZE, rsp);
__ Mov(Operand(sp, 0), actualNumArgs);
PopJSFunctionArgs(assembler, actualNumArgs);
PopOptimizedUnfoldArgVFrame(assembler);
@ -1378,7 +1338,7 @@ void OptimizedCall::ConstructorJSCallWithArgV(ExtendedAssembler *assembler)
__ Addq(Immediate(FRAME_SLOT_SIZE), callsiteSp); // 8 : 8 means skip pc to get last callsitesp
PushOptimizedUnfoldArgVFrame(assembler, callsiteSp);
__ Testb(1, actualNumArgs);
__ Jne(&align16Bytes);
__ Je(&align16Bytes);
__ PushAlignBytes();
__ Bind(&align16Bytes);
__ Cmp(Immediate(0), actualNumArgs);
@ -1389,11 +1349,8 @@ void OptimizedCall::ConstructorJSCallWithArgV(ExtendedAssembler *assembler)
PushMandatoryJSArgs(assembler, jsfunc, thisObj, newTarget);
__ Addq(Immediate(NUM_MANDATORY_JSFUNC_ARGS), actualNumArgs);
__ Pushq(actualNumArgs);
__ Movq(Operand(jsfunc, JSFunction::LEXICAL_ENV_OFFSET), rax);
__ Pushq(rax);
__ Movq(glue, rax);
__ CallAssemblerStub(RTSTUB_ID(ConstructorJSCall), false);
__ Addq(FRAME_SLOT_SIZE, rsp);
__ Mov(Operand(sp, 0), actualNumArgs);
PopJSFunctionArgs(assembler, actualNumArgs);
PopOptimizedUnfoldArgVFrame(assembler);

52
ecmascript/compiler/ts_type_lowering.cpp
View File

@ -900,9 +900,8 @@ void TSTypeLowering::LowerTypedNewObjRange(GateRef gate)
// call constructor
size_t range = acc_.GetNumValueIn(gate);
GateRef envArg = builder_.Undefined();
GateRef actualArgc = builder_.Int64(range + 2); // 2:newTaget, this
std::vector<GateRef> args { glue_, envArg, actualArgc, ctor, ctor, thisObj };
GateRef actualArgc = builder_.Int64(BytecodeCallArgc::ComputeCallArgc(range, EcmaOpcode::NEWOBJRANGE_IMM8_IMM8_V8));
std::vector<GateRef> args { glue_, actualArgc, ctor, ctor, thisObj };
for (size_t i = 1; i < range; ++i) { // 1:skip ctor
args.emplace_back(acc_.GetValueIn(gate, i));
}
@ -933,9 +932,8 @@ void TSTypeLowering::LowerTypedSuperCall(GateRef gate)
// call constructor
size_t range = acc_.GetNumValueIn(gate);
GateRef envArg = builder_.Undefined();
GateRef actualArgc = builder_.Int64(range + 3); // 3: ctor, newTaget, this
std::vector<GateRef> args { glue_, envArg, actualArgc, superCtor, newTarget, thisObj };
std::vector<GateRef> args { glue_, actualArgc, superCtor, newTarget, thisObj };
for (size_t i = 0; i < range; ++i) {
args.emplace_back(acc_.GetValueIn(gate, i));
}
@ -991,8 +989,7 @@ void TSTypeLowering::LowerTypedCallArg0(GateRef gate)
GateRef thisObj = builder_.Undefined();
if (IsLoadVtable(func)) {
builder_.JSCallThisTargetTypeCheck(funcType, func);
GateRef env = builder_.GetFunctionLexicalEnv(func);
std::vector<GateRef> args { glue_, env, actualArgc, func, newTarget, thisObj };
std::vector<GateRef> args { glue_, actualArgc, func, newTarget, thisObj };
GateRef result = builder_.TypedAotCall(gate, args);
acc_.ReplaceGate(gate, builder_.GetState(), builder_.GetDepend(), result);
@ -1003,8 +1000,7 @@ void TSTypeLowering::LowerTypedCallArg0(GateRef gate)
return;
}
builder_.JSCallTargetTypeCheck(funcType, func, builder_.IntPtr(methodIndex));
GateRef env = builder_.GetFunctionLexicalEnv(func);
std::vector<GateRef> args { glue_, env, actualArgc, func, newTarget, thisObj };
std::vector<GateRef> args { glue_, actualArgc, func, newTarget, thisObj };
GateRef result = builder_.TypedAotCall(gate, args);
acc_.ReplaceGate(gate, builder_.GetState(), builder_.GetDepend(), result);
@ -1032,8 +1028,7 @@ void TSTypeLowering::LowerTypedCallArg1(GateRef gate)
GateRef a0Value = acc_.GetValueIn(gate, 0);
if (IsLoadVtable(func)) {
builder_.JSCallThisTargetTypeCheck(funcType, func);
GateRef env = builder_.GetFunctionLexicalEnv(func);
std::vector<GateRef> args { glue_, env, actualArgc, func, newTarget, thisObj, a0Value };
std::vector<GateRef> args { glue_, actualArgc, func, newTarget, thisObj, a0Value };
GateRef result = builder_.TypedAotCall(gate, args);
acc_.ReplaceGate(gate, builder_.GetState(), builder_.GetDepend(), result);
} else {
@ -1043,8 +1038,7 @@ void TSTypeLowering::LowerTypedCallArg1(GateRef gate)
return;
}
builder_.JSCallTargetTypeCheck(funcType, func, builder_.IntPtr(methodIndex));
GateRef env = builder_.GetFunctionLexicalEnv(func);
std::vector<GateRef> args { glue_, env, actualArgc, func, newTarget, thisObj, a0Value };
std::vector<GateRef> args { glue_, actualArgc, func, newTarget, thisObj, a0Value };
GateRef result = builder_.TypedAotCall(gate, args);
acc_.ReplaceGate(gate, builder_.GetState(), builder_.GetDepend(), result);
}
@ -1072,8 +1066,7 @@ void TSTypeLowering::LowerTypedCallArg2(GateRef gate)
GateRef a1 = acc_.GetValueIn(gate, 1); // 1:first parameter
if (IsLoadVtable(func)) {
builder_.JSCallThisTargetTypeCheck(funcType, func);
GateRef env = builder_.GetFunctionLexicalEnv(func);
std::vector<GateRef> args { glue_, env, actualArgc, func, newTarget, thisObj, a0, a1 };
std::vector<GateRef> args { glue_, actualArgc, func, newTarget, thisObj, a0, a1 };
GateRef result = builder_.TypedAotCall(gate, args);
acc_.ReplaceGate(gate, builder_.GetState(), builder_.GetDepend(), result);
} else {
@ -1083,8 +1076,7 @@ void TSTypeLowering::LowerTypedCallArg2(GateRef gate)
return;
}
builder_.JSCallTargetTypeCheck(funcType, func, builder_.IntPtr(methodIndex));
GateRef env = builder_.GetFunctionLexicalEnv(func);
std::vector<GateRef> args { glue_, env, actualArgc, func, newTarget, thisObj, a0, a1 };
std::vector<GateRef> args { glue_, actualArgc, func, newTarget, thisObj, a0, a1 };
GateRef result = builder_.TypedAotCall(gate, args);
acc_.ReplaceGate(gate, builder_.GetState(), builder_.GetDepend(), result);
}
@ -1113,8 +1105,7 @@ void TSTypeLowering::LowerTypedCallArg3(GateRef gate)
GateRef a2 = acc_.GetValueIn(gate, 2);
if (IsLoadVtable(func)) {
builder_.JSCallThisTargetTypeCheck(funcType, func);
GateRef env = builder_.GetFunctionLexicalEnv(func);
std::vector<GateRef> args { glue_, env, actualArgc, func, newTarget, thisObj, a0, a1, a2 };
std::vector<GateRef> args { glue_, actualArgc, func, newTarget, thisObj, a0, a1, a2 };
GateRef result = builder_.TypedAotCall(gate, args);
acc_.ReplaceGate(gate, builder_.GetState(), builder_.GetDepend(), result);
} else {
@ -1124,8 +1115,7 @@ void TSTypeLowering::LowerTypedCallArg3(GateRef gate)
return;
}
builder_.JSCallTargetTypeCheck(funcType, func, builder_.IntPtr(methodIndex));
GateRef env = builder_.GetFunctionLexicalEnv(func);
std::vector<GateRef> args { glue_, env, actualArgc, func, newTarget, thisObj, a0, a1, a2 };
std::vector<GateRef> args { glue_, actualArgc, func, newTarget, thisObj, a0, a1, a2 };
GateRef result = builder_.TypedAotCall(gate, args);
acc_.ReplaceGate(gate, builder_.GetState(), builder_.GetDepend(), result);
}
@ -1163,9 +1153,6 @@ void TSTypeLowering::LowerTypedCallrange(GateRef gate)
}
if (IsLoadVtable(func)) {
builder_.JSCallThisTargetTypeCheck(funcType, func);
GateRef newEnv = builder_.GetFunctionLexicalEnv(func);
std::vector<GateRef>::iterator pos = vec.begin();
vec.insert(++pos, newEnv);
GateRef result = builder_.TypedAotCall(gate, vec);
acc_.ReplaceGate(gate, builder_.GetState(), builder_.GetDepend(), result);
} else {
@ -1175,9 +1162,6 @@ void TSTypeLowering::LowerTypedCallrange(GateRef gate)
return;
}
builder_.JSCallTargetTypeCheck(funcType, func, builder_.IntPtr(methodIndex));
GateRef newEnv = builder_.GetFunctionLexicalEnv(func);
std::vector<GateRef>::iterator pos = vec.begin();
vec.insert(++pos, newEnv);
GateRef result = builder_.TypedAotCall(gate, vec);
acc_.ReplaceGate(gate, builder_.GetState(), builder_.GetDepend(), result);
}
@ -1225,8 +1209,7 @@ void TSTypeLowering::LowerTypedCallthis0(GateRef gate)
EcmaOpcode::CALLTHIS0_IMM8_V8));
GateRef newTarget = builder_.Undefined();
GateRef thisObj = acc_.GetValueIn(gate, 0);
GateRef env = builder_.GetFunctionLexicalEnv(func);
std::vector<GateRef> args { glue_, env, actualArgc, func, newTarget, thisObj };
std::vector<GateRef> args { glue_, actualArgc, func, newTarget, thisObj };
GateRef result = builder_.TypedAotCall(gate, args);
acc_.ReplaceGate(gate, builder_.GetState(), builder_.GetDepend(), result);
@ -1255,8 +1238,7 @@ void TSTypeLowering::LowerTypedCallthis1(GateRef gate)
GateRef actualArgc = builder_.Int64(BytecodeCallArgc::ComputeCallArgc(acc_.GetNumValueIn(gate),
EcmaOpcode::CALLTHIS1_IMM8_V8_V8));
GateRef newTarget = builder_.Undefined();
GateRef env = builder_.GetFunctionLexicalEnv(func);
std::vector<GateRef> args { glue_, env, actualArgc, func, newTarget, thisObj, a0 };
std::vector<GateRef> args { glue_, actualArgc, func, newTarget, thisObj, a0 };
GateRef result = builder_.TypedAotCall(gate, args);
acc_.ReplaceGate(gate, builder_.GetState(), builder_.GetDepend(), result);
@ -1280,8 +1262,7 @@ void TSTypeLowering::LowerTypedCallthis2(GateRef gate)
GateRef thisObj = acc_.GetValueIn(gate, 0);
GateRef a0Value = acc_.GetValueIn(gate, 1);
GateRef a1Value = acc_.GetValueIn(gate, 2);
GateRef env = builder_.GetFunctionLexicalEnv(func);
std::vector<GateRef> args { glue_, env, actualArgc, func, newTarget, thisObj, a0Value, a1Value };
std::vector<GateRef> args { glue_, actualArgc, func, newTarget, thisObj, a0Value, a1Value };
GateRef result = builder_.TypedAotCall(gate, args);
acc_.ReplaceGate(gate, builder_.GetState(), builder_.GetDepend(), result);
@ -1305,8 +1286,7 @@ void TSTypeLowering::LowerTypedCallthis3(GateRef gate)
GateRef a0Value = acc_.GetValueIn(gate, 1);
GateRef a1Value = acc_.GetValueIn(gate, 2);
GateRef a2Value = acc_.GetValueIn(gate, 3);
GateRef env = builder_.GetFunctionLexicalEnv(func);
std::vector<GateRef> args { glue_, env, actualArgc, func, newTarget, thisObj, a0Value, a1Value, a2Value };
std::vector<GateRef> args { glue_, actualArgc, func, newTarget, thisObj, a0Value, a1Value, a2Value };
GateRef result = builder_.TypedAotCall(gate, args);
acc_.ReplaceGate(gate, builder_.GetState(), builder_.GetDepend(), result);
@ -1331,9 +1311,7 @@ void TSTypeLowering::LowerTypedCallthisrange(GateRef gate)
builder_.JSCallThisTargetTypeCheck(funcType, func);
GateRef thisObj = acc_.GetValueIn(gate, 0);
GateRef newTarget = builder_.Undefined();
GateRef env = builder_.GetFunctionLexicalEnv(func);
vec.emplace_back(glue_);
vec.emplace_back(env);
vec.emplace_back(actualArgc);
vec.emplace_back(func);
vec.emplace_back(newTarget);

3
ecmascript/compiler/type_lowering.cpp
View File

@ -3143,10 +3143,9 @@ GateRef TypeLowering::CallAccessor(GateRef glue, GateRef gate, GateRef function,
{
const CallSignature *cs = RuntimeStubCSigns::Get(RTSTUB_ID(JSCall));
GateRef target = builder_.IntPtr(RTSTUB_ID(JSCall));
GateRef envArg = builder_.Undefined();
GateRef newTarget = builder_.Undefined();
GateRef argc = builder_.Int64(NUM_MANDATORY_JSFUNC_ARGS + (mode == AccessorMode::SETTER ? 1 : 0)); // 1: value
std::vector<GateRef> args { glue, envArg, argc, function, newTarget, receiver };
std::vector<GateRef> args { glue, argc, function, newTarget, receiver };
if (mode == AccessorMode::SETTER) {
args.emplace_back(value);
}

2
ecmascript/frames.cpp
View File

@ -502,8 +502,6 @@ ARK_INLINE void OptimizedJSFunctionFrame::GCIterate(const FrameIterator &it,
visitor(Root::ROOT_FRAME, ObjectSlot(jsFuncSlot));
uintptr_t *preFrameSp = frame->ComputePrevFrameSp(it);
uintptr_t envSlot = ToUintPtr(preFrameSp);
visitor(Root::ROOT_FRAME, ObjectSlot(envSlot));
auto argc = frame->GetArgc(preFrameSp);
JSTaggedType *argv = frame->GetArgv(reinterpret_cast<uintptr_t *>(preFrameSp));

11
ecmascript/frames.h
View File

@ -422,8 +422,6 @@ STATIC_ASSERT_EQ_ARCH(sizeof(OptimizedJSFunctionArgConfigFrame),
// | call-target |
// |--------------------------|
// | argc |
// |--------------------------|
// | lexEnv |
// sp ----> |--------------------------| ---------------
// | returnAddr | ^
// |--------------------------| |
@ -441,7 +439,6 @@ struct OptimizedJSFunctionFrame : public base::AlignedStruct<JSTaggedValue::Tagg
base::AlignedPointer,
base::AlignedPointer> {
public:
static constexpr size_t ENV_SLOT_DIFF = 2;
enum class Index : size_t {
JSFuncIndex = 0,
TypeIndex,
@ -463,12 +460,12 @@ public:
JSTaggedType* GetArgv(uintptr_t *preFrameSp) const
{
return reinterpret_cast<JSTaggedType *>(preFrameSp + ENV_SLOT_DIFF * sizeof(uint64_t) / sizeof(uintptr_t));
return reinterpret_cast<JSTaggedType *>(preFrameSp + sizeof(uint64_t) / sizeof(uintptr_t));
}
size_t GetArgc(uintptr_t *preFrameSp) const
{
return *(preFrameSp + sizeof(uint64_t) / sizeof(uintptr_t));
return *preFrameSp;
}
JSTaggedType* GetArgv(const FrameIterator &it) const;
@ -1191,7 +1188,7 @@ struct OptimizedWithArgvLeaveFrame {
// +--------------------------+-------------
// | argc | ^
// |--------------------------| |
// | env | |
// | thread | |
// +--------------------------+ |
// | ret-addr | |
// sp --> |--------------------------| OptimizedBuiltinLeaveFrame
@ -1212,7 +1209,7 @@ public:
}
uintptr_t GetCallSiteSp() const
{
return ToUintPtr(this) + MEMBER_OFFSET(OptimizedBuiltinLeaveFrame, thread);
return ToUintPtr(this) + MEMBER_OFFSET(OptimizedBuiltinLeaveFrame, argc);
}
inline JSTaggedType* GetPrevFrameFp() const
{