mirror of
https://gitee.com/openharmony/arkcompiler_ets_runtime
synced 2024-10-07 16:13:49 +00:00
fastboot review
Signed-off-by: surpassgoodchao <surpassgoodchao@qq.com>
This commit is contained in:
parent
8724269cb9
commit
d15fafc5ac
@ -192,7 +192,7 @@ CString ErrorHelper::BuildNativeEcmaStackTrace(JSThread *thread)
|
||||
{
|
||||
auto ecmaVm = thread->GetEcmaVM();
|
||||
CString data;
|
||||
EcmaFrameHandler frameHandler(thread);
|
||||
InterpretedFrameHandler frameHandler(thread);
|
||||
for (; frameHandler.HasFrame(); frameHandler.PrevFrame()) {
|
||||
if (frameHandler.IsBreakFrame()) {
|
||||
continue;
|
||||
|
@ -1134,10 +1134,9 @@ void DoSafepoint()
|
||||
if (found) {
|
||||
for (auto &info : infos) {
|
||||
uintptr_t **address = nullptr;
|
||||
if (info.first == 7) { // 7: x86_64 dwarf register num, representing rsp
|
||||
if (info.first == SP_DWARF_REG_NUM) {
|
||||
address = reinterpret_cast<uintptr_t **>(reinterpret_cast<uint8_t *>(rsp) + info.second);
|
||||
// rbp
|
||||
} else if (info.first == 6) { // 6: x86_64 dwarf register num, representing rbp
|
||||
} else if (info.first == FP_DWARF_REG_NUM) {
|
||||
address = reinterpret_cast<uintptr_t **>(reinterpret_cast<uint8_t *>(rbp) + info.second);
|
||||
}
|
||||
std::cout << std::hex << "ref addr:" << address;
|
||||
|
@ -552,7 +552,7 @@ void JSTaggedValue::DumpVal(JSThread *thread, JSTaggedType val)
|
||||
|
||||
void JSThread::DumpStack()
|
||||
{
|
||||
EcmaFrameHandler handler(this);
|
||||
InterpretedFrameHandler handler(this);
|
||||
handler.DumpStack(std::cout);
|
||||
}
|
||||
|
||||
|
@ -25,7 +25,7 @@
|
||||
#include "include/tooling/pt_lang_extension.h"
|
||||
|
||||
namespace panda {
|
||||
using ecmascript::EcmaFrameHandler;
|
||||
using ecmascript::InterpretedFrameHandler;
|
||||
using ecmascript::EcmaVM;
|
||||
using ecmascript::JSThread;
|
||||
|
||||
@ -34,7 +34,7 @@ std::pair<Method *, uint32_t> EcmaLanguageContext::GetCatchMethodAndOffset(Metho
|
||||
Method *catchMethod = method;
|
||||
uint32_t catchOffset = 0;
|
||||
auto jsThread = static_cast<JSThread *>(thread);
|
||||
EcmaFrameHandler frameHandler(jsThread);
|
||||
InterpretedFrameHandler frameHandler(jsThread);
|
||||
for (; frameHandler.HasFrame(); frameHandler.PrevFrame()) {
|
||||
if (frameHandler.IsBreakFrame()) {
|
||||
continue;
|
||||
|
@ -118,12 +118,17 @@
|
||||
// or Optimized EntryFrame/Optimized Frame.
|
||||
// **nop** represent don't call SAVE or UPDATE, **illegal** represent this secnarios don't existed.
|
||||
|
||||
// ```
|
||||
// iframe OptimizedEntry Optimized RunTime
|
||||
// iframe SAVE/UPATE SAVE illegal SAVE/UPATE
|
||||
// OptimizedEntry UPATE illegal nop UPATE
|
||||
// Optimized UPATE illegal nop UPATE
|
||||
// RunTime nop illegal illegal nop
|
||||
// +----------------------------------------------------------------------+
|
||||
// | | iframe | OptimizedEntry | Optimized | RunTime |
|
||||
// |-----------------------------------------------------------------------
|
||||
// |iframe | SAVE/UPATE | SAVE | illegal | SAVE/UPATE |
|
||||
// |-----------------------------------------------------------------------
|
||||
// |OptimizedEntry | UPATE | illegal | nop | UPATE |
|
||||
// |-----------------------------------------------------------------------
|
||||
// |Optimized | UPATE | illegal | nop | UPATE |
|
||||
// |-----------------------------------------------------------------------
|
||||
// |RunTime | nop | illegal | illegal | nop |
|
||||
// +----------------------------------------------------------------------+
|
||||
// ```
|
||||
|
||||
// Iterator Frame from Runtime Frame, the process is as flollows:
|
||||
@ -231,22 +236,22 @@ auto as_integer(Enumeration const value)
|
||||
return static_cast<typename std::underlying_type<Enumeration>::type>(value);
|
||||
}
|
||||
|
||||
class OptFrameStateBase {
|
||||
class OptimizedFrameStateBase {
|
||||
public:
|
||||
FrameType frameType;
|
||||
uint64_t *prev; // for llvm :c-fp ; for interrupt: thread-fp for gc
|
||||
};
|
||||
|
||||
class InterPretFrameStateBase {
|
||||
class InterpretedFrameStateBase {
|
||||
public:
|
||||
uint64_t *prev; // for llvm :c-fp ; for interrupt: thread-fp for gc
|
||||
FrameType frameType;
|
||||
};
|
||||
|
||||
class LLVMOptimizedEntryFrameState {
|
||||
class OptimizedEntryFrameState {
|
||||
public:
|
||||
uint64_t *threadFp; // for gc
|
||||
OptFrameStateBase base;
|
||||
OptimizedFrameStateBase base;
|
||||
};
|
||||
|
||||
constexpr int kSystemPointerSize = sizeof(void*);
|
||||
|
@ -36,7 +36,7 @@ public:
|
||||
|
||||
static inline FunctionCache *GetCurrent(JSThread *thread)
|
||||
{
|
||||
JSTaggedValue funcValue = EcmaFrameHandler(thread).GetFunction();
|
||||
JSTaggedValue funcValue = InterpretedFrameHandler(thread).GetFunction();
|
||||
JSFunction *func = JSFunction::Cast(funcValue.GetTaggedObject());
|
||||
return FunctionCache::Cast(func->GetFunctionCache().GetTaggedObject());
|
||||
}
|
||||
|
@ -23,18 +23,18 @@
|
||||
#include "ecmascript/compiler/llvm/llvm_stackmap_parser.h"
|
||||
|
||||
namespace panda::ecmascript {
|
||||
EcmaFrameHandler::EcmaFrameHandler(const JSThread *thread)
|
||||
InterpretedFrameHandler::InterpretedFrameHandler(const JSThread *thread)
|
||||
{
|
||||
sp_ = const_cast<JSTaggedType *>(thread->GetCurrentSPFrame());
|
||||
}
|
||||
|
||||
bool EcmaFrameHandler::HasFrame() const
|
||||
bool InterpretedFrameHandler::HasFrame() const
|
||||
{
|
||||
// Breakframe also is a frame
|
||||
return sp_ != nullptr;
|
||||
}
|
||||
|
||||
bool EcmaFrameHandler::IsBreakFrame() const
|
||||
bool InterpretedFrameHandler::IsBreakFrame() const
|
||||
{
|
||||
ASSERT(HasFrame());
|
||||
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
|
||||
@ -42,7 +42,7 @@ bool EcmaFrameHandler::IsBreakFrame() const
|
||||
return state->sp == nullptr;
|
||||
}
|
||||
|
||||
void EcmaFrameHandler::PrevFrame()
|
||||
void InterpretedFrameHandler::PrevFrame()
|
||||
{
|
||||
ASSERT(HasFrame());
|
||||
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
|
||||
@ -50,29 +50,29 @@ void EcmaFrameHandler::PrevFrame()
|
||||
sp_ = state->base.prev;
|
||||
}
|
||||
|
||||
EcmaFrameHandler EcmaFrameHandler::GetPrevFrame() const
|
||||
InterpretedFrameHandler InterpretedFrameHandler::GetPrevFrame() const
|
||||
{
|
||||
ASSERT(HasFrame());
|
||||
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
|
||||
FrameState *state = reinterpret_cast<FrameState *>(sp_) - 1;
|
||||
return EcmaFrameHandler(state->base.prev);
|
||||
return InterpretedFrameHandler(state->base.prev);
|
||||
}
|
||||
|
||||
JSTaggedValue EcmaFrameHandler::GetVRegValue(size_t index) const
|
||||
JSTaggedValue InterpretedFrameHandler::GetVRegValue(size_t index) const
|
||||
{
|
||||
ASSERT(HasFrame());
|
||||
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
|
||||
return JSTaggedValue(sp_[index]);
|
||||
}
|
||||
|
||||
void EcmaFrameHandler::SetVRegValue(size_t index, JSTaggedValue value)
|
||||
void InterpretedFrameHandler::SetVRegValue(size_t index, JSTaggedValue value)
|
||||
{
|
||||
ASSERT(HasFrame());
|
||||
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
|
||||
sp_[index] = value.GetRawData();
|
||||
}
|
||||
|
||||
JSTaggedValue EcmaFrameHandler::GetAcc() const
|
||||
JSTaggedValue InterpretedFrameHandler::GetAcc() const
|
||||
{
|
||||
ASSERT(HasFrame());
|
||||
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
|
||||
@ -80,7 +80,7 @@ JSTaggedValue EcmaFrameHandler::GetAcc() const
|
||||
return state->acc;
|
||||
}
|
||||
|
||||
uint32_t EcmaFrameHandler::GetSize() const
|
||||
uint32_t InterpretedFrameHandler::GetSize() const
|
||||
{
|
||||
ASSERT(HasFrame());
|
||||
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
|
||||
@ -91,7 +91,7 @@ uint32_t EcmaFrameHandler::GetSize() const
|
||||
return static_cast<uint32_t>(size);
|
||||
}
|
||||
|
||||
uint32_t EcmaFrameHandler::GetBytecodeOffset() const
|
||||
uint32_t InterpretedFrameHandler::GetBytecodeOffset() const
|
||||
{
|
||||
ASSERT(HasFrame());
|
||||
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
|
||||
@ -101,7 +101,7 @@ uint32_t EcmaFrameHandler::GetBytecodeOffset() const
|
||||
return static_cast<uint32_t>(offset);
|
||||
}
|
||||
|
||||
JSMethod *EcmaFrameHandler::GetMethod() const
|
||||
JSMethod *InterpretedFrameHandler::GetMethod() const
|
||||
{
|
||||
ASSERT(HasFrame());
|
||||
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
|
||||
@ -109,7 +109,7 @@ JSMethod *EcmaFrameHandler::GetMethod() const
|
||||
return state->method;
|
||||
}
|
||||
|
||||
JSTaggedValue EcmaFrameHandler::GetFunction() const
|
||||
JSTaggedValue InterpretedFrameHandler::GetFunction() const
|
||||
{
|
||||
ASSERT(HasFrame());
|
||||
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
|
||||
@ -120,7 +120,7 @@ JSTaggedValue EcmaFrameHandler::GetFunction() const
|
||||
return func;
|
||||
}
|
||||
|
||||
const uint8_t *EcmaFrameHandler::GetPc() const
|
||||
const uint8_t *InterpretedFrameHandler::GetPc() const
|
||||
{
|
||||
ASSERT(HasFrame());
|
||||
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
|
||||
@ -128,7 +128,7 @@ const uint8_t *EcmaFrameHandler::GetPc() const
|
||||
return state->pc;
|
||||
}
|
||||
|
||||
JSTaggedType *EcmaFrameHandler::GetSp() const
|
||||
JSTaggedType *InterpretedFrameHandler::GetSp() const
|
||||
{
|
||||
ASSERT(HasFrame());
|
||||
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
|
||||
@ -136,7 +136,7 @@ JSTaggedType *EcmaFrameHandler::GetSp() const
|
||||
return state->sp;
|
||||
}
|
||||
|
||||
ConstantPool *EcmaFrameHandler::GetConstpool() const
|
||||
ConstantPool *InterpretedFrameHandler::GetConstpool() const
|
||||
{
|
||||
ASSERT(HasFrame());
|
||||
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
|
||||
@ -144,7 +144,7 @@ ConstantPool *EcmaFrameHandler::GetConstpool() const
|
||||
return state->constpool;
|
||||
}
|
||||
|
||||
JSTaggedValue EcmaFrameHandler::GetEnv() const
|
||||
JSTaggedValue InterpretedFrameHandler::GetEnv() const
|
||||
{
|
||||
ASSERT(HasFrame());
|
||||
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
|
||||
@ -152,7 +152,7 @@ JSTaggedValue EcmaFrameHandler::GetEnv() const
|
||||
return state->env;
|
||||
}
|
||||
|
||||
void EcmaFrameHandler::Iterate(const RootVisitor &v0, const RootRangeVisitor &v1)
|
||||
void InterpretedFrameHandler::Iterate(const RootVisitor &v0, const RootRangeVisitor &v1)
|
||||
{
|
||||
JSTaggedType *current = sp_;
|
||||
if (current != nullptr) {
|
||||
@ -176,10 +176,10 @@ void EcmaFrameHandler::Iterate(const RootVisitor &v0, const RootRangeVisitor &v1
|
||||
}
|
||||
}
|
||||
|
||||
void EcmaFrameHandler::DumpStack(std::ostream &os) const
|
||||
void InterpretedFrameHandler::DumpStack(std::ostream &os) const
|
||||
{
|
||||
size_t i = 0;
|
||||
EcmaFrameHandler frameHandler(sp_);
|
||||
InterpretedFrameHandler frameHandler(sp_);
|
||||
for (; frameHandler.HasFrame(); frameHandler.PrevFrame()) {
|
||||
os << "[" << i++
|
||||
<< "]:" << frameHandler.GetMethod()->ParseFunctionName()
|
||||
@ -187,9 +187,9 @@ void EcmaFrameHandler::DumpStack(std::ostream &os) const
|
||||
}
|
||||
}
|
||||
|
||||
void EcmaFrameHandler::DumpPC(std::ostream &os, const uint8_t *pc) const
|
||||
void InterpretedFrameHandler::DumpPC(std::ostream &os, const uint8_t *pc) const
|
||||
{
|
||||
EcmaFrameHandler frameHandler(sp_);
|
||||
InterpretedFrameHandler frameHandler(sp_);
|
||||
ASSERT(frameHandler.HasFrame());
|
||||
|
||||
// NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions, bugprone-narrowing-conversions)
|
||||
@ -245,18 +245,19 @@ void FrameIterator::Iterate(const RootVisitor &v0, const RootRangeVisitor &v1) c
|
||||
reinterpret_cast<long long>(current) + FrameConst::kFrameType));
|
||||
if (type == FrameType::INTERPRETER_FRAME) {
|
||||
FrameState *state = reinterpret_cast<FrameState *>(current) - 1;
|
||||
EcmaFrameHandler(current).Iterate(v0, v1);
|
||||
InterpretedFrameHandler(current).Iterate(v0, v1);
|
||||
current = state->base.prev;
|
||||
} else if (type == FrameType::OPTIMIZED_FRAME) {
|
||||
OptFrameStateBase *state = reinterpret_cast<OptFrameStateBase *>(
|
||||
OptimizedFrameStateBase *state = reinterpret_cast<OptimizedFrameStateBase *>(
|
||||
reinterpret_cast<long long>(current) -
|
||||
MEMBER_OFFSET(OptFrameStateBase, prev));
|
||||
MEMBER_OFFSET(OptimizedFrameStateBase, prev));
|
||||
OptimizedFrameHandler(current).Iterate(v0, v1);
|
||||
current = reinterpret_cast<JSTaggedType *>(state->prev);
|
||||
} else {
|
||||
LLVMOptimizedEntryFrameState *state = reinterpret_cast<LLVMOptimizedEntryFrameState *>(
|
||||
ASSERT(type == FrameType::OPTIMIZED_ENTRY_FRAME);
|
||||
OptimizedEntryFrameState *state = reinterpret_cast<OptimizedEntryFrameState *>(
|
||||
reinterpret_cast<long long>(current) -
|
||||
MEMBER_OFFSET(LLVMOptimizedEntryFrameState, base.prev));
|
||||
MEMBER_OFFSET(OptimizedEntryFrameState, base.prev));
|
||||
OptimizedEntryFrameHandler(current).Iterate(v0, v1);
|
||||
current = reinterpret_cast<JSTaggedType *>(state->threadFp);
|
||||
}
|
||||
|
@ -26,18 +26,18 @@ class JSThread;
|
||||
class JSFunction;
|
||||
class ConstantPool;
|
||||
|
||||
class EcmaFrameHandler {
|
||||
class InterpretedFrameHandler {
|
||||
public:
|
||||
explicit EcmaFrameHandler(JSTaggedType *sp) : sp_(sp) {}
|
||||
explicit EcmaFrameHandler(const JSThread *thread);
|
||||
~EcmaFrameHandler() = default;
|
||||
DEFAULT_COPY_SEMANTIC(EcmaFrameHandler);
|
||||
DEFAULT_MOVE_SEMANTIC(EcmaFrameHandler);
|
||||
explicit InterpretedFrameHandler(JSTaggedType *sp) : sp_(sp) {}
|
||||
explicit InterpretedFrameHandler(const JSThread *thread);
|
||||
~InterpretedFrameHandler() = default;
|
||||
DEFAULT_COPY_SEMANTIC(InterpretedFrameHandler);
|
||||
DEFAULT_MOVE_SEMANTIC(InterpretedFrameHandler);
|
||||
|
||||
bool HasFrame() const;
|
||||
bool IsBreakFrame() const;
|
||||
void PrevFrame();
|
||||
EcmaFrameHandler GetPrevFrame() const;
|
||||
InterpretedFrameHandler GetPrevFrame() const;
|
||||
|
||||
JSTaggedValue GetVRegValue(size_t index) const;
|
||||
void SetVRegValue(size_t index, JSTaggedValue value);
|
||||
|
@ -229,7 +229,7 @@ JSTaggedValue EcmaInterpreter::ExecuteNative(JSThread *thread, const CallParams&
|
||||
|
||||
FrameState *state = GET_FRAME(newSp);
|
||||
state->base.prev = sp;
|
||||
state->base.frameType = ecmascript::FrameType::INTERPRETER_FRAME;
|
||||
state->base.frameType = FrameType::INTERPRETER_FRAME;
|
||||
state->pc = nullptr;
|
||||
state->sp = newSp;
|
||||
state->method = methodToCall;
|
||||
@ -450,7 +450,7 @@ void EcmaInterpreter::ResumeContext(JSThread *thread)
|
||||
|
||||
void EcmaInterpreter::NotifyBytecodePcChanged(JSThread *thread)
|
||||
{
|
||||
EcmaFrameHandler frameHandler(thread);
|
||||
InterpretedFrameHandler frameHandler(thread);
|
||||
for (; frameHandler.HasFrame(); frameHandler.PrevFrame()) {
|
||||
if (frameHandler.IsBreakFrame()) {
|
||||
continue;
|
||||
@ -3183,7 +3183,7 @@ NO_UB_SANITIZE void EcmaInterpreter::RunInternal(JSThread *thread, ConstantPool
|
||||
HANDLE_OPCODE(EXCEPTION_HANDLER) {
|
||||
auto exception = thread->GetException();
|
||||
|
||||
EcmaFrameHandler frameHandler(sp);
|
||||
InterpretedFrameHandler frameHandler(sp);
|
||||
uint32_t pcOffset = panda_file::INVALID_OFFSET;
|
||||
for (; frameHandler.HasFrame(); frameHandler.PrevFrame()) {
|
||||
if (frameHandler.IsBreakFrame()) {
|
||||
|
@ -40,7 +40,7 @@ struct FrameState {
|
||||
JSTaggedValue acc;
|
||||
JSTaggedValue env;
|
||||
uint64_t numActualArgs;
|
||||
InterPretFrameStateBase base;
|
||||
InterpretedFrameStateBase base;
|
||||
};
|
||||
|
||||
// NOLINTNEXTLINE(bugprone-sizeof-expression)
|
||||
|
@ -82,7 +82,7 @@ JSTaggedValue SlowRuntimeHelper::NewObject(JSThread *thread, JSHandle<JSTaggedVa
|
||||
|
||||
void SlowRuntimeHelper::SaveFrameToContext(JSThread *thread, JSHandle<GeneratorContext> context)
|
||||
{
|
||||
EcmaFrameHandler frameHandler(thread);
|
||||
InterpretedFrameHandler frameHandler(thread);
|
||||
ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
|
||||
uint32_t nregs = frameHandler.GetSize();
|
||||
JSHandle<TaggedArray> regsArray = factory->NewTaggedArray(nregs);
|
||||
@ -122,7 +122,7 @@ JSTaggedValue ConstructGeneric(JSThread *thread, JSHandle<JSFunction> ctor, JSHa
|
||||
}
|
||||
|
||||
// Add the input parameter
|
||||
EcmaFrameHandler frameHandler(thread);
|
||||
InterpretedFrameHandler frameHandler(thread);
|
||||
CallParams params;
|
||||
params.callTarget = ECMAObject::Cast(*ctor);
|
||||
params.newTarget = newTgt.GetTaggedType();
|
||||
@ -221,7 +221,7 @@ JSTaggedValue ConstructProxy(JSThread *thread, JSHandle<JSProxy> ctor, JSHandle<
|
||||
args->Set(thread, i, value);
|
||||
}
|
||||
}
|
||||
EcmaFrameHandler frameHandler(thread);
|
||||
InterpretedFrameHandler frameHandler(thread);
|
||||
for (array_size_t i = 0; i < argsCount; ++i) {
|
||||
JSTaggedValue value = frameHandler.GetVRegValue(baseArgLocation + i);
|
||||
args->Set(thread, i + preArgsSize, value);
|
||||
|
@ -439,7 +439,7 @@ JSTaggedValue SlowRuntimeStub::CreateObjectWithExcludedKeys(JSThread *thread, ui
|
||||
JSHandle<JSObject> obj(thread, objVal);
|
||||
array_size_t numExcludedKeys = 0;
|
||||
JSHandle<TaggedArray> excludedKeys = factory->NewTaggedArray(numKeys + 1);
|
||||
EcmaFrameHandler frameHandler(thread);
|
||||
InterpretedFrameHandler frameHandler(thread);
|
||||
JSTaggedValue excludedKey = frameHandler.GetVRegValue(firstArgRegIdx);
|
||||
if (!excludedKey.IsUndefined()) {
|
||||
numExcludedKeys = numKeys + 1;
|
||||
@ -1716,7 +1716,7 @@ JSTaggedValue SlowRuntimeStub::SuperCall(JSThread *thread, JSTaggedValue func, J
|
||||
INTERPRETER_TRACE(thread, SuperCall);
|
||||
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
||||
ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
|
||||
EcmaFrameHandler frameHandler(thread);
|
||||
InterpretedFrameHandler frameHandler(thread);
|
||||
|
||||
JSHandle<JSTaggedValue> funcHandle(thread, func);
|
||||
JSHandle<JSTaggedValue> newTargetHandle(thread, newTarget);
|
||||
@ -1741,7 +1741,7 @@ JSTaggedValue SlowRuntimeStub::SuperCallSpread(JSThread *thread, JSTaggedValue f
|
||||
{
|
||||
INTERPRETER_TRACE(thread, SuperCallSpread);
|
||||
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
||||
EcmaFrameHandler frameHandler(thread);
|
||||
InterpretedFrameHandler frameHandler(thread);
|
||||
|
||||
JSHandle<JSTaggedValue> funcHandle(thread, func);
|
||||
JSHandle<JSTaggedValue> newTargetHandle(thread, newTarget);
|
||||
|
@ -78,7 +78,7 @@ void JSThread::ClearException()
|
||||
|
||||
JSTaggedValue JSThread::GetCurrentLexenv() const
|
||||
{
|
||||
return EcmaFrameHandler(currentFrame_).GetEnv();
|
||||
return InterpretedFrameHandler(currentFrame_).GetEnv();
|
||||
}
|
||||
|
||||
void JSThread::Iterate(const RootVisitor &v0, const RootRangeVisitor &v1)
|
||||
|
@ -2088,7 +2088,7 @@ JSHandle<JSObject> ObjectFactory::NewEmptyJSObject()
|
||||
|
||||
EcmaString *ObjectFactory::ResolveString(uint32_t stringId)
|
||||
{
|
||||
JSMethod *caller = EcmaFrameHandler(thread_).GetMethod();
|
||||
JSMethod *caller = InterpretedFrameHandler(thread_).GetMethod();
|
||||
auto *pf = caller->GetPandaFile();
|
||||
auto id = panda_file::File::EntityId(stringId);
|
||||
auto foundStr = pf->GetStringData(id);
|
||||
|
@ -30,7 +30,7 @@ bool RuntimeTrampolines::AddElementInternal(uint64_t argThread, uint64_t argRece
|
||||
JSTaggedType *fp = nullptr;
|
||||
GET_CURRETN_FP(fp);
|
||||
auto thread = reinterpret_cast<JSThread *>(argThread);
|
||||
StubCallRunTimeThreadFpScope(thread, fp);
|
||||
CallRuntimeTrampolinesScope scope(thread, fp);
|
||||
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
||||
JSHandle<JSObject> receiver(thread, reinterpret_cast<TaggedObject *>(argReceiver));
|
||||
JSHandle<JSTaggedValue> value(thread, JSTaggedValue(reinterpret_cast<TaggedObject *>(argValue)));
|
||||
@ -44,7 +44,7 @@ bool RuntimeTrampolines::CallSetter(uint64_t argThread, uint64_t argSetter, uint
|
||||
JSTaggedType *fp = nullptr;
|
||||
GET_CURRETN_FP(fp);
|
||||
auto thread = reinterpret_cast<JSThread *>(argThread);
|
||||
StubCallRunTimeThreadFpScope(thread, fp);
|
||||
CallRuntimeTrampolinesScope scope(thread, fp);
|
||||
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
||||
JSHandle<JSTaggedValue> receiver(thread, JSTaggedValue(reinterpret_cast<TaggedObject *>(argReceiver)));
|
||||
JSHandle<JSTaggedValue> value(thread, JSTaggedValue(reinterpret_cast<TaggedObject *>(argValue)));
|
||||
@ -57,7 +57,7 @@ void RuntimeTrampolines::ThrowTypeError(uint64_t argThread, int argMessageString
|
||||
JSTaggedType *fp = nullptr;
|
||||
GET_CURRETN_FP(fp);
|
||||
auto thread = reinterpret_cast<JSThread *>(argThread);
|
||||
StubCallRunTimeThreadFpScope(thread, fp);
|
||||
CallRuntimeTrampolinesScope scope(thread, fp);
|
||||
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
||||
std::string message = MessageString::GetMessageString(argMessageStringId);
|
||||
ObjectFactory *factory = JSThread::Cast(thread)->GetEcmaVM()->GetFactory();
|
||||
@ -71,7 +71,7 @@ bool RuntimeTrampolines::JSProxySetProperty(uint64_t argThread, uint64_t argProx
|
||||
JSTaggedType *fp = nullptr;
|
||||
GET_CURRETN_FP(fp);
|
||||
auto thread = reinterpret_cast<JSThread *>(argThread);
|
||||
StubCallRunTimeThreadFpScope(thread, fp);
|
||||
CallRuntimeTrampolinesScope scope(thread, fp);
|
||||
[[maybe_unused]] EcmaHandleScope handleScope(thread);
|
||||
JSHandle<JSProxy> proxy(thread, JSTaggedValue(reinterpret_cast<TaggedObject *>(argProxy)));
|
||||
JSHandle<JSTaggedValue> index(thread, JSTaggedValue(reinterpret_cast<TaggedObject *>(argKey)));
|
||||
@ -92,7 +92,7 @@ uint64_t RuntimeTrampolines::CallGetter(uint64_t argThread, uint64_t argGetter,
|
||||
JSTaggedType *fp = nullptr;
|
||||
GET_CURRETN_FP(fp);
|
||||
auto thread = reinterpret_cast<JSThread *>(argThread);
|
||||
StubCallRunTimeThreadFpScope(thread, fp);
|
||||
CallRuntimeTrampolinesScope scope(thread, fp);
|
||||
auto accessor = AccessorData::Cast(reinterpret_cast<TaggedObject *>(argGetter));
|
||||
JSHandle<JSTaggedValue> objHandle(thread, JSTaggedValue(reinterpret_cast<TaggedObject *>(argReceiver)));
|
||||
return JSObject::CallGetter(thread, accessor, objHandle).GetRawData();
|
||||
@ -103,7 +103,7 @@ uint64_t RuntimeTrampolines::AccessorGetter(uint64_t argThread, uint64_t argGett
|
||||
JSTaggedType *fp = nullptr;
|
||||
GET_CURRETN_FP(fp);
|
||||
auto thread = reinterpret_cast<JSThread *>(argThread);
|
||||
StubCallRunTimeThreadFpScope(thread, fp);
|
||||
CallRuntimeTrampolinesScope scope(thread, fp);
|
||||
auto accessor = AccessorData::Cast(reinterpret_cast<TaggedObject *>(argGetter));
|
||||
JSHandle<JSObject> objHandle(thread, JSTaggedValue(reinterpret_cast<TaggedObject *>(argReceiver)));
|
||||
return accessor->CallInternalGet(thread, objHandle).GetRawData();
|
||||
|
@ -50,23 +50,23 @@ public:
|
||||
static uint32_t StringGetHashCode(uint64_t ecmaString);
|
||||
};
|
||||
|
||||
class StubCallRunTimeThreadFpScope {
|
||||
class CallRuntimeTrampolinesScope {
|
||||
public:
|
||||
StubCallRunTimeThreadFpScope(JSThread *thread, JSTaggedType *newFp)
|
||||
CallRuntimeTrampolinesScope(JSThread *thread, JSTaggedType *newFp)
|
||||
:oldRbp_(const_cast<JSTaggedType *>(thread->GetCurrentSPFrame())),
|
||||
thread_(thread)
|
||||
{
|
||||
thread_->SetCurrentSPFrame(newFp);
|
||||
|
||||
std::cout << "StubCallRunTimeThreadFpScope newFp: " << newFp << " oldRbp_ : " << oldRbp_
|
||||
std::cout << "CallRuntimeTrampolinesScope newFp: " << newFp << " oldRbp_ : " << oldRbp_
|
||||
<< " thread_->fp:" << thread_->GetCurrentSPFrame() <<std::endl;
|
||||
FrameType type = *(reinterpret_cast<FrameType*>(
|
||||
reinterpret_cast<long long>(newFp) + FrameConst::kFrameType));
|
||||
std::cout << "type = " << as_integer(type) << std::endl;
|
||||
}
|
||||
~StubCallRunTimeThreadFpScope()
|
||||
~CallRuntimeTrampolinesScope()
|
||||
{
|
||||
std::cout << "~StubCallRunTimeThreadFpScope oldRbp_: " << oldRbp_ <<
|
||||
std::cout << "~CallRuntimeTrampolinesScope oldRbp_: " << oldRbp_ <<
|
||||
" thread_->fp:" << thread_->GetCurrentSPFrame() << std::endl;
|
||||
FrameType type = *(reinterpret_cast<FrameType*>(
|
||||
reinterpret_cast<long long>(oldRbp_) + FrameConst::kFrameType));
|
||||
|
@ -458,7 +458,7 @@ PtJSExtractor *JSBackend::GetExtractor(const CString &url)
|
||||
bool JSBackend::GenerateCallFrames(CVector<std::unique_ptr<CallFrame>> *callFrames)
|
||||
{
|
||||
int32_t callFrameId = 0;
|
||||
auto walkerFunc = [this, &callFrameId, &callFrames](const EcmaFrameHandler *frameHandler) -> StackState {
|
||||
auto walkerFunc = [this, &callFrameId, &callFrames](const InterpretedFrameHandler *frameHandler) -> StackState {
|
||||
JSMethod *method = DebuggerApi::GetMethod(frameHandler);
|
||||
if (method->IsNative()) {
|
||||
LOG(INFO, DEBUGGER) << "GenerateCallFrames: Skip CFrame and Native method";
|
||||
@ -478,7 +478,7 @@ bool JSBackend::GenerateCallFrames(CVector<std::unique_ptr<CallFrame>> *callFram
|
||||
return DebuggerApi::StackWalker(ecmaVm_, walkerFunc);
|
||||
}
|
||||
|
||||
bool JSBackend::GenerateCallFrame(CallFrame *callFrame, const EcmaFrameHandler *frameHandler, int32_t callFrameId)
|
||||
bool JSBackend::GenerateCallFrame(CallFrame *callFrame, const InterpretedFrameHandler *frameHandler, int32_t callFrameId)
|
||||
{
|
||||
JSMethod *method = DebuggerApi::GetMethod(frameHandler);
|
||||
auto *pf = method->GetPandaFile();
|
||||
@ -528,7 +528,7 @@ bool JSBackend::GenerateCallFrame(CallFrame *callFrame, const EcmaFrameHandler *
|
||||
return true;
|
||||
}
|
||||
|
||||
std::unique_ptr<Scope> JSBackend::GetLocalScopeChain(const EcmaFrameHandler *frameHandler,
|
||||
std::unique_ptr<Scope> JSBackend::GetLocalScopeChain(const InterpretedFrameHandler *frameHandler,
|
||||
std::unique_ptr<RemoteObject> *thisObj)
|
||||
{
|
||||
auto localScope = std::make_unique<Scope>();
|
||||
|
@ -109,8 +109,8 @@ private:
|
||||
PtJSExtractor *GetExtractor(const panda_file::File *file);
|
||||
PtJSExtractor *GetExtractor(const CString &url);
|
||||
bool GenerateCallFrames(CVector<std::unique_ptr<CallFrame>> *callFrames);
|
||||
bool GenerateCallFrame(CallFrame *callFrame, const EcmaFrameHandler *frameHandler, int32_t frameId);
|
||||
std::unique_ptr<Scope> GetLocalScopeChain(const EcmaFrameHandler *frameHandler,
|
||||
bool GenerateCallFrame(CallFrame *callFrame, const InterpretedFrameHandler *frameHandler, int32_t frameId);
|
||||
std::unique_ptr<Scope> GetLocalScopeChain(const InterpretedFrameHandler *frameHandler,
|
||||
std::unique_ptr<RemoteObject> *thisObj);
|
||||
std::unique_ptr<Scope> GetGlobalScopeChain();
|
||||
std::optional<Error> SetValue(int32_t regIndex, std::unique_ptr<RemoteObject> *result, const CString &varValue);
|
||||
|
@ -49,11 +49,11 @@ CString DebuggerApi::ConvertToString(const std::string &str)
|
||||
return panda::ecmascript::ConvertToString(str);
|
||||
}
|
||||
|
||||
// EcmaFrameHandler
|
||||
// InterpretedFrameHandler
|
||||
uint32_t DebuggerApi::GetStackDepth(const EcmaVM *ecmaVm)
|
||||
{
|
||||
uint32_t count = 0;
|
||||
EcmaFrameHandler frameHandler(ecmaVm->GetJSThread());
|
||||
InterpretedFrameHandler frameHandler(ecmaVm->GetJSThread());
|
||||
for (; frameHandler.HasFrame(); frameHandler.PrevFrame()) {
|
||||
if (frameHandler.IsBreakFrame()) {
|
||||
continue;
|
||||
@ -63,9 +63,9 @@ uint32_t DebuggerApi::GetStackDepth(const EcmaVM *ecmaVm)
|
||||
return count;
|
||||
}
|
||||
|
||||
bool DebuggerApi::StackWalker(const EcmaVM *ecmaVm, std::function<StackState(const EcmaFrameHandler *)> func)
|
||||
bool DebuggerApi::StackWalker(const EcmaVM *ecmaVm, std::function<StackState(const InterpretedFrameHandler *)> func)
|
||||
{
|
||||
EcmaFrameHandler frameHandler(ecmaVm->GetJSThread());
|
||||
InterpretedFrameHandler frameHandler(ecmaVm->GetJSThread());
|
||||
for (; frameHandler.HasFrame(); frameHandler.PrevFrame()) {
|
||||
if (frameHandler.IsBreakFrame()) {
|
||||
continue;
|
||||
@ -84,37 +84,37 @@ bool DebuggerApi::StackWalker(const EcmaVM *ecmaVm, std::function<StackState(con
|
||||
|
||||
uint32_t DebuggerApi::GetBytecodeOffset(const EcmaVM *ecmaVm)
|
||||
{
|
||||
return EcmaFrameHandler(ecmaVm->GetJSThread()).GetBytecodeOffset();
|
||||
return InterpretedFrameHandler(ecmaVm->GetJSThread()).GetBytecodeOffset();
|
||||
}
|
||||
|
||||
JSMethod *DebuggerApi::GetMethod(const EcmaVM *ecmaVm)
|
||||
{
|
||||
return EcmaFrameHandler(ecmaVm->GetJSThread()).GetMethod();
|
||||
return InterpretedFrameHandler(ecmaVm->GetJSThread()).GetMethod();
|
||||
}
|
||||
|
||||
Local<JSValueRef> DebuggerApi::GetVRegValue(const EcmaVM *ecmaVm, size_t index)
|
||||
{
|
||||
auto value = EcmaFrameHandler(ecmaVm->GetJSThread()).GetVRegValue(index);
|
||||
auto value = InterpretedFrameHandler(ecmaVm->GetJSThread()).GetVRegValue(index);
|
||||
JSHandle<JSTaggedValue> handledValue(ecmaVm->GetJSThread(), value);
|
||||
return JSNApiHelper::ToLocal<JSValueRef>(handledValue);
|
||||
}
|
||||
|
||||
void DebuggerApi::SetVRegValue(const EcmaVM *ecmaVm, size_t index, Local<JSValueRef> value)
|
||||
{
|
||||
return EcmaFrameHandler(ecmaVm->GetJSThread()).SetVRegValue(index, JSNApiHelper::ToJSTaggedValue(*value));
|
||||
return InterpretedFrameHandler(ecmaVm->GetJSThread()).SetVRegValue(index, JSNApiHelper::ToJSTaggedValue(*value));
|
||||
}
|
||||
|
||||
uint32_t DebuggerApi::GetBytecodeOffset(const EcmaFrameHandler *frameHandler)
|
||||
uint32_t DebuggerApi::GetBytecodeOffset(const InterpretedFrameHandler *frameHandler)
|
||||
{
|
||||
return frameHandler->GetBytecodeOffset();
|
||||
}
|
||||
|
||||
JSMethod *DebuggerApi::GetMethod(const EcmaFrameHandler *frameHandler)
|
||||
JSMethod *DebuggerApi::GetMethod(const InterpretedFrameHandler *frameHandler)
|
||||
{
|
||||
return frameHandler->GetMethod();
|
||||
}
|
||||
|
||||
Local<JSValueRef> DebuggerApi::GetVRegValue(const EcmaVM *ecmaVm, const EcmaFrameHandler *frameHandler, size_t index)
|
||||
Local<JSValueRef> DebuggerApi::GetVRegValue(const EcmaVM *ecmaVm, const InterpretedFrameHandler *frameHandler, size_t index)
|
||||
{
|
||||
auto value = frameHandler->GetVRegValue(index);
|
||||
JSHandle<JSTaggedValue> handledValue(ecmaVm->GetJSThread(), value);
|
||||
|
@ -32,7 +32,7 @@ class JSDebugger;
|
||||
} // tooling::ecmascript
|
||||
|
||||
namespace ecmascript {
|
||||
class EcmaFrameHandler;
|
||||
class InterpretedFrameHandler;
|
||||
class EcmaVM;
|
||||
class JSMethod;
|
||||
class JSThread;
|
||||
@ -41,7 +41,7 @@ class JSThread;
|
||||
|
||||
namespace panda::tooling::ecmascript {
|
||||
using panda::ecmascript::CString;
|
||||
using panda::ecmascript::EcmaFrameHandler;
|
||||
using panda::ecmascript::InterpretedFrameHandler;
|
||||
using panda::ecmascript::EcmaVM;
|
||||
using panda::ecmascript::JSMethod;
|
||||
using panda::ecmascript::JSThread;
|
||||
@ -59,16 +59,16 @@ public:
|
||||
static CString ToCString(int32_t number);
|
||||
static CString ConvertToString(const std::string &str);
|
||||
|
||||
// EcmaFrameHandler
|
||||
// InterpretedFrameHandler
|
||||
static uint32_t GetStackDepth(const EcmaVM *ecmaVm);
|
||||
static bool StackWalker(const EcmaVM *ecmaVm, std::function<StackState(const EcmaFrameHandler *)> func);
|
||||
static bool StackWalker(const EcmaVM *ecmaVm, std::function<StackState(const InterpretedFrameHandler *)> func);
|
||||
static uint32_t GetBytecodeOffset(const EcmaVM *ecmaVm);
|
||||
static JSMethod *GetMethod(const EcmaVM *ecmaVm);
|
||||
static Local<JSValueRef> GetVRegValue(const EcmaVM *ecmaVm, size_t index);
|
||||
static void SetVRegValue(const EcmaVM *ecmaVm, size_t index, Local<JSValueRef> value);
|
||||
static uint32_t GetBytecodeOffset(const EcmaFrameHandler *frameHandler);
|
||||
static JSMethod *GetMethod(const EcmaFrameHandler *frameHandler);
|
||||
static Local<JSValueRef> GetVRegValue(const EcmaVM *ecmaVm, const EcmaFrameHandler *frameHandler, size_t index);
|
||||
static uint32_t GetBytecodeOffset(const InterpretedFrameHandler *frameHandler);
|
||||
static JSMethod *GetMethod(const InterpretedFrameHandler *frameHandler);
|
||||
static Local<JSValueRef> GetVRegValue(const EcmaVM *ecmaVm, const InterpretedFrameHandler *frameHandler, size_t index);
|
||||
|
||||
// JSThread
|
||||
static Local<JSValueRef> GetException(const EcmaVM *ecmaVm);
|
||||
|
@ -17,7 +17,7 @@
|
||||
#include "ecmascript/tooling/pt_js_extractor.h"
|
||||
|
||||
namespace panda::tooling::ecmascript {
|
||||
using panda::ecmascript::EcmaFrameHandler;
|
||||
using panda::ecmascript::InterpretedFrameHandler;
|
||||
using panda::ecmascript::JSTaggedType;
|
||||
uint32_t PtJSExtractor::SingleStepper::GetStackDepth() const
|
||||
{
|
||||
|
Loading…
Reference in New Issue
Block a user