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

!1844 refactor compiler Stub

Browse Source 
Merge pull request !1844 from 孙哲/master
This commit is contained in:
openharmony_ci 2022-07-21 04:28:46 +00:00 committed by Gitee
commit a8a90aafd2
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
11 changed files with 179 additions and 655 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ecmascript/compiler/bc_call_signature.cpp
View File

@ -31,7 +31,8 @@ void BytecodeStubCSigns::Initialize()
callSigns_[name].SetConstructor( \
[](void* ciruit) { \
return static_cast<void*>( \
new name##Stub(static_cast<Circuit*>(ciruit))); \
new name##Stub(&callSigns_[name], \
static_cast<Circuit*>(ciruit))); \
});
INTERPRETER_BC_STUB_LIST(INIT_SIGNATURES)
#undef INIT_SIGNATURES
@ -44,7 +45,7 @@ void BytecodeStubCSigns::Initialize()
callSigns_[name].SetConstructor( \
[](void* ciruit) { \
return static_cast<void*>( \
new name##Stub(static_cast<Circuit*>(ciruit))); \
new name##Stub(&callSigns_[name], static_cast<Circuit*>(ciruit))); \
});
ASM_INTERPRETER_BC_HELPER_STUB_LIST(INIT_HELPER_SIGNATURES)
#undef INIT_HELPER_SIGNATURES

12
ecmascript/compiler/call_signature.h
View File

@ -63,7 +63,7 @@ public:
using TailCallBit = VariadicArgsBit::NextField<bool, 1>;
using GCLeafFunctionBit = TailCallBit::NextField<bool, 1>;
explicit CallSignature(std::string name, int flags, int paramCounter, ArgumentsOrder order, VariableType returnType)
explicit CallSignature(std::string name, int flags, size_t paramCounter, ArgumentsOrder order, VariableType returnType)
: name_(name), paramCounter_(paramCounter), order_(order), returnType_(returnType)
{
SetTargetKind(TargetKind::COMMON_STUB);
@ -87,7 +87,7 @@ public:
constructor_ = other.constructor_;
if (paramCounter_ > 0 && other.paramsType_ != nullptr) {
paramsType_ = std::make_unique<std::vector<VariableType>>(paramCounter_);
for (int i = 0; i < paramCounter_; i++) {
for (size_t i = 0; i < paramCounter_; i++) {
(*paramsType_)[i] = other.GetParametersType()[i];
}
}
@ -104,7 +104,7 @@ public:
constructor_ = other.constructor_;
if (paramCounter_ > 0 && other.paramsType_ != nullptr) {
paramsType_ = std::make_unique<std::vector<VariableType>>(paramCounter_);
for (int i = 0; i < paramCounter_; i++) {
for (size_t i = 0; i < paramCounter_; i++) {
(*paramsType_)[i] = other.GetParametersType()[i];
}
}
@ -158,7 +158,7 @@ public:
{
if (paramCounter_ > 0 && paramsType_ == nullptr) {
paramsType_ = std::make_unique<std::vector<VariableType>>(paramCounter_);
for (int i = 0; i < paramCounter_; i++) {
for (size_t i = 0; i < paramCounter_; i++) {
(*paramsType_)[i] = paramsType[i];
}
}
@ -173,7 +173,7 @@ public:
}
}
int GetParametersCount() const
size_t GetParametersCount() const
{
return paramCounter_;
}
@ -275,7 +275,7 @@ public:
private:
std::string name_;
int paramCounter_ {0};
size_t paramCounter_ {0};
int id_ {-1};
ArgumentsOrder order_ {ArgumentsOrder::DEFAULT_ORDER};
VariableType returnType_ {VariableType::VOID()};

84
ecmascript/compiler/common_stubs.cpp
View File

@ -26,81 +26,6 @@
namespace panda::ecmascript::kungfu {
using namespace panda::ecmascript;
#ifndef NDEBUG
void MulGCTestStub::GenerateCircuit(const CompilationConfig *cfg)
{
Stub::GenerateCircuit(cfg);
auto env = GetEnvironment();
GateRef glue = PtrArgument(0);
GateRef x = Int64Argument(1);
GateRef y = Int64Argument(2); // 2: 3rd argument
DEFVARIABLE(intX, VariableType::INT64(), Int64(0));
DEFVARIABLE(intY, VariableType::INT64(), Int64(0));
DEFVARIABLE(valuePtr, VariableType::INT64(), Int64(0));
DEFVARIABLE(doubleX, VariableType::FLOAT64(), Double(0));
DEFVARIABLE(doubleY, VariableType::FLOAT64(), Double(0));
Label xIsNumber(env);
Label xNotNumberOryNotNumber(env);
Label xIsNumberAndyIsNumber(env);
Label xIsDoubleAndyIsDouble(env);
Branch(TaggedIsNumber(x), &xIsNumber, &xNotNumberOryNotNumber);
Bind(&xIsNumber);
{
Label yIsNumber(env);
// if right.IsNumber()
Branch(TaggedIsNumber(y), &yIsNumber, &xNotNumberOryNotNumber);
Bind(&yIsNumber);
{
Label xIsInt(env);
Label xNotInt(env);
Branch(TaggedIsInt(x), &xIsInt, &xNotInt);
Bind(&xIsInt);
{
intX = TaggedCastToInt64(x);
doubleX = CastInt64ToFloat64(*intX);
Jump(&xIsNumberAndyIsNumber);
}
Bind(&xNotInt);
{
doubleX = TaggedCastToDouble(x);
Jump(&xIsNumberAndyIsNumber);
}
}
}
Bind(&xNotNumberOryNotNumber);
Return(Hole(VariableType::JS_ANY()));
Label yIsInt(env);
Label yNotInt(env);
Bind(&xIsNumberAndyIsNumber);
{
Branch(TaggedIsInt(y), &yIsInt, &yNotInt);
Bind(&yIsInt);
{
intY = TaggedCastToInt64(y);
doubleY = CastInt64ToFloat64(*intY);
Jump(&xIsDoubleAndyIsDouble);
}
Bind(&yNotInt);
{
doubleY = TaggedCastToDouble(y);
Jump(&xIsDoubleAndyIsDouble);
}
}
Bind(&xIsDoubleAndyIsDouble);
doubleX = DoubleMul(*doubleX, *doubleY);
GateRef ptr1 = CallRuntime(glue, RTSTUB_ID(GetTaggedArrayPtrTest), {Int64(JSTaggedValue::VALUE_UNDEFINED)});
GateRef ptr2 = CallRuntime(glue, RTSTUB_ID(GetTaggedArrayPtrTest), {ptr1});
auto value1 = GetValueFromTaggedArray(VariableType::INT64(), ptr1, Int32(0));
GateRef tmp = CastInt64ToFloat64(value1);
doubleX = DoubleMul(*doubleX, tmp);
auto value2 = GetValueFromTaggedArray(VariableType::INT64(), ptr2, Int32(1));
tmp = CastInt64ToFloat64(value2);
doubleX = DoubleMul(*doubleX, tmp);
Return(DoubleBuildTaggedWithNoGC(*doubleX));
}
#endif
void AddStub::GenerateCircuit(const CompilationConfig *cfg)
{
Stub::GenerateCircuit(cfg);
@ -466,8 +391,10 @@ void JsProxyCallInternalStub::GenerateCircuit(const CompilationConfig *cfg)
}
Bind(&isNotUndefined);
{
const int JSPROXY_NUM_ARGS = 3;
GateRef arrHandle = CallRuntime(glue, RTSTUB_ID(CreateArrayFromList), argc, argv);
GateRef thisArg = Load(VariableType::JS_POINTER(), argv, IntPtr(2*sizeof(JSTaggedValue)));
// 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),
@ -483,12 +410,13 @@ CallSignature CommonStubCSigns::callSigns_[CommonStubCSigns::NUM_OF_STUBS];
void CommonStubCSigns::Initialize()
{
#define INIT_SIGNATURES(name, counter) \
#define INIT_SIGNATURES(name) \
name##CallSignature::Initialize(&callSigns_[name]); \
callSigns_[name].SetID(name); \
callSigns_[name].SetConstructor( \
[](void* ciruit) { \
return static_cast<void*>(new name##Stub(static_cast<Circuit*>(ciruit))); \
return static_cast<void*>( \
new name##Stub(&callSigns_[name], static_cast<Circuit*>(ciruit))); \
});
COMMON_STUB_ID_LIST(INIT_SIGNATURES)

345
ecmascript/compiler/common_stubs.h
View File

@ -20,322 +20,51 @@
#include "ecmascript/compiler/test_stubs.h"
namespace panda::ecmascript::kungfu {
#define COMMON_STUB_LIST(V) \
V(Add, 3) \
V(Sub, 3) \
V(Mul, 3) \
V(Div, 3) \
V(Mod, 3) \
V(Equal, 3) \
V(TypeOf, 2) \
V(GetPropertyByName, 3) \
V(SetPropertyByName, 4) \
V(SetPropertyByNameWithOwn, 4) \
V(GetPropertyByIndex, 3) \
V(SetPropertyByIndex, 4) \
V(SetPropertyByIndexWithOwn, 4) \
V(GetPropertyByValue, 3) \
V(SetPropertyByValue, 4) \
V(SetPropertyByValueWithOwn, 4) \
V(TryLoadICByName, 4) \
V(TryLoadICByValue, 5) \
V(TryStoreICByName, 5) \
V(TryStoreICByValue, 6) \
V(SetValueWithBarrier, 4) \
V(JsProxyCallInternal, 4)
#define COMMON_STUB_LIST(V) \
V(Add) \
V(Sub) \
V(Mul) \
V(Div) \
V(Mod) \
V(Equal) \
V(TypeOf) \
V(GetPropertyByName) \
V(SetPropertyByName) \
V(SetPropertyByNameWithOwn) \
V(GetPropertyByIndex) \
V(SetPropertyByIndex) \
V(SetPropertyByIndexWithOwn) \
V(GetPropertyByValue) \
V(SetPropertyByValue) \
V(SetPropertyByValueWithOwn) \
V(TryLoadICByName) \
V(TryLoadICByValue) \
V(TryStoreICByName) \
V(TryStoreICByValue) \
V(SetValueWithBarrier) \
V(JsProxyCallInternal)
#define COMMON_STUB_ID_LIST(V) \
COMMON_STUB_LIST(V) \
TEST_STUB_LIST(V)
TEST_STUB_SIGNATRUE_LIST(V)
class MulGCTestStub : public Stub {
public:
// 3 : 3 means argument counts
explicit MulGCTestStub(Circuit *circuit) : Stub("MulGCTest", 3, circuit) {}
~MulGCTestStub() = default;
NO_MOVE_SEMANTIC(MulGCTestStub);
NO_COPY_SEMANTIC(MulGCTestStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class AddStub : public Stub {
public:
// 3 : 3 means argument counts
explicit AddStub(Circuit *circuit) : Stub("Add", 3, circuit)
{
circuit->SetFrameType(panda::ecmascript::FrameType::OPTIMIZED_FRAME);
}
~AddStub() = default;
NO_MOVE_SEMANTIC(AddStub);
NO_COPY_SEMANTIC(AddStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class SubStub : public Stub {
public:
// 3 : 3 means argument counts
explicit SubStub(Circuit *circuit) : Stub("Sub", 3, circuit) {}
~SubStub() = default;
NO_MOVE_SEMANTIC(SubStub);
NO_COPY_SEMANTIC(SubStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class MulStub : public Stub {
public:
// 3 : 3 means argument counts
explicit MulStub(Circuit *circuit) : Stub("Mul", 3, circuit) {}
~MulStub() = default;
NO_MOVE_SEMANTIC(MulStub);
NO_COPY_SEMANTIC(MulStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class DivStub : public Stub {
public:
// 3 : 3 means argument counts
explicit DivStub(Circuit *circuit) : Stub("Div", 3, circuit) {}
~DivStub() = default;
NO_MOVE_SEMANTIC(DivStub);
NO_COPY_SEMANTIC(DivStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class GetPropertyByIndexStub : public Stub {
public:
// 3 : 3 means argument counts
explicit GetPropertyByIndexStub(Circuit *circuit) : Stub("GetPropertyByIndex", 3, circuit)
{
circuit->SetFrameType(panda::ecmascript::FrameType::OPTIMIZED_FRAME);
}
~GetPropertyByIndexStub() = default;
NO_MOVE_SEMANTIC(GetPropertyByIndexStub);
NO_COPY_SEMANTIC(GetPropertyByIndexStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class SetPropertyByIndexStub : public Stub {
public:
// 4 : 4 means argument counts
explicit SetPropertyByIndexStub(Circuit *circuit) : Stub("SetPropertyByIndex", 4, circuit)
{
circuit->SetFrameType(panda::ecmascript::FrameType::OPTIMIZED_FRAME);
}
~SetPropertyByIndexStub() = default;
NO_MOVE_SEMANTIC(SetPropertyByIndexStub);
NO_COPY_SEMANTIC(SetPropertyByIndexStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class SetPropertyByIndexWithOwnStub : public Stub {
public:
// 4 : 4 means argument counts
explicit SetPropertyByIndexWithOwnStub(Circuit *circuit) : Stub("SetPropertyByIndexWithOwn", 4, circuit)
{
circuit->SetFrameType(panda::ecmascript::FrameType::OPTIMIZED_FRAME);
}
~SetPropertyByIndexWithOwnStub() = default;
NO_MOVE_SEMANTIC(SetPropertyByIndexWithOwnStub);
NO_COPY_SEMANTIC(SetPropertyByIndexWithOwnStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class GetPropertyByNameStub : public Stub {
public:
// 3 : 3 means argument counts
explicit GetPropertyByNameStub(Circuit *circuit) : Stub("GetPropertyByName", 3, circuit)
{
circuit->SetFrameType(panda::ecmascript::FrameType::OPTIMIZED_FRAME);
}
~GetPropertyByNameStub() = default;
NO_MOVE_SEMANTIC(GetPropertyByNameStub);
NO_COPY_SEMANTIC(GetPropertyByNameStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class SetPropertyByNameStub : public Stub {
public:
// 4 : 4 means argument counts
explicit SetPropertyByNameStub(Circuit *circuit) : Stub("SetPropertyByName", 4, circuit)
{
circuit->SetFrameType(panda::ecmascript::FrameType::OPTIMIZED_FRAME);
}
~SetPropertyByNameStub() = default;
NO_MOVE_SEMANTIC(SetPropertyByNameStub);
NO_COPY_SEMANTIC(SetPropertyByNameStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class SetPropertyByNameWithOwnStub : public Stub {
public:
// 4 : 4 means argument counts
explicit SetPropertyByNameWithOwnStub(Circuit *circuit) : Stub("SetPropertyByNameWithOwn", 4, circuit)
{
circuit->SetFrameType(panda::ecmascript::FrameType::OPTIMIZED_FRAME);
}
~SetPropertyByNameWithOwnStub() = default;
NO_MOVE_SEMANTIC(SetPropertyByNameWithOwnStub);
NO_COPY_SEMANTIC(SetPropertyByNameWithOwnStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class ModStub : public Stub {
public:
// 3 means argument counts
explicit ModStub(Circuit *circuit) : Stub("Mod", 3, circuit)
{
circuit->SetFrameType(panda::ecmascript::FrameType::OPTIMIZED_FRAME);
}
~ModStub() = default;
NO_MOVE_SEMANTIC(ModStub);
NO_COPY_SEMANTIC(ModStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class TypeOfStub : public Stub {
public:
// 2 means argument counts
explicit TypeOfStub(Circuit *circuit) : Stub("TypeOf", 2, circuit) {}
~TypeOfStub() = default;
NO_MOVE_SEMANTIC(TypeOfStub);
NO_COPY_SEMANTIC(TypeOfStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class FunctionCallInternalStub : public Stub {
public:
// 5 : 5 means argument counts
explicit FunctionCallInternalStub(Circuit *circuit) : Stub("FunctionCallInternal", 5, circuit) {}
~FunctionCallInternalStub() = default;
NO_MOVE_SEMANTIC(FunctionCallInternalStub);
NO_COPY_SEMANTIC(FunctionCallInternalStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class GetPropertyByValueStub : public Stub {
public:
// 3 : 3 means argument counts
explicit GetPropertyByValueStub(Circuit *circuit) : Stub("GetPropertyByValue", 3, circuit)
{
circuit->SetFrameType(panda::ecmascript::FrameType::OPTIMIZED_FRAME);
}
~GetPropertyByValueStub() = default;
NO_MOVE_SEMANTIC(GetPropertyByValueStub);
NO_COPY_SEMANTIC(GetPropertyByValueStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class SetPropertyByValueStub : public Stub {
public:
// 4 : 4 means argument counts
explicit SetPropertyByValueStub(Circuit *circuit) : Stub("SetPropertyByValue", 4, circuit)
{
circuit->SetFrameType(panda::ecmascript::FrameType::OPTIMIZED_FRAME);
}
~SetPropertyByValueStub() = default;
NO_MOVE_SEMANTIC(SetPropertyByValueStub);
NO_COPY_SEMANTIC(SetPropertyByValueStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class SetPropertyByValueWithOwnStub : public Stub {
public:
// 4 : 4 means argument counts
explicit SetPropertyByValueWithOwnStub(Circuit *circuit) : Stub("SetPropertyByValueWithOwn", 4, circuit)
{
circuit->SetFrameType(panda::ecmascript::FrameType::OPTIMIZED_FRAME);
}
~SetPropertyByValueWithOwnStub() = default;
NO_MOVE_SEMANTIC(SetPropertyByValueWithOwnStub);
NO_COPY_SEMANTIC(SetPropertyByValueWithOwnStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class EqualStub : public Stub {
public:
// 3 means argument counts
explicit EqualStub(Circuit *circuit) : Stub("FastEqual", 3, circuit) {}
~EqualStub() = default;
NO_MOVE_SEMANTIC(EqualStub);
NO_COPY_SEMANTIC(EqualStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class TryLoadICByNameStub : public Stub {
public:
// 4 : 4 means argument counts
explicit TryLoadICByNameStub(Circuit *circuit) : Stub("TryLoadICByName", 4, circuit) {}
~TryLoadICByNameStub() = default;
NO_MOVE_SEMANTIC(TryLoadICByNameStub);
NO_COPY_SEMANTIC(TryLoadICByNameStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class TryLoadICByValueStub : public Stub {
public:
// 5 : 5 means argument counts
explicit TryLoadICByValueStub(Circuit *circuit) : Stub("TryLoadICByValue", 5, circuit) {}
~TryLoadICByValueStub() = default;
NO_MOVE_SEMANTIC(TryLoadICByValueStub);
NO_COPY_SEMANTIC(TryLoadICByValueStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class TryStoreICByNameStub : public Stub {
public:
// 5 : 5 means argument counts
explicit TryStoreICByNameStub(Circuit *circuit) : Stub("TryStoreICByName", 5, circuit)
{
circuit->SetFrameType(panda::ecmascript::FrameType::OPTIMIZED_FRAME);
}
~TryStoreICByNameStub() = default;
NO_MOVE_SEMANTIC(TryStoreICByNameStub);
NO_COPY_SEMANTIC(TryStoreICByNameStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class TryStoreICByValueStub : public Stub {
public:
// 6 : 6 means argument counts
explicit TryStoreICByValueStub(Circuit *circuit) : Stub("TryStoreICByValue", 6, circuit)
{
circuit->SetFrameType(panda::ecmascript::FrameType::OPTIMIZED_FRAME);
}
~TryStoreICByValueStub() = default;
NO_MOVE_SEMANTIC(TryStoreICByValueStub);
NO_COPY_SEMANTIC(TryStoreICByValueStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class SetValueWithBarrierStub : public Stub {
public:
// 4 : 4 means argument counts
explicit SetValueWithBarrierStub(Circuit *circuit) : Stub("SetValueWithBarrier", 4, circuit)
{
circuit->SetFrameType(panda::ecmascript::FrameType::OPTIMIZED_FRAME);
}
~SetValueWithBarrierStub() = default;
NO_MOVE_SEMANTIC(SetValueWithBarrierStub);
NO_COPY_SEMANTIC(SetValueWithBarrierStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class JsProxyCallInternalStub : public Stub {
public:
// 4 : 4 means argument counts
explicit JsProxyCallInternalStub(Circuit *circuit) : Stub("JsProxyCallInternal", 4, circuit) {}
~JsProxyCallInternalStub() = default;
NO_MOVE_SEMANTIC(JsProxyCallInternalStub);
NO_COPY_SEMANTIC(JsProxyCallInternalStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
private:
static constexpr int JSPROXY_NUM_ARGS = 3;
};
#define DECLARE_STUB_CLASS(name) \
class name##Stub : public Stub { \
public: \
explicit name##Stub(CallSignature *callSignature, Circuit *circuit) \
: Stub(callSignature, circuit) {} \
~name##Stub() = default; \
NO_MOVE_SEMANTIC(name##Stub); \
NO_COPY_SEMANTIC(name##Stub); \
void GenerateCircuit(const CompilationConfig *cfg) override; \
};
COMMON_STUB_LIST(DECLARE_STUB_CLASS)
#undef DECLARE_STUB_CLASS
class CommonStubCSigns {
public:
enum ID {
#define DEF_STUB_ID(name, counter) name,
#define DEF_STUB_ID(name) name,
COMMON_STUB_ID_LIST(DEF_STUB_ID)
#undef DEF_STUB_ID
NUM_OF_STUBS

8
ecmascript/compiler/interpreter_stub.h
View File

@ -24,8 +24,8 @@
namespace panda::ecmascript::kungfu {
class InterpreterStub : public Stub {
public:
InterpreterStub(const char* name, int argCount, Circuit *circuit)
: Stub(name, argCount, circuit) {}
InterpreterStub(CallSignature *callSignature, Circuit *circuit)
: Stub(callSignature, circuit) {}
~InterpreterStub() = default;
NO_MOVE_SEMANTIC(InterpreterStub);
NO_COPY_SEMANTIC(InterpreterStub);
@ -116,8 +116,8 @@ private:
#define DECLARE_HANDLE_STUB_CLASS(name) \
class name##Stub : public InterpreterStub { \
public: \
explicit name##Stub(Circuit *circuit) : InterpreterStub(#name, \
static_cast<int>(InterpreterHandlerInputs::NUM_OF_INPUTS), circuit) \
explicit name##Stub(CallSignature *callSignature, Circuit *circuit) \
: InterpreterStub(callSignature, circuit) \
{ \
circuit->SetFrameType(FrameType::INTERPRETER_FRAME); \
} \

2
ecmascript/compiler/llvm_ir_builder.cpp
View File

@ -1935,7 +1935,7 @@ LLVMTypeRef LLVMModule::GetFuncType(const CallSignature *stubDescriptor)
}
}
for (int i = 1; i < paramCount; i++) {
for (size_t i = 1; i < paramCount; i++) {
paramTys.push_back(ConvertLLVMTypeFromVariableType(paramsType[i]));
}
}

97
ecmascript/compiler/stub-inl.h
View File

@ -130,76 +130,42 @@ inline GateRef Stub::Argument(size_t index)
inline GateRef Stub::Int1Argument(size_t index)
{
GateRef argument = Argument(index);
acc_.SetOpCode(argument, OpCode(OpCode::ARG));
acc_.SetMachineType(argument, MachineType::I1);
return argument;
return Argument(index);
}
inline GateRef Stub::Int32Argument(size_t index)
{
GateRef argument = Argument(index);
acc_.SetOpCode(argument, OpCode(OpCode::ARG));
acc_.SetMachineType(argument, MachineType::I32);
return argument;
return Argument(index);
}
inline GateRef Stub::Int64Argument(size_t index)
{
GateRef argument = Argument(index);
acc_.SetOpCode(argument, OpCode(OpCode::ARG));
acc_.SetMachineType(argument, MachineType::I64);
return argument;
return Argument(index);
}
inline GateRef Stub::TaggedArgument(size_t index)
{
GateRef argument = Argument(index);
acc_.SetOpCode(argument, OpCode(OpCode::ARG));
acc_.SetGateType(argument, GateType::TaggedValue());
acc_.SetMachineType(argument, MachineType::I64);
return argument;
return Argument(index);
}
inline GateRef Stub::TaggedPointerArgument(size_t index, GateType type)
inline GateRef Stub::TaggedPointerArgument(size_t index)
{
GateRef argument = Argument(index);
acc_.SetOpCode(argument, OpCode(OpCode::ARG));
acc_.SetGateType(argument, type);
acc_.SetMachineType(argument, MachineType::I64);
return argument;
return Argument(index);
}
inline GateRef Stub::PtrArgument(size_t index, GateType type)
inline GateRef Stub::PtrArgument(size_t index)
{
GateRef argument = Argument(index);
acc_.SetGateType(argument, type);
if (env_.IsArch64Bit()) {
acc_.SetOpCode(argument, OpCode(OpCode::ARG));
acc_.SetMachineType(argument, MachineType::I64);
} else if (env_.IsArch32Bit()) {
acc_.SetOpCode(argument, OpCode(OpCode::ARG));
acc_.SetMachineType(argument, MachineType::I32);
} else {
UNREACHABLE();
}
return argument;
return Argument(index);
}
inline GateRef Stub::Float32Argument(size_t index)
{
GateRef argument = Argument(index);
acc_.SetOpCode(argument, OpCode(OpCode::ARG));
acc_.SetMachineType(argument, MachineType::F32);
return argument;
return Argument(index);
}
inline GateRef Stub::Float64Argument(size_t index)
{
GateRef argument = Argument(index);
acc_.SetOpCode(argument, OpCode(OpCode::ARG));
acc_.SetMachineType(argument, MachineType::F64);
return argument;
return Argument(index);
}
inline GateRef Stub::Alloca(int size)
@ -254,7 +220,7 @@ inline GateRef Stub::UpdateLeaveFrameAndCallNGCRuntime(GateRef glue, int index,
// CpuProfiler will get the latest leaveFrame_ in thread to up frames.
// So it's necessary to update leaveFrame_ if the program enters the c++ environment.
// We use the latest asm interpreter frame to update it when CallNGCRuntime.
GateRef sp = PtrArgument(static_cast<size_t>(InterpreterHandlerInputs::SP));
GateRef sp = Argument(static_cast<size_t>(InterpreterHandlerInputs::SP));
GateRef spOffset = IntPtr(JSThread::GlueData::GetLeaveFrameOffset(env_.Is32Bit()));
Store(VariableType::NATIVE_POINTER(), glue, glue, spOffset, sp);
}
@ -282,8 +248,8 @@ inline void Stub::FatalPrint(GateRef glue, std::initializer_list<GateRef> args)
void Stub::SavePcIfNeeded(GateRef glue)
{
if (env_.IsAsmInterp()) {
GateRef sp = PtrArgument(static_cast<size_t>(InterpreterHandlerInputs::SP));
GateRef pc = PtrArgument(static_cast<size_t>(InterpreterHandlerInputs::PC));
GateRef sp = Argument(static_cast<size_t>(InterpreterHandlerInputs::SP));
GateRef pc = Argument(static_cast<size_t>(InterpreterHandlerInputs::PC));
GateRef frame = PtrSub(sp,
IntPtr(AsmInterpretedFrame::GetSize(GetEnvironment()->IsArch32Bit())));
Store(VariableType::INT64(), glue, frame,
@ -294,44 +260,15 @@ void Stub::SavePcIfNeeded(GateRef glue)
// memory
inline GateRef Stub::Load(VariableType type, GateRef base, GateRef offset)
{
auto depend = env_.GetCurrentLabel()->GetDepend();
if (env_.IsArch64Bit()) {
GateRef val = Int64Add(base, offset);
if (type == VariableType::NATIVE_POINTER()) {
type = VariableType::INT64();
}
GateRef result = env_.GetCircuit()->NewGate(OpCode(OpCode::LOAD), type.GetMachineType(),
0, { depend, val }, type.GetGateType());
env_.GetCurrentLabel()->SetDepend(result);
return result;
if (type == VariableType::NATIVE_POINTER()) {
type = env_.IsArch64Bit() ? VariableType::INT64() : VariableType::INT32();
}
if (env_.IsArch32Bit()) {
GateRef val = Int32Add(base, offset);
if (type == VariableType::NATIVE_POINTER()) {
type = VariableType::INT32();
}
GateRef result = env_.GetCircuit()->NewGate(OpCode(OpCode::LOAD), type.GetMachineType(),
0, { depend, val }, type.GetGateType());
env_.GetCurrentLabel()->SetDepend(result);
return result;
}
UNREACHABLE();
return builder_.Load(type, base, offset);
}
inline GateRef Stub::Load(VariableType type, GateRef base)
{
if (type == VariableType::NATIVE_POINTER()) {
if (env_.IsArch64Bit()) {
type = VariableType::INT64();
} else {
type = VariableType::INT32();
}
}
auto depend = env_.GetCurrentLabel()->GetDepend();
GateRef result = env_.GetCircuit()->NewGate(OpCode(OpCode::LOAD), type.GetMachineType(),
0, { depend, base }, type.GetGateType());
env_.GetCurrentLabel()->SetDepend(result);
return result;
return Load(type, base, IntPtr(0));
}
// arithmetic

24
ecmascript/compiler/stub.cpp
View File

@ -27,6 +27,28 @@
#include "libpandabase/macros.h"
namespace panda::ecmascript::kungfu {
Stub::Stub(CallSignature *callSignature, Circuit *circuit)
: callSignature_(callSignature), builder_(circuit),
acc_(circuit), env_(callSignature->GetParametersCount(), &builder_)
{
}
void Stub::InitializeArguments()
{
auto argLength = callSignature_->GetParametersCount();
auto paramsType = callSignature_->GetParametersType();
for (size_t i = 0; i < argLength; i++) {
GateRef argument = Argument(i);
if (paramsType[i] == VariableType::NATIVE_POINTER()) {
auto type = env_.IsArch64Bit() ? MachineType::I64 : MachineType::I32;
acc_.SetMachineType(argument, type);
} else {
acc_.SetMachineType(argument, paramsType[i].GetMachineType());
}
acc_.SetGateType(argument, paramsType[i].GetGateType());
}
}
void Stub::Jump(Label *label)
{
ASSERT(label);
@ -4008,7 +4030,7 @@ GateRef Stub::JSCallDispatch(GateRef glue, GateRef func, GateRef actualNumArgs,
}
GateRef sp = 0;
if (env->IsAsmInterp()) {
sp = PtrArgument(static_cast<size_t>(InterpreterHandlerInputs::SP));
sp = Argument(static_cast<size_t>(InterpreterHandlerInputs::SP));
}
Label methodisAot(env);
Label methodNotAot(env);

21
ecmascript/compiler/stub.h
View File

@ -28,16 +28,14 @@ using namespace panda::ecmascript;
class Stub {
public:
explicit Stub(const char *name, int argCount, Circuit *circuit)
: builder_(circuit), acc_(circuit), env_(argCount, &builder_), methodName_(name)
{
}
explicit Stub(CallSignature *callSignature, Circuit *circuit);
virtual ~Stub() = default;
NO_MOVE_SEMANTIC(Stub);
NO_COPY_SEMANTIC(Stub);
virtual void GenerateCircuit(const CompilationConfig *cfg)
{
env_.SetCompilationConfig(cfg);
InitializeArguments();
}
CircuitBuilder* GetBuilder()
{
@ -47,13 +45,17 @@ public:
{
return &env_;
}
CallSignature *GetCallSignature() const
{
return callSignature_;
}
int NextVariableId()
{
return env_.NextVariableId();
}
std::string GetMethodName() const
const std::string &GetMethodName() const
{
return methodName_;
return callSignature_->GetName();
}
// constant
GateRef Int8(int8_t value);
@ -78,8 +80,8 @@ public:
GateRef Int32Argument(size_t index);
GateRef Int64Argument(size_t index);
GateRef TaggedArgument(size_t index);
GateRef TaggedPointerArgument(size_t index, GateType type = GateType::TaggedPointer());
GateRef PtrArgument(size_t index, GateType type = GateType::NJSValue());
GateRef TaggedPointerArgument(size_t index);
GateRef PtrArgument(size_t index);
GateRef Float32Argument(size_t index);
GateRef Float64Argument(size_t index);
GateRef Alloca(int size);
@ -475,10 +477,11 @@ private:
GateRef FastAddSubAndMul(GateRef left, GateRef right);
GateRef FastBinaryOp(GateRef left, GateRef right,
const BinaryOperation& intOp, const BinaryOperation& floatOp);
void InitializeArguments();
CallSignature *callSignature_;
CircuitBuilder builder_;
GateAccessor acc_;
Environment env_;
std::string methodName_;
};
} // namespace panda::ecmascript::kungfu
#endif // ECMASCRIPT_COMPILER_STUB_H

160
ecmascript/compiler/test_stubs.h
View File

@ -17,157 +17,23 @@
#define ECMASCRIPT_COMPILER_TEST_STUBS_H
#include "ecmascript/compiler/stub.h"
#include "test_stubs_signature.h"
namespace panda::ecmascript::kungfu {
#define IGNORE_TEST_STUB(name, count)
#ifndef NDEBUG
#define TEST_STUB_LIST(V) \
V(FooAOT, 7) \
V(Foo1AOT, 7) \
V(Foo2AOT, 7) \
V(FooNativeAOT, 7) \
V(FooBoundAOT, 7) \
V(BarAOT, 7) \
V(Bar1AOT, 8) \
V(FooProxyAOT, 7) \
V(FooProxy2AOT, 7) \
V(Bar2AOT, 7) \
V(TestAbsoluteAddressRelocation, 1)
#else
#define TEST_STUB_LIST(V)
#define DECLARE_STUB_CLASS(name) \
class name##Stub : public Stub { \
public: \
explicit name##Stub(CallSignature *callSignature, Circuit *circuit) \
: Stub(callSignature, circuit) {} \
~name##Stub() = default; \
NO_MOVE_SEMANTIC(name##Stub); \
NO_COPY_SEMANTIC(name##Stub); \
void GenerateCircuit(const CompilationConfig *cfg) override; \
};
TEST_STUB_SIGNATRUE_LIST(DECLARE_STUB_CLASS)
#undef DECLARE_STUB_CLASS
#endif
class FooAOTStub : public Stub {
public:
// 8 : 8 means argument counts
explicit FooAOTStub(Circuit *circuit) : Stub("FooAOT", 8, circuit)
{
}
~FooAOTStub() = default;
NO_MOVE_SEMANTIC(FooAOTStub);
NO_COPY_SEMANTIC(FooAOTStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class BarAOTStub : public Stub {
public:
// 8 : 8 means argument counts
explicit BarAOTStub(Circuit *circuit) : Stub("BarAOT", 8, circuit)
{
}
~BarAOTStub() = default;
NO_MOVE_SEMANTIC(BarAOTStub);
NO_COPY_SEMANTIC(BarAOTStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class Foo1AOTStub : public Stub {
public:
// 8 : 8 means argument counts
explicit Foo1AOTStub(Circuit *circuit) : Stub("Foo1AOT", 8, circuit)
{
}
~Foo1AOTStub() = default;
NO_MOVE_SEMANTIC(Foo1AOTStub);
NO_COPY_SEMANTIC(Foo1AOTStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class Foo2AOTStub : public Stub {
public:
// 8 : 8 means argument counts
explicit Foo2AOTStub(Circuit *circuit) : Stub("Foo2AOT", 8, circuit)
{
}
~Foo2AOTStub() = default;
NO_MOVE_SEMANTIC(Foo2AOTStub);
NO_COPY_SEMANTIC(Foo2AOTStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class FooNativeAOTStub : public Stub {
public:
// 8 : 8 means argument counts
explicit FooNativeAOTStub(Circuit *circuit) : Stub("FooNativeAOT", 8, circuit)
{
}
~FooNativeAOTStub() = default;
NO_MOVE_SEMANTIC(FooNativeAOTStub);
NO_COPY_SEMANTIC(FooNativeAOTStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class FooBoundAOTStub : public Stub {
public:
// 8 : 8 means argument counts
explicit FooBoundAOTStub(Circuit *circuit) : Stub("FooBoundAOT", 8, circuit)
{
}
~FooBoundAOTStub() = default;
NO_MOVE_SEMANTIC(FooBoundAOTStub);
NO_COPY_SEMANTIC(FooBoundAOTStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class Bar1AOTStub : public Stub {
public:
// 9 : 9 means argument counts
explicit Bar1AOTStub(Circuit *circuit) : Stub("Bar1AOT", 9, circuit)
{
}
~Bar1AOTStub() = default;
NO_MOVE_SEMANTIC(Bar1AOTStub);
NO_COPY_SEMANTIC(Bar1AOTStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class FooProxyAOTStub : public Stub {
public:
// 8 : 8 means argument counts
explicit FooProxyAOTStub(Circuit *circuit) : Stub("FooProxyAOT", 8, circuit)
{
}
~FooProxyAOTStub() = default;
NO_MOVE_SEMANTIC(FooProxyAOTStub);
NO_COPY_SEMANTIC(FooProxyAOTStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class FooProxy2AOTStub : public Stub {
public:
// 8 : 8 means argument counts
explicit FooProxy2AOTStub(Circuit *circuit) : Stub("FooProxy2AOTStub", 8, circuit)
{
}
~FooProxy2AOTStub() = default;
NO_MOVE_SEMANTIC(FooProxy2AOTStub);
NO_COPY_SEMANTIC(FooProxy2AOTStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class Bar2AOTStub : public Stub {
public:
// 6 : 6 means argument counts
explicit Bar2AOTStub(Circuit *circuit) : Stub("Bar2AOT", 6, circuit)
{
}
~Bar2AOTStub() = default;
NO_MOVE_SEMANTIC(Bar2AOTStub);
NO_COPY_SEMANTIC(Bar2AOTStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
class TestAbsoluteAddressRelocationStub : public Stub {
public:
// 2 : 2 means argument counts
explicit TestAbsoluteAddressRelocationStub(Circuit *circuit) : Stub("TestAbsoluteAddressRelocation", 1, circuit)
{
}
~TestAbsoluteAddressRelocationStub() = default;
NO_MOVE_SEMANTIC(TestAbsoluteAddressRelocationStub);
NO_COPY_SEMANTIC(TestAbsoluteAddressRelocationStub);
void GenerateCircuit(const CompilationConfig *cfg) override;
};
}
#endif

76
ecmascript/compiler/tests/stub_tests.cpp
View File

@ -102,7 +102,9 @@ HWTEST_F_L0(StubTest, FastAddTest)
auto module = stubModule.GetModule();
auto function = stubModule.GetFunction(CommonStubCSigns::Add);
Circuit netOfGates;
AddStub optimizer(&netOfGates);
CallSignature callSignature;
AddCallSignature::Initialize(&callSignature);
AddStub optimizer(&callSignature, &netOfGates);
optimizer.GenerateCircuit(stubModule.GetCompilationConfig());
netOfGates.PrintAllGates();
auto cfg = Scheduler::Run(&netOfGates);
@ -139,7 +141,9 @@ HWTEST_F_L0(StubTest, FastSubTest)
auto module = stubModule.GetModule();
auto function = stubModule.GetFunction(CommonStubCSigns::Sub);
Circuit netOfGates;
SubStub optimizer(&netOfGates);
CallSignature callSignature;
SubCallSignature::Initialize(&callSignature);
SubStub optimizer(&callSignature, &netOfGates);
optimizer.GenerateCircuit(stubModule.GetCompilationConfig());
netOfGates.PrintAllGates();
auto cfg = Scheduler::Run(&netOfGates);
@ -172,7 +176,9 @@ HWTEST_F_L0(StubTest, FastMulTest)
auto module = stubModule.GetModule();
auto function = stubModule.GetFunction(CommonStubCSigns::Mul);
Circuit netOfGates;
MulStub optimizer(&netOfGates);
CallSignature callSignature;
MulCallSignature::Initialize(&callSignature);
MulStub optimizer(&callSignature, &netOfGates);
optimizer.GenerateCircuit(stubModule.GetCompilationConfig());
netOfGates.PrintAllGates();
auto cfg = Scheduler::Run(&netOfGates);
@ -224,7 +230,9 @@ HWTEST_F_L0(StubTest, FastDivTest)
auto module = stubModule.GetModule();
auto function = stubModule.GetFunction(CommonStubCSigns::Div);
Circuit netOfGates;
DivStub optimizer(&netOfGates);
CallSignature callSignature;
DivCallSignature::Initialize(&callSignature);
DivStub optimizer(&callSignature, &netOfGates);
optimizer.GenerateCircuit(stubModule.GetCompilationConfig());
netOfGates.PrintAllGates();
auto cfg = Scheduler::Run(&netOfGates);
@ -269,7 +277,9 @@ HWTEST_F_L0(StubTest, FastModTest)
auto module = stubModule.GetModule();
auto function = stubModule.GetFunction(CommonStubCSigns::Mod);
Circuit netOfGates;
ModStub optimizer(&netOfGates);
CallSignature callSignature;
ModCallSignature::Initialize(&callSignature);
ModStub optimizer(&callSignature, &netOfGates);
optimizer.GenerateCircuit(stubModule.GetCompilationConfig());
netOfGates.PrintAllGates();
auto cfg = Scheduler::Run(&netOfGates);
@ -333,7 +343,9 @@ HWTEST_F_L0(StubTest, TryLoadICByName)
auto module = stubModule.GetModule();
auto findFunction = stubModule.GetFunction(CommonStubCSigns::TryLoadICByName);
Circuit netOfGates;
TryLoadICByNameStub optimizer(&netOfGates);
CallSignature callSignature;
TryLoadICByNameCallSignature::Initialize(&callSignature);
TryLoadICByNameStub optimizer(&callSignature, &netOfGates);
optimizer.GenerateCircuit(stubModule.GetCompilationConfig());
netOfGates.PrintAllGates();
auto cfg = Scheduler::Run(&netOfGates);
@ -350,7 +362,9 @@ HWTEST_F_L0(StubTest, TryLoadICByValue)
auto module = stubModule.GetModule();
auto findFunction = stubModule.GetFunction(CommonStubCSigns::TryLoadICByValue);
Circuit netOfGates;
TryLoadICByValueStub optimizer(&netOfGates);
CallSignature callSignature;
TryLoadICByValueCallSignature::Initialize(&callSignature);
TryLoadICByValueStub optimizer(&callSignature, &netOfGates);
optimizer.GenerateCircuit(stubModule.GetCompilationConfig());
netOfGates.PrintAllGates();
auto cfg = Scheduler::Run(&netOfGates);
@ -367,7 +381,9 @@ HWTEST_F_L0(StubTest, TryStoreICByName)
auto module = stubModule.GetModule();
auto findFunction = stubModule.GetFunction(CommonStubCSigns::TryStoreICByName);
Circuit netOfGates;
TryStoreICByNameStub optimizer(&netOfGates);
CallSignature callSignature;
TryStoreICByNameCallSignature::Initialize(&callSignature);
TryStoreICByNameStub optimizer(&callSignature, &netOfGates);
optimizer.GenerateCircuit(stubModule.GetCompilationConfig());
netOfGates.PrintAllGates();
auto cfg = Scheduler::Run(&netOfGates);
@ -384,7 +400,9 @@ HWTEST_F_L0(StubTest, TryStoreICByValue)
auto module = stubModule.GetModule();
auto findFunction = stubModule.GetFunction(CommonStubCSigns::TryStoreICByValue);
Circuit netOfGates;
TryStoreICByValueStub optimizer(&netOfGates);
CallSignature callSignature;
TryStoreICByValueCallSignature::Initialize(&callSignature);
TryStoreICByValueStub optimizer(&callSignature, &netOfGates);
optimizer.GenerateCircuit(stubModule.GetCompilationConfig());
netOfGates.PrintAllGates();
auto cfg = Scheduler::Run(&netOfGates);
@ -847,7 +865,9 @@ HWTEST_F_L0(StubTest, GetPropertyByIndexStub)
auto module = stubModule.GetModule();
auto function = stubModule.GetFunction(CommonStubCSigns::GetPropertyByIndex);
Circuit netOfGates;
GetPropertyByIndexStub optimizer(&netOfGates);
CallSignature callSignature;
GetPropertyByIndexCallSignature::Initialize(&callSignature);
GetPropertyByIndexStub optimizer(&callSignature, &netOfGates);
optimizer.GenerateCircuit(stubModule.GetCompilationConfig());
netOfGates.PrintAllGates();
auto cfg = Scheduler::Run(&netOfGates);
@ -877,7 +897,9 @@ HWTEST_F_L0(StubTest, SetPropertyByIndexStub)
auto module = stubModule.GetModule();
auto function = stubModule.GetFunction(CommonStubCSigns::SetPropertyByIndex);
Circuit netOfGates;
SetPropertyByIndexStub optimizer(&netOfGates);
CallSignature callSignature;
SetPropertyByIndexCallSignature::Initialize(&callSignature);
SetPropertyByIndexStub optimizer(&callSignature, &netOfGates);
optimizer.GenerateCircuit(stubModule.GetCompilationConfig());
netOfGates.PrintAllGates();
bool result = Verifier::Run(&netOfGates);
@ -911,7 +933,9 @@ HWTEST_F_L0(StubTest, GetPropertyByNameStub)
auto module = stubModule.GetModule();
auto function = stubModule.GetFunction(CommonStubCSigns::GetPropertyByName);
Circuit netOfGates;
GetPropertyByNameStub optimizer(&netOfGates);
CallSignature callSignature;
GetPropertyByNameCallSignature::Initialize(&callSignature);
GetPropertyByNameStub optimizer(&callSignature, &netOfGates);
optimizer.GenerateCircuit(stubModule.GetCompilationConfig());
netOfGates.PrintAllGates();
bool result = Verifier::Run(&netOfGates);
@ -947,7 +971,9 @@ HWTEST_F_L0(StubTest, SetPropertyByNameStub)
auto module = stubModule.GetModule();
auto function = stubModule.GetFunction(CommonStubCSigns::SetPropertyByName);
Circuit netOfGates;
SetPropertyByNameStub optimizer(&netOfGates);
CallSignature callSignature;
SetPropertyByNameCallSignature::Initialize(&callSignature);
SetPropertyByNameStub optimizer(&callSignature, &netOfGates);
optimizer.GenerateCircuit(stubModule.GetCompilationConfig());
netOfGates.PrintAllGates();
auto cfg = Scheduler::Run(&netOfGates);
@ -980,7 +1006,9 @@ HWTEST_F_L0(StubTest, GetPropertyByValueStub)
auto module = stubModule.GetModule();
LLVMValueRef getPropertyByIndexfunction = stubModule.GetFunction(CommonStubCSigns::GetPropertyByIndex);
Circuit netOfGates2;
GetPropertyByIndexStub getPropertyByIndexStub(&netOfGates2);
CallSignature callSignature;
GetPropertyByIndexCallSignature::Initialize(&callSignature);
GetPropertyByIndexStub getPropertyByIndexStub(&callSignature, &netOfGates2);
getPropertyByIndexStub.GenerateCircuit(stubModule.GetCompilationConfig());
netOfGates2.PrintAllGates();
auto cfg2 = Scheduler::Run(&netOfGates2);
@ -990,7 +1018,9 @@ HWTEST_F_L0(StubTest, GetPropertyByValueStub)
LLVMValueRef getPropertyByNamefunction = stubModule.GetFunction(CommonStubCSigns::GetPropertyByName);
Circuit netOfGates1;
GetPropertyByNameStub getPropertyByNameStub(&netOfGates1);
CallSignature callSignature1;
GetPropertyByNameCallSignature::Initialize(&callSignature1);
GetPropertyByNameStub getPropertyByNameStub(&callSignature1, &netOfGates1);
getPropertyByNameStub.GenerateCircuit(stubModule.GetCompilationConfig());
bool result = Verifier::Run(&netOfGates1);
ASSERT_TRUE(result);
@ -1001,7 +1031,9 @@ HWTEST_F_L0(StubTest, GetPropertyByValueStub)
LLVMValueRef function = stubModule.GetFunction(CommonStubCSigns::GetPropertyByValue);
Circuit netOfGates;
GetPropertyByValueStub optimizer(&netOfGates);
CallSignature callSignature2;
GetPropertyByValueCallSignature::Initialize(&callSignature2);
GetPropertyByValueStub optimizer(&callSignature2, &netOfGates);
optimizer.GenerateCircuit(stubModule.GetCompilationConfig());
netOfGates.PrintAllGates();
result = Verifier::Run(&netOfGates);
@ -1068,7 +1100,9 @@ HWTEST_F_L0(StubTest, FastTypeOfTest)
auto module = stubModule.GetModule();
auto function = stubModule.GetFunction(CommonStubCSigns::TypeOf);
Circuit netOfGates;
TypeOfStub optimizer(&netOfGates);
CallSignature callSignature;
TypeOfCallSignature::Initialize(&callSignature);
TypeOfStub optimizer(&callSignature, &netOfGates);
optimizer.GenerateCircuit(stubModule.GetCompilationConfig());
netOfGates.PrintAllGates();
bool verRes = Verifier::Run(&netOfGates);
@ -1154,7 +1188,9 @@ HWTEST_F_L0(StubTest, FastEqualTest)
auto module = stubModule.GetModule();
auto function = stubModule.GetFunction(CommonStubCSigns::Equal);
Circuit netOfGates;
EqualStub optimizer(&netOfGates);
CallSignature callSignature;
EqualCallSignature::Initialize(&callSignature);
EqualStub optimizer(&callSignature, &netOfGates);
optimizer.GenerateCircuit(stubModule.GetCompilationConfig());
netOfGates.PrintAllGates();
auto cfg = Scheduler::Run(&netOfGates);
@ -1385,7 +1421,9 @@ HWTEST_F_L0(StubTest, RelocateTest)
auto module = stubModule.GetModule();
auto function = stubModule.GetFunction(CommonStubCSigns::TestAbsoluteAddressRelocation);
Circuit netOfGates;
TestAbsoluteAddressRelocationStub optimizer(&netOfGates);
CallSignature callSignature;
TestAbsoluteAddressRelocationCallSignature::Initialize(&callSignature);
TestAbsoluteAddressRelocationStub optimizer(&callSignature, &netOfGates);
optimizer.GenerateCircuit(stubModule.GetCompilationConfig());
netOfGates.PrintAllGates();
bool verRes = Verifier::Run(&netOfGates);