diff --git a/ecmascript/base/error_helper.cpp b/ecmascript/base/error_helper.cpp
index 4b6e4f0df9..eb3ca02508 100644
--- a/ecmascript/base/error_helper.cpp
+++ b/ecmascript/base/error_helper.cpp
@@ -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;
diff --git a/ecmascript/compiler/tests/stub_tests.cpp b/ecmascript/compiler/tests/stub_tests.cpp
index 6a2f63c03e..16d815ce13 100644
--- a/ecmascript/compiler/tests/stub_tests.cpp
+++ b/ecmascript/compiler/tests/stub_tests.cpp
@@ -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;
diff --git a/ecmascript/dump.cpp b/ecmascript/dump.cpp
index 30bacd0593..f5adfe9fa6 100644
--- a/ecmascript/dump.cpp
+++ b/ecmascript/dump.cpp
@@ -552,7 +552,7 @@ void JSTaggedValue::DumpVal(JSThread *thread, JSTaggedType val)
 
 void JSThread::DumpStack()
 {
-    EcmaFrameHandler handler(this);
+    InterpretedFrameHandler handler(this);
     handler.DumpStack(std::cout);
 }
 
diff --git a/ecmascript/ecma_language_context.cpp b/ecmascript/ecma_language_context.cpp
index 5bd15494b5..8a59b2ec2d 100644
--- a/ecmascript/ecma_language_context.cpp
+++ b/ecmascript/ecma_language_context.cpp
@@ -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;
diff --git a/ecmascript/frames.h b/ecmascript/frames.h
index e13e0237ab..822d8e58e1 100644
--- a/ecmascript/frames.h
+++ b/ecmascript/frames.h
@@ -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*);
diff --git a/ecmascript/ic/function_cache.h b/ecmascript/ic/function_cache.h
index edf42f06f5..b2ddcd5c75 100644
--- a/ecmascript/ic/function_cache.h
+++ b/ecmascript/ic/function_cache.h
@@ -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());
     }
diff --git a/ecmascript/interpreter/frame_handler.cpp b/ecmascript/interpreter/frame_handler.cpp
index cc9c75a59b..91e28045a3 100644
--- a/ecmascript/interpreter/frame_handler.cpp
+++ b/ecmascript/interpreter/frame_handler.cpp
@@ -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);
         }
diff --git a/ecmascript/interpreter/frame_handler.h b/ecmascript/interpreter/frame_handler.h
index 25b3e53638..9c8a6b7181 100644
--- a/ecmascript/interpreter/frame_handler.h
+++ b/ecmascript/interpreter/frame_handler.h
@@ -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);
diff --git a/ecmascript/interpreter/interpreter-inl.h b/ecmascript/interpreter/interpreter-inl.h
index 596acfa3d3..024178229a 100644
--- a/ecmascript/interpreter/interpreter-inl.h
+++ b/ecmascript/interpreter/interpreter-inl.h
@@ -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()) {
diff --git a/ecmascript/interpreter/interpreter.h b/ecmascript/interpreter/interpreter.h
index 0c1a504d99..1e119c3266 100644
--- a/ecmascript/interpreter/interpreter.h
+++ b/ecmascript/interpreter/interpreter.h
@@ -40,7 +40,7 @@ struct FrameState {
     JSTaggedValue acc;
     JSTaggedValue env;
     uint64_t numActualArgs;
-    InterPretFrameStateBase base;
+    InterpretedFrameStateBase base;
 };
 
 // NOLINTNEXTLINE(bugprone-sizeof-expression)
diff --git a/ecmascript/interpreter/slow_runtime_helper.cpp b/ecmascript/interpreter/slow_runtime_helper.cpp
index 4d89e3df16..1d9a9a8096 100644
--- a/ecmascript/interpreter/slow_runtime_helper.cpp
+++ b/ecmascript/interpreter/slow_runtime_helper.cpp
@@ -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);
diff --git a/ecmascript/interpreter/slow_runtime_stub.cpp b/ecmascript/interpreter/slow_runtime_stub.cpp
index 43f35cdbf2..40814567e6 100644
--- a/ecmascript/interpreter/slow_runtime_stub.cpp
+++ b/ecmascript/interpreter/slow_runtime_stub.cpp
@@ -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);
diff --git a/ecmascript/js_thread.cpp b/ecmascript/js_thread.cpp
index 6338196739..02827166a7 100644
--- a/ecmascript/js_thread.cpp
+++ b/ecmascript/js_thread.cpp
@@ -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)
diff --git a/ecmascript/object_factory.cpp b/ecmascript/object_factory.cpp
index 554f77f1ad..d760c314c8 100644
--- a/ecmascript/object_factory.cpp
+++ b/ecmascript/object_factory.cpp
@@ -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);
diff --git a/ecmascript/runtime_trampolines.cpp b/ecmascript/runtime_trampolines.cpp
index f52e2bfb12..e9592ee8ac 100644
--- a/ecmascript/runtime_trampolines.cpp
+++ b/ecmascript/runtime_trampolines.cpp
@@ -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();
diff --git a/ecmascript/runtime_trampolines.h b/ecmascript/runtime_trampolines.h
index 94e7115181..e221bbbf4b 100644
--- a/ecmascript/runtime_trampolines.h
+++ b/ecmascript/runtime_trampolines.h
@@ -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));
diff --git a/ecmascript/tooling/agent/js_backend.cpp b/ecmascript/tooling/agent/js_backend.cpp
index 6172d2ae76..9cf7c709c2 100644
--- a/ecmascript/tooling/agent/js_backend.cpp
+++ b/ecmascript/tooling/agent/js_backend.cpp
@@ -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>();
diff --git a/ecmascript/tooling/agent/js_backend.h b/ecmascript/tooling/agent/js_backend.h
index 44060029ca..2cdff1cff7 100644
--- a/ecmascript/tooling/agent/js_backend.h
+++ b/ecmascript/tooling/agent/js_backend.h
@@ -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);
diff --git a/ecmascript/tooling/interface/debugger_api.cpp b/ecmascript/tooling/interface/debugger_api.cpp
index 93ae8e71d0..ab629242e7 100644
--- a/ecmascript/tooling/interface/debugger_api.cpp
+++ b/ecmascript/tooling/interface/debugger_api.cpp
@@ -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);
diff --git a/ecmascript/tooling/interface/debugger_api.h b/ecmascript/tooling/interface/debugger_api.h
index fa9458c892..18b6f3b6c4 100644
--- a/ecmascript/tooling/interface/debugger_api.h
+++ b/ecmascript/tooling/interface/debugger_api.h
@@ -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);
diff --git a/ecmascript/tooling/pt_js_extractor.cpp b/ecmascript/tooling/pt_js_extractor.cpp
index 7498f82b05..fe9e50f4ee 100644
--- a/ecmascript/tooling/pt_js_extractor.cpp
+++ b/ecmascript/tooling/pt_js_extractor.cpp
@@ -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
 {