From dcd4c0f49b086a704a3252f5facc918326a2c1fa Mon Sep 17 00:00:00 2001
From: hufeng <hufeng20@huawei.com>
Date: Tue, 1 Nov 2022 21:25:32 +0800
Subject: [PATCH 1/2] Fix no restoring before CFG on ES2ABC

Signed-off-by: hufeng <hufeng20@huawei.com>
Change-Id: Ia668f7977628c6b6689506b468cff6a7764fbd5e
---
 es2panda/compiler/core/function.cpp           |   1 +
 es2panda/compiler/core/pandagen.cpp           | 198 ++++++-------
 es2panda/compiler/core/pandagen.h             |  18 +-
 es2panda/compiler/core/regAllocator.cpp       | 215 +++++++-------
 es2panda/compiler/core/regAllocator.h         | 152 ++++------
 es2panda/compiler/templates/isa.h.erb         |  40 ++-
 es2panda/ir/irnode.h                          |  10 +
 .../test-spill-fill-with-CFG-expected.txt     |   1 +
 .../regAllocator/test-spill-fill-with-CFG.js  | 274 ++++++++++++++++++
 9 files changed, 608 insertions(+), 301 deletions(-)
 create mode 100644 es2panda/test/compiler/js/regAllocator/test-spill-fill-with-CFG-expected.txt
 create mode 100644 es2panda/test/compiler/js/regAllocator/test-spill-fill-with-CFG.js

diff --git a/es2panda/compiler/core/function.cpp b/es2panda/compiler/core/function.cpp
index 9143ac1ca2..3769926906 100644
--- a/es2panda/compiler/core/function.cpp
+++ b/es2panda/compiler/core/function.cpp
@@ -205,6 +205,7 @@ static void CompileFunctionOrProgram(PandaGen *pg)
 void Function::Compile(PandaGen *pg)
 {
     CompileFunctionOrProgram(pg);
+    pg->AdjustSpillInsns();
     pg->SetFunctionKind();
     pg->SetSourceLocationFlag(lexer::SourceLocationFlag::INVALID_SOURCE_LOCATION);
     pg->CopyFunctionArguments(pg->RootNode());
diff --git a/es2panda/compiler/core/pandagen.cpp b/es2panda/compiler/core/pandagen.cpp
index ed81f39bda..a7c61bf5f4 100644
--- a/es2panda/compiler/core/pandagen.cpp
+++ b/es2panda/compiler/core/pandagen.cpp
@@ -91,7 +91,7 @@ void PandaGen::SetFunctionKind()
 Label *PandaGen::AllocLabel()
 {
     std::string id = std::string {Label::PREFIX} + std::to_string(labelId_++);
-    return sa_.AllocLabel(std::move(id));
+    return ra_.AllocLabel(std::move(id));
 }
 
 bool PandaGen::IsDebug() const
@@ -210,6 +210,8 @@ void PandaGen::InitializeLexEnv(const ir::AstNode *node)
 void PandaGen::CopyFunctionArguments(const ir::AstNode *node)
 {
     FrontAllocator fa(this);
+    auto spillRegsCount = ra_.GetSpillRegsCount();
+    totalRegs_ += spillRegsCount;
     VReg targetReg = totalRegs_;
 
     for (const auto *param : topScope_->ParamScope()->Params()) {
@@ -221,11 +223,11 @@ void PandaGen::CopyFunctionArguments(const ir::AstNode *node)
             auto typeIndex = context_->TypeRecorder()->GetVariableTypeIndex(param);
             if (typeIndex != extractor::TypeRecorder::PRIMITIVETYPE_ANY) {
                 // Simply encode type index for params
-                MoveVregWithType(node, -(typeIndex + 1), param->Vreg(), targetReg++);
+                MoveVregWithType(node, -(typeIndex + 1), param->Vreg() + spillRegsCount, targetReg++);
                 continue;
             }
         }
-        MoveVreg(node, param->Vreg(), targetReg++);
+        MoveVreg(node, param->Vreg() + spillRegsCount, targetReg++);
     }
 }
 
@@ -462,9 +464,9 @@ void PandaGen::TryLoadGlobalByName(const ir::AstNode *node, const util::StringVi
     } else {
         int64_t typeIndex = extractor::TypeExtractor::GetBuiltinTypeIndex(name);
         if (context_->IsTypeExtractorEnabled() && typeIndex != extractor::TypeRecorder::PRIMITIVETYPE_ANY) {
-            sa_.EmitWithType<Tryldglobalbyname>(node, typeIndex, 0, name);
+            ra_.EmitWithType<Tryldglobalbyname>(node, typeIndex, 0, name);
         } else {
-            sa_.Emit<Tryldglobalbyname>(node, 0, name);
+            ra_.Emit<Tryldglobalbyname>(node, 0, name);
         }
     }
     strings_.insert(name);
@@ -493,7 +495,7 @@ void PandaGen::TryStoreGlobalByName(const ir::AstNode *node, const util::StringV
     if (isDebuggerEvaluateExpressionMode()) {
         StoreObjByNameViaDebugger(node, name);
     } else {
-        sa_.Emit<Trystglobalbyname>(node, 0, name);
+        ra_.Emit<Trystglobalbyname>(node, 0, name);
     }
     strings_.insert(name);
 }
@@ -501,7 +503,7 @@ void PandaGen::TryStoreGlobalByName(const ir::AstNode *node, const util::StringV
 void PandaGen::LoadObjByName(const ir::AstNode *node, VReg obj, const util::StringView &prop)
 {
     LoadAccumulator(node, obj); // object is load to acc
-    sa_.Emit<Ldobjbyname>(node, 0, prop);
+    ra_.Emit<Ldobjbyname>(node, 0, prop);
     strings_.insert(prop);
 }
 
@@ -515,11 +517,11 @@ void PandaGen::LoadObjByIndex(const ir::AstNode *node, VReg obj, int64_t index)
 {
     LoadAccumulator(node, obj); // object is load to acc
     if (index <= util::Helpers::MAX_INT16) {
-        sa_.Emit<Ldobjbyindex>(node, 0, index);
+        ra_.Emit<Ldobjbyindex>(node, 0, index);
         return;
     }
 
-    sa_.Emit<WideLdobjbyindex>(node, index);
+    ra_.Emit<WideLdobjbyindex>(node, index);
 }
 
 void PandaGen::LoadObjByValue(const ir::AstNode *node, VReg obj)
@@ -586,13 +588,13 @@ void PandaGen::LoadAccumulator(const ir::AstNode *node, VReg reg)
 
 void PandaGen::LoadGlobalVar(const ir::AstNode *node, const util::StringView &name)
 {
-    sa_.Emit<Ldglobalvar>(node, 0, name);
+    ra_.Emit<Ldglobalvar>(node, 0, name);
     strings_.insert(name);
 }
 
 void PandaGen::StoreGlobalVar(const ir::AstNode *node, const util::StringView &name)
 {
-    sa_.Emit<Stglobalvar>(node, 0, name);
+    ra_.Emit<Stglobalvar>(node, 0, name);
     strings_.insert(name);
 }
 
@@ -608,28 +610,28 @@ void PandaGen::StoreAccToLexEnv(const ir::AstNode *node, const binder::ScopeFind
 
 void PandaGen::LoadAccumulatorString(const ir::AstNode *node, const util::StringView &str)
 {
-    sa_.Emit<LdaStr>(node, str);
+    ra_.Emit<LdaStr>(node, str);
     strings_.insert(str);
 }
 
 void PandaGen::LoadAccumulatorFloat(const ir::AstNode *node, double num)
 {
-    sa_.Emit<Fldai>(node, num);
+    ra_.Emit<Fldai>(node, num);
 }
 
 void PandaGen::LoadAccumulatorInt(const ir::AstNode *node, int32_t num)
 {
-    sa_.Emit<Ldai>(node, num);
+    ra_.Emit<Ldai>(node, num);
 }
 
 void PandaGen::LoadAccumulatorInt(const ir::AstNode *node, size_t num)
 {
-    sa_.Emit<Ldai>(node, static_cast<int64_t>(num));
+    ra_.Emit<Ldai>(node, static_cast<int64_t>(num));
 }
 
 void PandaGen::LoadAccumulatorBigInt(const ir::AstNode *node, const util::StringView &num)
 {
-    sa_.Emit<Ldbigint>(node, num);
+    ra_.Emit<Ldbigint>(node, num);
     strings_.insert(num);
 }
 
@@ -643,39 +645,39 @@ void PandaGen::LoadConst(const ir::AstNode *node, Constant id)
 {
     switch (id) {
         case Constant::JS_HOLE: {
-            sa_.Emit<Ldhole>(node);
+            ra_.Emit<Ldhole>(node);
             break;
         }
         case Constant::JS_NAN: {
-            sa_.Emit<Ldnan>(node);
+            ra_.Emit<Ldnan>(node);
             break;
         }
         case Constant::JS_INFINITY: {
-            sa_.Emit<Ldinfinity>(node);
+            ra_.Emit<Ldinfinity>(node);
             break;
         }
         case Constant::JS_GLOBAL: {
-            sa_.Emit<Ldglobal>(node);
+            ra_.Emit<Ldglobal>(node);
             break;
         }
         case Constant::JS_UNDEFINED: {
-            sa_.Emit<Ldundefined>(node);
+            ra_.Emit<Ldundefined>(node);
             break;
         }
         case Constant::JS_SYMBOL: {
-            sa_.Emit<Ldsymbol>(node);
+            ra_.Emit<Ldsymbol>(node);
             break;
         }
         case Constant::JS_NULL: {
-            sa_.Emit<Ldnull>(node);
+            ra_.Emit<Ldnull>(node);
             break;
         }
         case Constant::JS_TRUE: {
-            sa_.Emit<Ldtrue>(node);
+            ra_.Emit<Ldtrue>(node);
             break;
         }
         case Constant::JS_FALSE: {
-            sa_.Emit<Ldfalse>(node);
+            ra_.Emit<Ldfalse>(node);
             break;
         }
         default: {
@@ -696,12 +698,12 @@ void PandaGen::MoveVregWithType(const ir::AstNode *node, int64_t typeIndex, VReg
 
 void PandaGen::SetLabel([[maybe_unused]] const ir::AstNode *node, Label *label)
 {
-    sa_.AddLabel(label);
+    ra_.AddLabel(label);
 }
 
 void PandaGen::Branch(const ir::AstNode *node, Label *label)
 {
-    sa_.Emit<Jmp>(node, label);
+    ra_.Emit<Jmp>(node, label);
 }
 
 bool PandaGen::CheckControlFlowChange() const
@@ -831,12 +833,12 @@ void PandaGen::Unary(const ir::AstNode *node, lexer::TokenType op, VReg operand)
         }
         case lexer::TokenType::PUNCTUATOR_MINUS: {
             LoadAccumulator(node, operand);
-            sa_.Emit<Neg>(node, 0);
+            ra_.Emit<Neg>(node, 0);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_TILDE: {
             LoadAccumulator(node, operand);
-            sa_.Emit<Not>(node, 0);
+            ra_.Emit<Not>(node, 0);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_EXCLAMATION_MARK: {
@@ -845,12 +847,12 @@ void PandaGen::Unary(const ir::AstNode *node, lexer::TokenType op, VReg operand)
         }
         case lexer::TokenType::PUNCTUATOR_PLUS_PLUS: {
             LoadAccumulator(node, operand);
-            sa_.Emit<Inc>(node, 0);
+            ra_.Emit<Inc>(node, 0);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_MINUS_MINUS: {
             LoadAccumulator(node, operand);
-            sa_.Emit<Dec>(node, 0);
+            ra_.Emit<Dec>(node, 0);
             break;
         }
         case lexer::TokenType::KEYW_VOID:
@@ -1020,7 +1022,7 @@ void PandaGen::GreaterEqual(const ir::AstNode *node, VReg lhs)
 
 void PandaGen::IsTrue(const ir::AstNode *node)
 {
-    sa_.Emit<Istrue>(node);
+    ra_.Emit<Istrue>(node);
 }
 
 void PandaGen::BranchIfUndefined(const ir::AstNode *node, Label *target)
@@ -1030,7 +1032,7 @@ void PandaGen::BranchIfUndefined(const ir::AstNode *node, Label *target)
     StoreAccumulator(node, tmp);
     LoadConst(node, Constant::JS_UNDEFINED);
     Equal(node, tmp);
-    sa_.Emit<Jnez>(node, target);
+    ra_.Emit<Jnez>(node, target);
 }
 
 void PandaGen::BranchIfNotUndefined(const ir::AstNode *node, Label *target)
@@ -1040,7 +1042,7 @@ void PandaGen::BranchIfNotUndefined(const ir::AstNode *node, Label *target)
     StoreAccumulator(node, tmp);
     LoadConst(node, Constant::JS_UNDEFINED);
     Equal(node, tmp);
-    sa_.Emit<Jeqz>(node, target);
+    ra_.Emit<Jeqz>(node, target);
 }
 
 void PandaGen::BranchIfStrictNotUndefined(const ir::AstNode *node, class Label *target)
@@ -1050,13 +1052,13 @@ void PandaGen::BranchIfStrictNotUndefined(const ir::AstNode *node, class Label *
     StoreAccumulator(node, tmp);
     LoadConst(node, Constant::JS_UNDEFINED);
     StrictEqual(node, tmp);
-    sa_.Emit<Jeqz>(node, target);
+    ra_.Emit<Jeqz>(node, target);
 }
 
 void PandaGen::BranchIfTrue(const ir::AstNode *node, Label *target)
 {
     IsTrue(node);
-    sa_.Emit<Jnez>(node, target);
+    ra_.Emit<Jnez>(node, target);
 }
 
 void PandaGen::BranchIfNotTrue(const ir::AstNode *node, Label *target)
@@ -1067,8 +1069,8 @@ void PandaGen::BranchIfNotTrue(const ir::AstNode *node, Label *target)
 
 void PandaGen::BranchIfFalse(const ir::AstNode *node, Label *target)
 {
-    sa_.Emit<Isfalse>(node);
-    sa_.Emit<Jnez>(node, target);
+    ra_.Emit<Isfalse>(node);
+    ra_.Emit<Jnez>(node, target);
 }
 
 void PandaGen::BranchIfStrictNull(const ir::AstNode *node, class Label *target)
@@ -1078,12 +1080,12 @@ void PandaGen::BranchIfStrictNull(const ir::AstNode *node, class Label *target)
     StoreAccumulator(node, tmp);
     LoadConst(node, Constant::JS_NULL);
     ra_.Emit<Stricteq>(node, 0, tmp);
-    sa_.Emit<Jnez>(node, target);
+    ra_.Emit<Jnez>(node, target);
 }
 
 void PandaGen::EmitThrow(const ir::AstNode *node)
 {
-    sa_.Emit<Throw>(node);
+    ra_.Emit<Throw>(node);
 }
 
 void PandaGen::EmitRethrow(const ir::AstNode *node)
@@ -1100,7 +1102,7 @@ void PandaGen::EmitRethrow(const ir::AstNode *node)
 
     LoadAccumulator(node, exception);
     NotEqual(node, hole);
-    sa_.Emit<Jeqz>(node, skipThrow);
+    ra_.Emit<Jeqz>(node, skipThrow);
 
     SetLabel(node, doThrow);
     LoadAccumulator(node, exception);
@@ -1111,12 +1113,12 @@ void PandaGen::EmitRethrow(const ir::AstNode *node)
 
 void PandaGen::EmitReturn(const ir::AstNode *node)
 {
-    sa_.Emit<Return>(node);
+    ra_.Emit<Return>(node);
 }
 
 void PandaGen::EmitReturnUndefined(const ir::AstNode *node)
 {
-    sa_.Emit<Returnundefined>(node);
+    ra_.Emit<Returnundefined>(node);
 }
 
 void PandaGen::ImplicitReturn(const ir::AstNode *node)
@@ -1190,11 +1192,11 @@ void PandaGen::CallThis(const ir::AstNode *node, VReg startReg, size_t argCount)
         default: {
             int64_t actualArgs = argCount - 1;
             if (actualArgs <= util::Helpers::MAX_INT8) {
-                rra_.Emit<Callthisrange>(node, thisReg, argCount, 0, actualArgs, thisReg);
+                ra_.EmitRange<Callthisrange>(node, argCount, 0, actualArgs, thisReg);
                 break;
             }
 
-            rra_.Emit<WideCallthisrange>(node, thisReg, argCount, actualArgs, thisReg);
+            ra_.EmitRange<WideCallthisrange>(node, argCount, actualArgs, thisReg);
             break;
         }
     }
@@ -1205,7 +1207,7 @@ void PandaGen::Call(const ir::AstNode *node, VReg startReg, size_t argCount)
     LoadAccumulator(node, startReg); // callee is load to acc
     switch (argCount) {
         case 0: { // 0 args
-            sa_.Emit<Callarg0>(node, 0);
+            ra_.Emit<Callarg0>(node, 0);
             break;
         }
         case 1: { // 1 arg
@@ -1229,11 +1231,11 @@ void PandaGen::Call(const ir::AstNode *node, VReg startReg, size_t argCount)
         default: {
             VReg arg0 = startReg + 1;
             if (argCount <= util::Helpers::MAX_INT8) {
-                rra_.Emit<Callrange>(node, arg0, argCount, 0, argCount, arg0);
+                ra_.EmitRange<Callrange>(node, argCount, 0, argCount, arg0);
                 break;
             }
 
-            rra_.Emit<WideCallrange>(node, arg0, argCount, argCount, arg0);
+            ra_.EmitRange<WideCallrange>(node, argCount, argCount, arg0);
             break;
         }
     }
@@ -1244,20 +1246,20 @@ void PandaGen::SuperCall(const ir::AstNode *node, VReg startReg, size_t argCount
     if (RootNode()->AsScriptFunction()->IsArrow()) {
         GetFunctionObject(node); // load funcobj to acc for super call in arrow function
         if (argCount <= util::Helpers::MAX_INT8) {
-            rra_.Emit<Supercallarrowrange>(node, startReg, argCount, 0, static_cast<int64_t>(argCount), startReg);
+            ra_.EmitRange<Supercallarrowrange>(node, argCount, 0, static_cast<int64_t>(argCount), startReg);
         } else {
-            rra_.Emit<WideSupercallarrowrange>(node, startReg, argCount, static_cast<int64_t>(argCount), startReg);
+            ra_.EmitRange<WideSupercallarrowrange>(node, argCount, static_cast<int64_t>(argCount), startReg);
         }
         return;
     }
 
     if (argCount <= util::Helpers::MAX_INT8) {
         // no need to load funcobj to acc for super call in other kinds of functions
-        rra_.Emit<Supercallthisrange>(node, startReg, argCount, 0, static_cast<int64_t>(argCount), startReg);
+        ra_.EmitRange<Supercallthisrange>(node, argCount, 0, static_cast<int64_t>(argCount), startReg);
         return;
     }
 
-    rra_.Emit<WideSupercallthisrange>(node, startReg, argCount, static_cast<int64_t>(argCount), startReg);
+    ra_.EmitRange<WideSupercallthisrange>(node, argCount, static_cast<int64_t>(argCount), startReg);
 }
 
 void PandaGen::SuperCallSpread(const ir::AstNode *node, VReg vs)
@@ -1268,11 +1270,11 @@ void PandaGen::SuperCallSpread(const ir::AstNode *node, VReg vs)
 void PandaGen::NewObject(const ir::AstNode *node, VReg startReg, size_t argCount)
 {
     if (argCount <= util::Helpers::MAX_INT8) {
-        rra_.Emit<Newobjrange>(node, startReg, argCount, 0, static_cast<int64_t>(argCount), startReg);
+        ra_.EmitRange<Newobjrange>(node, argCount, 0, static_cast<int64_t>(argCount), startReg);
         return;
     }
 
-    rra_.Emit<WideNewobjrange>(node, startReg, argCount, static_cast<int64_t>(argCount), startReg);
+    ra_.EmitRange<WideNewobjrange>(node, argCount, static_cast<int64_t>(argCount), startReg);
 }
 
 void PandaGen::DefineFunction(const ir::AstNode *node, const ir::ScriptFunction *realNode, const util::StringView &name)
@@ -1293,7 +1295,7 @@ void PandaGen::DefineFunction(const ir::AstNode *node, const ir::ScriptFunction
 
 void PandaGen::TypeOf(const ir::AstNode *node)
 {
-    sa_.Emit<Typeof>(node, 0);
+    ra_.Emit<Typeof>(node, 0);
 }
 
 void PandaGen::CallSpread(const ir::AstNode *node, VReg func, VReg thisReg, VReg args)
@@ -1309,7 +1311,7 @@ void PandaGen::NewObjSpread(const ir::AstNode *node, VReg obj)
 
 void PandaGen::GetUnmappedArgs(const ir::AstNode *node)
 {
-    sa_.Emit<Getunmappedargs>(node);
+    ra_.Emit<Getunmappedargs>(node);
 }
 
 void PandaGen::Negate(const ir::AstNode *node)
@@ -1327,13 +1329,13 @@ void PandaGen::Negate(const ir::AstNode *node)
 void PandaGen::ToNumber(const ir::AstNode *node, VReg arg)
 {
     LoadAccumulator(node, arg);
-    sa_.Emit<Tonumber>(node, 0);
+    ra_.Emit<Tonumber>(node, 0);
 }
 
 void PandaGen::ToNumeric(const ir::AstNode *node, VReg arg)
 {
     LoadAccumulator(node, arg);
-    sa_.Emit<Tonumeric>(node, 0);
+    ra_.Emit<Tonumeric>(node, 0);
 }
 
 void PandaGen::CreateGeneratorObj(const ir::AstNode *node, VReg funcObj)
@@ -1383,18 +1385,18 @@ void PandaGen::GeneratorComplete(const ir::AstNode *node, VReg genObj)
 void PandaGen::ResumeGenerator(const ir::AstNode *node, VReg genObj)
 {
     LoadAccumulator(node, genObj);
-    sa_.Emit<Resumegenerator>(node);
+    ra_.Emit<Resumegenerator>(node);
 }
 
 void PandaGen::GetResumeMode(const ir::AstNode *node, VReg genObj)
 {
     LoadAccumulator(node, genObj);
-    sa_.Emit<Getresumemode>(node);
+    ra_.Emit<Getresumemode>(node);
 }
 
 void PandaGen::AsyncFunctionEnter(const ir::AstNode *node)
 {
-    sa_.Emit<Asyncfunctionenter>(node);
+    ra_.Emit<Asyncfunctionenter>(node);
 }
 
 void PandaGen::AsyncFunctionAwait(const ir::AstNode *node, VReg asyncFuncObj)
@@ -1425,17 +1427,17 @@ void PandaGen::AsyncGeneratorReject(const ir::AstNode *node, VReg asyncGenObj)
 void PandaGen::GetTemplateObject(const ir::AstNode *node, VReg value)
 {
     LoadAccumulator(node, value);
-    sa_.Emit<Gettemplateobject>(node, 0);
+    ra_.Emit<Gettemplateobject>(node, 0);
 }
 
 void PandaGen::CopyRestArgs(const ir::AstNode *node, uint32_t index)
 {
-    index <= util::Helpers::MAX_INT8 ? sa_.Emit<Copyrestargs>(node, index) : sa_.Emit<WideCopyrestargs>(node, index);
+    index <= util::Helpers::MAX_INT8 ? ra_.Emit<Copyrestargs>(node, index) : ra_.Emit<WideCopyrestargs>(node, index);
 }
 
 void PandaGen::GetPropIterator(const ir::AstNode *node)
 {
-    sa_.Emit<Getpropiterator>(node);
+    ra_.Emit<Getpropiterator>(node);
 }
 
 void PandaGen::GetNextPropName(const ir::AstNode *node, VReg iter)
@@ -1445,7 +1447,7 @@ void PandaGen::GetNextPropName(const ir::AstNode *node, VReg iter)
 
 void PandaGen::CreateEmptyObject(const ir::AstNode *node)
 {
-    sa_.Emit<Createemptyobject>(node);
+    ra_.Emit<Createemptyobject>(node);
 }
 
 void PandaGen::CreateObjectWithBuffer(const ir::AstNode *node, uint32_t idx)
@@ -1453,7 +1455,7 @@ void PandaGen::CreateObjectWithBuffer(const ir::AstNode *node, uint32_t idx)
     ASSERT(util::Helpers::IsInteger<uint32_t>(idx));
     std::string idxStr = std::string(context_->Binder()->Program()->RecordName()) + "_" + std::to_string(idx);
     util::UString litId(idxStr, allocator_);
-    sa_.Emit<Createobjectwithbuffer>(node, 0, litId.View());
+    ra_.Emit<Createobjectwithbuffer>(node, 0, litId.View());
 }
 
 void PandaGen::SetObjectWithProto(const ir::AstNode *node, VReg proto, VReg obj)
@@ -1476,7 +1478,7 @@ void PandaGen::DefineGetterSetterByValue(const ir::AstNode *node, VReg obj, VReg
 
 void PandaGen::CreateEmptyArray(const ir::AstNode *node)
 {
-    sa_.Emit<Createemptyarray>(node, 0);
+    ra_.Emit<Createemptyarray>(node, 0);
 }
 
 void PandaGen::CreateArrayWithBuffer(const ir::AstNode *node, uint32_t idx)
@@ -1484,7 +1486,7 @@ void PandaGen::CreateArrayWithBuffer(const ir::AstNode *node, uint32_t idx)
     ASSERT(util::Helpers::IsInteger<uint32_t>(idx));
     std::string idxStr = std::string(context_->Binder()->Program()->RecordName()) + "_" + std::to_string(idx);
     util::UString litId(idxStr, allocator_);
-    sa_.Emit<Createarraywithbuffer>(node, 0, litId.View());
+    ra_.Emit<Createarraywithbuffer>(node, 0, litId.View());
 }
 
 void PandaGen::CreateArray(const ir::AstNode *node, const ArenaVector<ir::Expression *> &elements, VReg obj)
@@ -1595,19 +1597,19 @@ void PandaGen::ThrowIfNotObject(const ir::AstNode *node, VReg obj)
 
 void PandaGen::ThrowThrowNotExist(const ir::AstNode *node)
 {
-    sa_.Emit<ThrowNotexists>(node);
+    ra_.Emit<ThrowNotexists>(node);
 }
 
 void PandaGen::GetIterator(const ir::AstNode *node)
 {
-    sa_.Emit<Getiterator>(node, 0);
+    ra_.Emit<Getiterator>(node, 0);
 }
 
 void PandaGen::GetAsyncIterator(const ir::AstNode *node)
 {
     /*
      *  TODO: async iterator
-     *  sa_.Emit<EcmaGetasynciterator>(node);
+     *  ra_.Emit<EcmaGetasynciterator>(node);
      */
 }
 
@@ -1622,18 +1624,16 @@ void PandaGen::CreateObjectWithExcludedKeys(const ir::AstNode *node, VReg obj, V
     size_t argRegCnt = (argCount == 0 ? argCount : argCount - 1);
 
     if (argRegCnt <= util::Helpers::MAX_INT8) {
-        rra_.Emit<Createobjectwithexcludedkeys>(node, argStart, argCount, static_cast<int64_t>(argRegCnt),
-                                                    obj, argStart);
+        ra_.EmitRange<Createobjectwithexcludedkeys>(node, argCount, static_cast<int64_t>(argRegCnt), obj, argStart);
         return;
     }
 
-    rra_.Emit<WideCreateobjectwithexcludedkeys>(node, argStart, argCount, static_cast<int64_t>(argRegCnt),
-                                                obj, argStart);
+    ra_.EmitRange<WideCreateobjectwithexcludedkeys>(node, argCount, static_cast<int64_t>(argRegCnt), obj, argStart);
 }
 
 void PandaGen::ThrowObjectNonCoercible(const ir::AstNode *node)
 {
-    sa_.Emit<ThrowPatternnoncoercible>(node);
+    ra_.Emit<ThrowPatternnoncoercible>(node);
 }
 
 void PandaGen::CloseIterator(const ir::AstNode *node, VReg iter)
@@ -1653,28 +1653,28 @@ void PandaGen::DefineClassWithBuffer(const ir::AstNode *node, const util::String
 void PandaGen::LoadLocalModuleVariable(const ir::AstNode *node, const binder::ModuleVariable *variable)
 {
     auto index = variable->Index();
-    index <= util::Helpers::MAX_INT8 ? sa_.Emit<Ldlocalmodulevar>(node, index) :
-                                       sa_.Emit<WideLdlocalmodulevar>(node, index);
+    index <= util::Helpers::MAX_INT8 ? ra_.Emit<Ldlocalmodulevar>(node, index) :
+                                       ra_.Emit<WideLdlocalmodulevar>(node, index);
 }
 
 void PandaGen::LoadExternalModuleVariable(const ir::AstNode *node, const binder::ModuleVariable *variable)
 {
     auto index = variable->Index();
-    index <= util::Helpers::MAX_INT8 ? sa_.Emit<Ldexternalmodulevar>(node, index) :
-                                       sa_.Emit<WideLdexternalmodulevar>(node, index);
+    index <= util::Helpers::MAX_INT8 ? ra_.Emit<Ldexternalmodulevar>(node, index) :
+                                       ra_.Emit<WideLdexternalmodulevar>(node, index);
 }
 
 void PandaGen::StoreModuleVariable(const ir::AstNode *node, const binder::ModuleVariable *variable)
 {
     auto index = variable->Index();
-    index <= util::Helpers::MAX_INT8 ? sa_.Emit<Stmodulevar>(node, index) :
-                                       sa_.Emit<WideStmodulevar>(node, index);
+    index <= util::Helpers::MAX_INT8 ? ra_.Emit<Stmodulevar>(node, index) :
+                                       ra_.Emit<WideStmodulevar>(node, index);
 }
 
 void PandaGen::GetModuleNamespace(const ir::AstNode *node, uint32_t index)
 {
-    index <= util::Helpers::MAX_INT8 ? sa_.Emit<Getmodulenamespace>(node, index) :
-                                       sa_.Emit<WideGetmodulenamespace>(node, index);
+    index <= util::Helpers::MAX_INT8 ? ra_.Emit<Getmodulenamespace>(node, index) :
+                                       ra_.Emit<WideGetmodulenamespace>(node, index);
 }
 
 void PandaGen::DynamicImportCall(const ir::AstNode *node)
@@ -1691,7 +1691,7 @@ void PandaGen::StSuperByName(const ir::AstNode *node, VReg obj, const util::Stri
 void PandaGen::LdSuperByName(const ir::AstNode *node, VReg obj, const util::StringView &key)
 {
     LoadAccumulator(node, obj); // object is load to acc
-    sa_.Emit<Ldsuperbyname>(node, 0, key);
+    ra_.Emit<Ldsuperbyname>(node, 0, key);
     strings_.insert(key);
 }
 
@@ -1751,27 +1751,27 @@ void PandaGen::LoadSuperProperty(const ir::AstNode *node, VReg obj, const Operan
 void PandaGen::LoadLexicalVar(const ir::AstNode *node, uint32_t level, uint32_t slot)
 {
     if ((level > util::Helpers::MAX_INT8) || (slot > util::Helpers::MAX_INT8)) {
-        sa_.Emit<WideLdlexvar>(node, level, slot);
+        ra_.Emit<WideLdlexvar>(node, level, slot);
         return;
     }
 
-    sa_.Emit<Ldlexvar>(node, level, slot);
+    ra_.Emit<Ldlexvar>(node, level, slot);
 }
 
 void PandaGen::LoadLexicalVar(const ir::AstNode *node, uint32_t level, uint32_t slot, const util::StringView &name)
 {
     if (context_->HotfixHelper() && context_->HotfixHelper()->IsPatchVar(slot)) {
         uint32_t patchSlot = context_->HotfixHelper()->GetPatchLexicalIdx(std::string(name));
-        sa_.Emit<WideLdpatchvar>(node, patchSlot);
+        ra_.Emit<WideLdpatchvar>(node, patchSlot);
         return;
     }
 
     if ((level > util::Helpers::MAX_INT8) || (slot > util::Helpers::MAX_INT8)) {
-        sa_.Emit<WideLdlexvar>(node, level, slot);
+        ra_.Emit<WideLdlexvar>(node, level, slot);
         return;
     }
 
-    sa_.Emit<Ldlexvar>(node, level, slot);
+    ra_.Emit<Ldlexvar>(node, level, slot);
 }
 
 void PandaGen::StoreLexicalVar(const ir::AstNode *node, uint32_t level, uint32_t slot)
@@ -1799,7 +1799,7 @@ void PandaGen::StoreLexicalVar(const ir::AstNode *node, uint32_t level, uint32_t
 {
     if (context_->HotfixHelper() && context_->HotfixHelper()->IsPatchVar(slot)) {
         uint32_t patchSlot = context_->HotfixHelper()->GetPatchLexicalIdx(std::string(name));
-        sa_.Emit<WideStpatchvar>(node, patchSlot);
+        ra_.Emit<WideStpatchvar>(node, patchSlot);
         return;
     }
     RegScope rs(this);
@@ -1810,7 +1810,7 @@ void PandaGen::StoreLexicalVar(const ir::AstNode *node, uint32_t level, uint32_t
 
 void PandaGen::ThrowIfSuperNotCorrectCall(const ir::AstNode *node, int64_t num)
 {
-    sa_.Emit<ThrowIfsupernotcorrectcall>(node, num);
+    ra_.Emit<ThrowIfsupernotcorrectcall>(node, num);
 }
 
 void PandaGen::ThrowUndefinedIfHole(const ir::AstNode *node, const util::StringView &name)
@@ -1838,14 +1838,14 @@ void PandaGen::ThrowConstAssignment(const ir::AstNode *node, const util::StringV
 
 void PandaGen::PopLexEnv(const ir::AstNode *node)
 {
-    sa_.Emit<Poplexenv>(node);
+    ra_.Emit<Poplexenv>(node);
 }
 
 void PandaGen::CopyLexEnv(const ir::AstNode *node)
 {
     /*
      *  TODO: add copy lexenv to optimize the loop env creation
-     *  sa_.Emit<EcmaCopylexenvdyn>(node);
+     *  ra_.Emit<EcmaCopylexenvdyn>(node);
      */
 }
 
@@ -1862,15 +1862,15 @@ void PandaGen::NewLexicalEnv(const ir::AstNode *node, uint32_t num, binder::Vari
 
 void PandaGen::NewLexEnv(const ir::AstNode *node, uint32_t num)
 {
-    num <= util::Helpers::MAX_INT8 ? sa_.Emit<Newlexenv>(node, num) : sa_.Emit<WideNewlexenv>(node, num);
+    num <= util::Helpers::MAX_INT8 ? ra_.Emit<Newlexenv>(node, num) : ra_.Emit<WideNewlexenv>(node, num);
 }
 
 void PandaGen::NewLexEnvWithScopeInfo(const ir::AstNode *node, uint32_t num, int32_t scopeInfoIdx)
 {
     std::string idxStr = std::string(context_->Binder()->Program()->RecordName()) + "_" + std::to_string(scopeInfoIdx);
     util::UString litId(idxStr, allocator_);
-    num <= util::Helpers::MAX_INT8 ? sa_.Emit<Newlexenvwithname>(node, num, litId.View()) :
-                                     sa_.Emit<WideNewlexenvwithname>(node, num, litId.View());
+    num <= util::Helpers::MAX_INT8 ? ra_.Emit<Newlexenvwithname>(node, num, litId.View()) :
+                                     ra_.Emit<WideNewlexenvwithname>(node, num, litId.View());
 }
 
 uint32_t PandaGen::TryDepth() const
@@ -1990,13 +1990,13 @@ VReg PandaGen::LoadPropertyKey(const ir::Expression *prop, bool isComputed)
 
 void PandaGen::StLetOrClassToGlobalRecord(const ir::AstNode *node, const util::StringView &name)
 {
-    sa_.Emit<Sttoglobalrecord>(node, 0, name);
+    ra_.Emit<Sttoglobalrecord>(node, 0, name);
     strings_.insert(name);
 }
 
 void PandaGen::StConstToGlobalRecord(const ir::AstNode *node, const util::StringView &name)
 {
-    sa_.Emit<Stconsttoglobalrecord>(node, 0, name);
+    ra_.Emit<Stconsttoglobalrecord>(node, 0, name);
     strings_.insert(name);
 }
 
diff --git a/es2panda/compiler/core/pandagen.h b/es2panda/compiler/core/pandagen.h
index 02f17f126c..4e85174c87 100644
--- a/es2panda/compiler/core/pandagen.h
+++ b/es2panda/compiler/core/pandagen.h
@@ -89,9 +89,7 @@ public:
           catchList_(allocator_->Adapter()),
           strings_(allocator_->Adapter()),
           buffStorage_(allocator_->Adapter()),
-          sa_(this),
-          ra_(this),
-          rra_(this)
+          ra_(this)
     {
     }
     ~PandaGen() = default;
@@ -143,6 +141,11 @@ public:
         return insns_;
     }
 
+    void SetInsns(ArenaList<IRNode *> newInsns)
+    {
+        insns_ = newInsns;
+    }
+
     ArenaMap<const IRNode *, int64_t> &TypedInsns()
     {
         return typedInsns_;
@@ -205,9 +208,12 @@ public:
 
     void SetSourceLocationFlag(lexer::SourceLocationFlag flag)
     {
-        sa_.SetSourceLocationFlag(flag);
         ra_.SetSourceLocationFlag(flag);
-        rra_.SetSourceLocationFlag(flag);
+    }
+
+    void AdjustSpillInsns()
+    {
+        ra_.AdjustInsRegWhenHasSpill();
     }
 
     panda::panda_file::FunctionKind GetFunctionKind() const
@@ -480,9 +486,7 @@ private:
     DynamicContext *dynamicContext_ {};
     OptionalChain *optionalChain_ {};
     InlineCache ic_;
-    SimpleAllocator sa_;
     RegAllocator ra_;
-    RangeRegAllocator rra_;
     IcSizeType currentSlot_ {0};
 
     uint32_t usedRegs_ {0};
diff --git a/es2panda/compiler/core/regAllocator.cpp b/es2panda/compiler/core/regAllocator.cpp
index 88613e85bd..79410e310c 100644
--- a/es2panda/compiler/core/regAllocator.cpp
+++ b/es2panda/compiler/core/regAllocator.cpp
@@ -21,168 +21,187 @@
 
 namespace panda::es2panda::compiler {
 
-// AllocatorBase
+// FrontAllocator
 
-void AllocatorBase::PushBack(IRNode *ins)
+FrontAllocator::FrontAllocator(PandaGen *pg)
+    : pg_(pg), insn_(std::move(pg_->Insns()), pg_->Allocator()->Adapter())
 {
-    pg_->Insns().push_back(ins);
 }
 
-ArenaAllocator *AllocatorBase::Allocator() const
+FrontAllocator::~FrontAllocator()
 {
-    return pg_->Allocator();
+    pg_->Insns().splice(pg_->Insns().end(), std::move(insn_));
 }
 
-void AllocatorBase::UpdateIcSlot(IRNode *node)
+// RegAllocator
+
+void RegAllocator::PushBack(IRNode *ins)
 {
-    auto inc = node->SetIcSlot(pg_->GetCurrentSlot());
-    pg_->IncreaseCurrentSlot(inc);
+    pg_->Insns().push_back(ins);
 }
 
-void SimpleAllocator::Run(IRNode *ins, int64_t typeIndex)
+ArenaAllocator *RegAllocator::Allocator() const
 {
-    PushBack(ins);
-    pg_->TypedInsns()[ins] = typeIndex;
+    return pg_->Allocator();
 }
 
-// FrontAllocator
-
-FrontAllocator::FrontAllocator(PandaGen *pg)
-    : AllocatorBase(pg), insn_(std::move(pg_->Insns()), pg_->Allocator()->Adapter())
+uint16_t RegAllocator::GetSpillRegsCount() const
 {
+    return spillRegs_;
 }
 
-FrontAllocator::~FrontAllocator()
+void RegAllocator::UpdateIcSlot(IRNode *node)
 {
-    pg_->Insns().splice(pg_->Insns().end(), std::move(insn_));
+    auto inc = node->SetIcSlot(pg_->GetCurrentSlot());
+    pg_->IncreaseCurrentSlot(inc);
 }
 
-// SimpleAllocator
-Label *SimpleAllocator::AllocLabel(std::string &&id)
+Label *RegAllocator::AllocLabel(std::string &&id)
 {
     const auto *lastInsNode = pg_->Insns().empty() ? FIRST_NODE_OF_FUNCTION : pg_->Insns().back()->Node();
     return Alloc<Label>(lastInsNode, std::move(id));
 }
 
-// RegAllocatorBase
-
-VReg RegAllocatorBase::Spill(IRNode *ins, VReg reg)
+void RegAllocator::Run(IRNode *ins, int64_t typeIndex)
 {
-    VReg spillReg = pg_->AllocReg();
-    VReg origin = spillIndex_++;
-    spillMap_.emplace(origin, reg);
-
-    Add<Mov>(ins->Node(), spillReg, origin);
-    Add<Mov>(ins->Node(), origin, reg);
-
-    return origin;
+    Run(ins);
+    pg_->TypedInsns()[ins] = typeIndex;
 }
 
-void RegAllocatorBase::Restore(IRNode *ins)
+void RegAllocator::Run(IRNode *ins)
 {
-    spillIndex_--;
-    VReg spillReg = spillIndex_;
-    VReg origin = regEnd_ + spillIndex_;
-    VReg actualReg = spillMap_[spillReg];
+    std::array<VReg *, IRNode::MAX_REG_OPERAND> regs {};
+    auto regCnt = ins->Registers(&regs);
 
-    Add<Mov>(ins->Node(), actualReg, spillReg);
-    Add<Mov>(ins->Node(), spillReg, origin);
-}
+    if (regCnt == 0) {
+        return PushBack(ins);
+    }
 
-void RegAllocatorBase::ClearSpillMap()
-{
-    spillMap_.clear();
-}
+    auto registers = Span<VReg *>(regs.data(), regs.data() + regCnt);
+    spillRegs_ = std::max(spillRegs_, static_cast<uint16_t>(regCnt));
 
-// RegAllocator
+    if (!CheckRegIndices(ins, registers)) {
+        hasSpill_ = true;
+    }
 
-void RegAllocator::Run(IRNode *ins)
+    PushBack(ins);
+}
+
+void RegAllocator::Run(IRNode *ins, size_t argCount)
 {
-    ASSERT(spillIndex_ == 0);
     std::array<VReg *, IRNode::MAX_REG_OPERAND> regs {};
     auto regCnt = ins->Registers(&regs);
+    ASSERT(regCnt != 0);
     auto registers = Span<VReg *>(regs.data(), regs.data() + regCnt);
+    spillRegs_ = std::max(spillRegs_, static_cast<uint16_t>(argCount + regCnt - 1));
 
-    if (CheckRegIndices(ins, registers)) {
-        PushBack(ins);
-        return;
+    if (!CheckRegIndices(ins, registers)) {
+        hasSpill_ = true;
     }
 
-    RegScope regScope(pg_);
+    PushBack(ins);
+}
+
+void RegAllocator::AdjustInsRegWhenHasSpill()
+{
+    if (!hasSpill_) {
+        spillRegs_ = 0;
+        return;
+    }
 
-    regEnd_ = pg_->NextReg();
+    ArenaList<IRNode *> newInsns(Allocator()->Adapter());
+    auto &insns = pg_->Insns();
+    for (auto it = insns.begin(); it != insns.end(); ++it) {
+        IRNode *ins = *it;
+        std::vector<OperandKind> regsKind;
+        std::array<VReg *, IRNode::MAX_REG_OPERAND> regs {};
+        auto regCnt = ins->Registers(&regs);
 
-    for (auto *reg : registers) {
-        if (IsRegisterCorrect(reg)) {
+        if (regCnt == 0) {
+            newInsns.push_back(ins);
             continue;
         }
 
-        const auto actualReg = *reg;
-        *reg = Spill(ins, actualReg);
-    }
-
-    PushBack(ins);
+        auto registers = Span<VReg *>(regs.data(), regs.data() + regCnt);
+        for (auto *reg : registers) {
+            *reg = *reg + spillRegs_;
+        }
 
-    while (spillIndex_ != 0) {
-        Restore(ins);
-    }
+        if (CheckRegIndices(ins, registers, &regsKind)) {
+            // current ins has no spill, continue iterating
+            newInsns.push_back(ins);
+            continue;
+        }
 
-    ClearSpillMap();
-}
+        // current ins has spill
+        if (ins->IsRangeInst()) {
+            AdjustRangeInsSpill(registers, ins, newInsns);
+            continue;
+        }
 
-void RegAllocator::Run(IRNode *ins, int64_t typeIndex)
-{
-    Run(ins);
-    pg_->TypedInsns()[ins] = typeIndex;
+        AdjustInsSpill(registers, ins, newInsns, regsKind);
+    }
+    pg_->SetInsns(newInsns);
 }
 
-// RangeRegAllocator
-
-void RangeRegAllocator::Run(IRNode *ins, VReg rangeStart, size_t argCount)
+void RegAllocator::AdjustInsSpill(Span<VReg *> &registers, IRNode *ins, ArenaList<IRNode *> &newInsns,
+                                  std::vector<OperandKind> &regsKind)
 {
     ASSERT(spillIndex_ == 0);
-    const auto rangeEnd = rangeStart + argCount;
-
-    std::array<VReg *, IRNode::MAX_REG_OPERAND> regs {};
-    auto regCnt = ins->Registers(&regs);
-    auto registers = Span<VReg *>(regs.data(), regs.data() + regCnt);
+    ASSERT(!regsKind.empty());
+    int idx = 0;
+    for (auto *reg : registers) {
+        if (IsRegisterCorrect(reg)) {
+            idx++;
+            continue;
+        }
 
-    if (CheckRegIndices(ins, registers)) {
-        PushBack(ins);
-        return;
+        const auto originReg = *reg;
+        VReg spillReg = spillIndex_;
+        if (regsKind[idx] == OperandKind::SRC_VREG || regsKind[idx] == OperandKind::SRC_DST_VREG) {
+            Add<Mov>(newInsns, ins->Node(), spillReg, originReg);
+        } else {
+            dstRegSpills_.push_back(std::make_pair(originReg, spillReg));
+        }
+        *reg = spillIndex_++;
+        idx++;
     }
 
-    RegScope regScope(pg_);
+    newInsns.push_back(ins);
 
-    regEnd_ = pg_->NextReg();
+    for (auto spillPair : dstRegSpills_) {
+        Add<Mov>(newInsns, ins->Node(), spillPair.first, spillPair.second);
+    }
 
-    auto *iter = registers.begin();
-    auto *iterEnd = iter + registers.size() - 1;
+    FreeSpill();
+    dstRegSpills_.clear();
+}
 
-    while (iter != iterEnd) {
+void RegAllocator::AdjustRangeInsSpill(Span<VReg *> &registers, IRNode *ins, ArenaList<IRNode *> &newInsns)
+{
+    ASSERT(spillIndex_ == 0);
+    ASSERT(ins->IsRangeInst());
+    auto rangeRegCount = ins->RangeRegsCount();
+    auto *iter = registers.begin();
+    auto *rangeStartIter = iter + registers.size() - 1;
+    
+    while (iter != rangeStartIter) {
         VReg *reg = *iter;
-
-        const auto actualReg = *reg;
-        *reg = Spill(ins, actualReg);
+        Add<Mov>(newInsns, ins->Node(), spillIndex_, *reg);
+        *reg = spillIndex_++;
         iter++;
     }
 
-    VReg *regStartReg = *iter;
-    VReg reg = rangeStart++;
-    *regStartReg = Spill(ins, reg);
-
-    while (rangeStart != rangeEnd) {
-        reg = rangeStart++;
-        Spill(ins, reg);
-    }
-
-    PushBack(ins);
+    VReg *rangeStartReg = *rangeStartIter;
+    auto originReg = *rangeStartReg;
+    *rangeStartReg = spillIndex_;
 
-    while (spillIndex_ != 0) {
-        Restore(ins);
+    while (rangeRegCount--) {
+        Add<Mov>(newInsns, ins->Node(), spillIndex_++, originReg++);
     }
 
-    ClearSpillMap();
+    newInsns.push_back(ins);
+    FreeSpill();
 }
 
 }  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/core/regAllocator.h b/es2panda/compiler/core/regAllocator.h
index bd1bb17fa8..202d43a126 100644
--- a/es2panda/compiler/core/regAllocator.h
+++ b/es2panda/compiler/core/regAllocator.h
@@ -28,15 +28,15 @@ namespace panda::es2panda::compiler {
 
 class PandaGen;
 
-class AllocatorBase {
+class RegAllocator {
 public:
-    explicit AllocatorBase(PandaGen *pg)
+    explicit RegAllocator(PandaGen *pg)
         : pg_(pg), sourceLocationFlag_(lexer::SourceLocationFlag::VALID_SOURCE_LOCATION)
     {
     }
-    NO_COPY_SEMANTIC(AllocatorBase);
-    NO_MOVE_SEMANTIC(AllocatorBase);
-    ~AllocatorBase() = default;
+    NO_COPY_SEMANTIC(RegAllocator);
+    NO_MOVE_SEMANTIC(RegAllocator);
+    ~RegAllocator() = default;
 
     void SetSourceLocationFlag(lexer::SourceLocationFlag flag)
     {
@@ -48,38 +48,10 @@ public:
         return sourceLocationFlag_;
     }
 
-protected:
-    void PushBack(IRNode *ins);
     ArenaAllocator *Allocator() const;
-
-    template <typename T, typename... Args>
-    T *Alloc(const ir::AstNode *node, Args &&... args)
-    {
-        ir::AstNode *invalidNode = nullptr;
-        bool isInvalid = GetSourceLocationFlag() == lexer::SourceLocationFlag::INVALID_SOURCE_LOCATION;
-        auto *ret = Allocator()->New<T>(isInvalid ? invalidNode : node, std::forward<Args>(args)...);
-        UpdateIcSlot(ret);
-        return ret;
-    }
-
-    void UpdateIcSlot(IRNode *node);
-
-    template <typename T, typename... Args>
-    void Add(const ir::AstNode *node, Args &&... args)
-    {
-        return PushBack(Alloc<T>(node, std::forward<Args>(args)...));
-    }
-
-    PandaGen *pg_;
-    lexer::SourceLocationFlag sourceLocationFlag_; // for instructions that need to be set with invalid debuginfo
-};
-
-class SimpleAllocator : public AllocatorBase {
-public:
-    explicit SimpleAllocator(PandaGen *pg) : AllocatorBase(pg) {};
-    NO_COPY_SEMANTIC(SimpleAllocator);
-    NO_MOVE_SEMANTIC(SimpleAllocator);
-    ~SimpleAllocator() = default;
+    uint16_t GetSpillRegsCount() const;
+    
+    void AdjustInsRegWhenHasSpill();
 
     Label *AllocLabel(std::string &&id);
     void AddLabel(Label *label)
@@ -90,7 +62,8 @@ public:
     template <typename T, typename... Args>
     void Emit(const ir::AstNode *node, Args &&... args)
     {
-        Add<T>(node, std::forward<Args>(args)...);
+        auto *ins = Alloc<T>(node, std::forward<Args>(args)...);
+        Run(ins);
     }
 
     template <typename T, typename... Args>
@@ -100,36 +73,26 @@ public:
         Run(ins, typeIndex);
     }
 
-private:
-    void Run(IRNode *ins, int64_t typeIndex);
-};
-
-class FrontAllocator : public AllocatorBase {
-public:
-    explicit FrontAllocator(PandaGen *pg);
-    NO_COPY_SEMANTIC(FrontAllocator);
-    NO_MOVE_SEMANTIC(FrontAllocator);
-    ~FrontAllocator();
+    template <typename T, typename... Args>
+    void EmitRange(const ir::AstNode *node, size_t argCount, Args &&... args)
+    {
+        auto *ins = Alloc<T>(node, std::forward<Args>(args)...);
+        Run(ins, argCount);
+    }
 
 private:
-    ArenaList<IRNode *> insn_;
-};
-
-class RegAllocatorBase : public AllocatorBase {
-public:
-    explicit RegAllocatorBase(PandaGen *pg) : AllocatorBase(pg) {}
-    NO_COPY_SEMANTIC(RegAllocatorBase);
-    NO_MOVE_SEMANTIC(RegAllocatorBase);
-    ~RegAllocatorBase() = default;
-
-protected:
-    inline bool CheckRegIndices(IRNode *ins, const Span<VReg *> &registers)
+    bool CheckRegIndices(IRNode *ins, const Span<VReg *> &registers,
+                         std::vector<OperandKind> *regsKind = nullptr)
     {
         Formats formats = ins->GetFormats();
         limit_ = 0;
 
         for (const auto &format : formats) {
             for (const auto &formatItem : format.GetFormatItem()) {
+                if (regsKind && formatItem.IsVReg()) {
+                    regsKind->push_back(formatItem.Kind());
+                }
+
                 if (formatItem.IsVReg()) {
                     limit_ = 1 << formatItem.Bitwidth();
                     break;
@@ -149,58 +112,55 @@ protected:
         return *reg < limit_;
     }
 
-    VReg Spill(IRNode *ins, VReg reg);
-    void Restore(IRNode *ins);
-    void ClearSpillMap();
-
-    VReg spillIndex_ {0};
-    VReg regEnd_ {0};
-    size_t limit_ {0};
-    std::unordered_map<VReg, VReg> spillMap_ {};
-};
+    inline void FreeSpill()
+    {
+        spillIndex_ = 0;
+    }
 
-class RegAllocator : public RegAllocatorBase {
-public:
-    explicit RegAllocator(PandaGen *pg) : RegAllocatorBase(pg) {}
-    NO_COPY_SEMANTIC(RegAllocator);
-    NO_MOVE_SEMANTIC(RegAllocator);
-    ~RegAllocator() = default;
+    void PushBack(IRNode *ins);
+    void UpdateIcSlot(IRNode *node);
+    void Run(IRNode *ins);
+    void Run(IRNode *ins, size_t argCount);
+    void Run(IRNode *ins, int64_t typeIndex);
+    void AdjustInsSpill(Span<VReg *> &registers, IRNode *ins, ArenaList<IRNode *> &newInsns,
+                        std::vector<OperandKind> &regsKind);
+    void AdjustRangeInsSpill(Span<VReg *> &registers, IRNode *ins, ArenaList<IRNode *> &newInsns);
 
     template <typename T, typename... Args>
-    void Emit(const ir::AstNode *node, Args &&... args)
+    T *Alloc(const ir::AstNode *node, Args &&... args)
     {
-        auto *ins = Alloc<T>(node, std::forward<Args>(args)...);
-        Run(ins);
+        ir::AstNode *invalidNode = nullptr;
+        bool isInvalid = GetSourceLocationFlag() == lexer::SourceLocationFlag::INVALID_SOURCE_LOCATION;
+        auto *ret = Allocator()->New<T>(isInvalid ? invalidNode : node, std::forward<Args>(args)...);
+        UpdateIcSlot(ret);
+        return ret;
     }
 
     template <typename T, typename... Args>
-    void EmitWithType(const ir::AstNode *node, int64_t typeIndex, Args &&... args)
+    void Add(ArenaList<IRNode *> &insns, const ir::AstNode *node, Args &&... args)
     {
-        auto *ins = Alloc<T>(node, std::forward<Args>(args)...);
-        Run(ins, typeIndex);
+        insns.push_back(Alloc<T>(node, std::forward<Args>(args)...));
     }
 
-private:
-    void Run(IRNode *ins);
-    void Run(IRNode *ins, int64_t typeIndex);
+    PandaGen *pg_;
+    lexer::SourceLocationFlag sourceLocationFlag_; // for instructions that need to be set with invalid debuginfo
+    size_t limit_ {0};
+    uint16_t spillRegs_ {0};
+    VReg spillIndex_ {0};
+    bool hasSpill_ {false};
+    std::vector<std::pair<VReg, VReg>> dstRegSpills_ {};
 };
 
-class RangeRegAllocator : public RegAllocatorBase {
+class FrontAllocator {
 public:
-    explicit RangeRegAllocator(PandaGen *pg) : RegAllocatorBase(pg) {}
-    NO_COPY_SEMANTIC(RangeRegAllocator);
-    NO_MOVE_SEMANTIC(RangeRegAllocator);
-    ~RangeRegAllocator() = default;
-
-    template <typename T, typename... Args>
-    void Emit(const ir::AstNode *node, VReg rangeStart, size_t argCount, Args &&... args)
-    {
-        auto *ins = Alloc<T>(node, std::forward<Args>(args)...);
-        Run(ins, rangeStart, argCount);
-    }
+    explicit FrontAllocator(PandaGen *pg);
+    NO_COPY_SEMANTIC(FrontAllocator);
+    NO_MOVE_SEMANTIC(FrontAllocator);
+    ~FrontAllocator();
 
 private:
-    void Run(IRNode *ins, VReg rangeStart, size_t argCount);
+    PandaGen *pg_;
+    ArenaList<IRNode *> insn_;
 };
 }  // namespace panda::es2panda::compiler
 
diff --git a/es2panda/compiler/templates/isa.h.erb b/es2panda/compiler/templates/isa.h.erb
index a6e0ab0d66..eebe2f391f 100644
--- a/es2panda/compiler/templates/isa.h.erb
+++ b/es2panda/compiler/templates/isa.h.erb
@@ -78,7 +78,19 @@ private:
 %   return mnemonic.map{|el| el == '64' ? 'Wide' : el.capitalize}.join()
 % end
 %
-% def is_VReg (name)
+% def is_Range(insn)
+%   if insn.mnemonic == "callrange" or insn.mnemonic == "wide.callrange" or
+%       insn.mnemonic == "callthisrange" or insn.mnemonic == "wide.callthisrange" or
+%       insn.mnemonic == "newobjrange" or insn.mnemonic == "wide.newobjrange" or
+%       insn.mnemonic == "createobjectwithexcludedkeys" or insn.mnemonic == "wide.createobjectwithexcludedkeys" or
+%       insn.mnemonic == "supercallthisrange" or insn.mnemonic == "wide.supercallthisrange" or
+%       insn.mnemonic == "supercallarrowrange" or insn.mnemonic == "wide.supercallarrowrange"
+%      return true
+%   end
+%   return false
+% end
+%
+% def is_VReg(name)
 %     if name ==  :v
 %        return true
 %     end
@@ -168,6 +180,7 @@ private:
 % insn = group.first
 % node_kind = get_node_kind(mnemonic)
 % class_name = insn2node(insn)
+% is_range_op = is_Range(insn)
 % base_class = "IRNode"
 % ops_list,ctor_arg_list,op_map = get_ctor_args(insn)
 % ctor_args = "const ir::AstNode* node" + (ctor_arg_list.length == 0 ? "" : ", ") + ctor_arg_list.map {|arg| "#{arg}"}.join(", ")
@@ -274,6 +287,31 @@ public:
 % end
     }
 
+% if is_range_op
+    bool IsRangeInst() const override
+    {
+        return true;
+    }
+
+    int64_t RangeRegsCount() override
+    {
+%   if insn.mnemonic == "createobjectwithexcludedkeys" or insn.mnemonic.start_with? "wide."
+%       if insn.mnemonic == "wide.callthisrange" or insn.mnemonic == "createobjectwithexcludedkeys" or
+%           insn.mnemonic == "wide.createobjectwithexcludedkeys"
+        return <%= op_map['imm'][0] %> + 1;
+%       else
+        return <%= op_map['imm'][0] %>;
+%       end
+%   else
+%       if insn.mnemonic == "callthisrange"
+        return <%= op_map['imm'][1] %> + 1;
+%       else
+        return <%= op_map['imm'][1] %>;
+%       end
+%   end
+    }
+% end
+
 % if ops_list.length != 0
 private:
     <%= members %>
diff --git a/es2panda/ir/irnode.h b/es2panda/ir/irnode.h
index 072450c69b..d988e01f1f 100644
--- a/es2panda/ir/irnode.h
+++ b/es2panda/ir/irnode.h
@@ -123,6 +123,16 @@ public:
     virtual void Transform(panda::pandasm::Ins *ins) const = 0;
     virtual ICSlot SetIcSlot(IcSizeType currentSlot) = 0;
 
+    virtual bool IsRangeInst() const
+    {
+        return false;
+    }
+
+    virtual int64_t RangeRegsCount()
+    {
+        return 0;
+    }
+
 private:
     const ir::AstNode *node_;
 };
diff --git a/es2panda/test/compiler/js/regAllocator/test-spill-fill-with-CFG-expected.txt b/es2panda/test/compiler/js/regAllocator/test-spill-fill-with-CFG-expected.txt
new file mode 100644
index 0000000000..709edb6d43
--- /dev/null
+++ b/es2panda/test/compiler/js/regAllocator/test-spill-fill-with-CFG-expected.txt
@@ -0,0 +1 @@
+obj's a
diff --git a/es2panda/test/compiler/js/regAllocator/test-spill-fill-with-CFG.js b/es2panda/test/compiler/js/regAllocator/test-spill-fill-with-CFG.js
new file mode 100644
index 0000000000..d4afcfb6b3
--- /dev/null
+++ b/es2panda/test/compiler/js/regAllocator/test-spill-fill-with-CFG.js
@@ -0,0 +1,274 @@
+let obj = {
+    a: "obj's a",
+    xx : function xx() {
+        let a = undefined;
+        let aa = undefined;
+        let aaa = undefined;
+        let aaaa = undefined;
+        let aaaaa = undefined;
+        let aaaaaa = undefined;
+        let aaaaaaa = undefined;
+        let aaaaaaaa = undefined;
+        let b = undefined;
+        let bb = undefined;
+        let bbb = undefined;
+        let aaabab = undefined;
+        let aaaabab = undefined;
+        let aaaabaab = undefined;
+        let aaaaabaab = undefined;
+        let aaaaaabaab = undefined;
+        let ab = undefined;
+        let aba = undefined;
+        let abaa = undefined;
+        let abaaa = undefined;
+        let abaaaa = undefined;
+        let aabaaaa = undefined;
+        let aabaaaaa = undefined;
+        let aaabaaaaa = undefined;
+        let bbbbb = undefined;
+        let bbbbbb = undefined;
+        let bbbb = undefined;
+        let aaaba = undefined;
+        let aaaaba = undefined;
+        let aaaabaa = undefined;
+        let aaaaabaa = undefined;
+        let aaaaaabaa = undefined;
+        let c = undefined;
+        let ac = undefined;
+        let aac = undefined;
+        let aaac = undefined;
+        let aaaac = undefined;
+        let aaaaac = undefined;
+        let aaaaaac = undefined;
+        let aaaaaaac = undefined;
+        let aaaaaaaca = undefined;
+        let bc = undefined;
+        let bbc = undefined;
+        let bbbc = undefined;
+        let aaabcab = undefined;
+        let aaaababc = undefined;
+        let aaaabaabc = undefined;
+        let aaaaabaabc = undefined;
+        let aaaaaabaabc = undefined;
+        let abc = undefined;
+        let abca = undefined;
+        let abcaa = undefined;
+        let abacaa = undefined;
+        let abacaaa = undefined;
+        let aabaacaa = undefined;
+        let aabaacaaa = undefined;
+        let aaabcaaaaa = undefined;
+        let bbbbcb = undefined;
+        let bbbbcbb = undefined;
+        let bbbcb = undefined;
+        let aacaba = undefined;
+        let aaaabca = undefined;
+        let aaaacbaa = undefined;
+        let aaaaabcaa = undefined;
+        let aaaaacabaa = undefined;
+        let add = undefined;
+        let aadd = undefined;
+        let aaadd = undefined;
+        let aaaadd = undefined;
+        let aaaaadd = undefined;
+        let aaaaaadd = undefined;
+        let aaaaaadda = undefined;
+        let aaaaaaadda = undefined;
+        let bdd = undefined;
+        let bbdd = undefined;
+        let bbbdd = undefined;
+        let aaababdd = undefined;
+        let aaaabddab = undefined;
+        let aaaabddaab = undefined;
+        let aaaaaddbaab = undefined;
+        let aaaaaabddaab = undefined;
+        let ddab = undefined;
+        let abdda = undefined;
+        let abadda = undefined;
+        let abaddaa = undefined;
+        let abaaddaa = undefined;
+        let aabaaddaa = undefined;
+        let aabaaaddaa = undefined;
+        let aaabaaaddaa = undefined;
+        let bbbddbb = undefined;
+        let bbbddbbb = undefined;
+        let bbddbb = undefined;
+        let aaaddba = undefined;
+        let aaaddaba = undefined;
+        let aaaabaadd = undefined;
+        let aaaaabaadd = undefined;
+        let aaaaaabaadd = undefined;
+        let cdd = undefined;
+        let acdd = undefined;
+        let aacdd = undefined;
+        let aaacdd = undefined;
+        let aaaacddd = undefined;
+        let aaaaacddd = undefined;
+        let aaaaaacddd = undefined;
+        let aaaaaaacdd = undefined;
+        let aaaaaaacadd = undefined;
+        let bcdd = undefined;
+        let bbcdd = undefined;
+        let bbbcdd = undefined;
+        let aaabcabdd = undefined;
+        let aaaababcdd = undefined;
+        let aaaabaabcdd = undefined;
+        let aaaaabaabcdd = undefined;
+        let aaaaaabaabcdd = undefined;
+        let abcdd = undefined;
+        let abcdda = undefined;
+        let abcaddda = undefined;
+        let abacaddda = undefined;
+        let abacaadda = undefined;
+        let aabaacddaa = undefined;
+        let aabaacaaadd = undefined;
+        let aaabcaaaaadd = undefined;
+        let bbbbcbdd = undefined;
+        let bbbbcbbdd = undefined;
+        let bbbcbdd = undefined;
+        let aacabdda = undefined;
+        let aaaabcadd = undefined;
+        let aaaacbadda = undefined;
+        let aaaaabcaadd = undefined;
+        let aaaaacabddaa = undefined;
+        let ae = undefined;
+        let aaee = undefined;
+        let aaaee = undefined;
+        let aaaae = undefined;
+        let aaaaea = undefined;
+        let aaaaaea = undefined;
+        let aaaaaeaa = undefined;
+        let aaaaaaeaa = undefined;
+        let be = undefined;
+        let bbe = undefined;
+        let bbeb = undefined;
+        let aaabeab = undefined;
+        let aaaaebab = undefined;
+        let aaaabaeab = undefined;
+        let aaaaaebaab = undefined;
+        let aaaaaaebaab = undefined;
+        let abe = undefined;
+        let aeba = undefined;
+        let abeaa = undefined;
+        let abaeaa = undefined;
+        let abaeaaa = undefined;
+        let aabaeaaa = undefined;
+        let aabaaeaaa = undefined;
+        let aaabeaaaaa = undefined;
+        let bbbbeb = undefined;
+        let bbbbebb = undefined;
+        let bbbeb = undefined;
+        let aaaeba = undefined;
+        let aaaeaba = undefined;
+        let aaaeabaa = undefined;
+        let aaaeaabaa = undefined;
+        let aaaaeaabaa = undefined;
+        let ce = undefined;
+        let aec = undefined;
+        let aaec = undefined;
+        let aaaec = undefined;
+        let aaaeac = undefined;
+        let aaaaeac = undefined;
+        let aaaaeaac = undefined;
+        let aaaaaeaac = undefined;
+        let aaaaaeaaca = undefined;
+        let bce = undefined;
+        let bbce = undefined;
+        let bbbec = undefined;
+        let aaabceab = undefined;
+        let aaaabaebc = undefined;
+        let aaaabaeabc = undefined;
+        let aaaaabaeabc = undefined;
+        let aaaaaabeaabc = undefined;
+        let abce = undefined;
+        let abcea = undefined;
+        let abcaea = undefined;
+        let abacaea = undefined;
+        let abacaeaa = undefined;
+        let aabaeacaa = undefined;
+        let aabaaceaaa = undefined;
+        let aaabcaaeaaa = undefined;
+        let bbbbecb = undefined;
+        let bbbbcbeb = undefined;
+        let bbbceb = undefined;
+        let aacaeba = undefined;
+        let aaaaebca = undefined;
+        let aaaacbaea = undefined;
+        let aaaaabecaa = undefined;
+        let aaaaaceabaa = undefined;
+        let adde = undefined;
+        let aaded = undefined;
+        let aaaedd = undefined;
+        let aaaaedd = undefined;
+        let aaaaeadd = undefined;
+        let aaaaeaadd = undefined;
+        let aaaaaeadda = undefined;
+        let aaaaaaeadda = undefined;
+        let bded = undefined;
+        let bbedd = undefined;
+        let bbbded = undefined;
+        let aaababedd = undefined;
+        let aaaabdedab = undefined;
+        let aaaabddaeab = undefined;
+        let aaaaaeddbaab = undefined;
+        let aaaaaabeddaab = undefined;
+        let ddabe = undefined;
+        let abdeda = undefined;
+        let abadeda = undefined;
+        let abadedaa = undefined;
+        let abaaddeaa = undefined;
+        let aabaadedaa = undefined;
+        let aabaaaeddaa = undefined;
+        let aaabaaadedaa = undefined;
+        let bbbddebb = undefined;
+        let bbbddbebb = undefined;
+        let bbddebb = undefined;
+        let aaaddeba = undefined;
+        let aaaddaeba = undefined;
+        let aaaabeaadd = undefined;
+        let aaaaabaeadd = undefined;
+        let aaaaaabaeadd = undefined;
+        let cdde = undefined;
+        let acdde = undefined;
+        let aacdde = undefined;
+        let aaacdde = undefined;
+        let aaaacdded = undefined;
+        let aaaaacdded = undefined;
+        let aaaaaacdded = undefined;
+        let aaaaaaacdde = undefined;
+        let aaaaaaacadde = undefined;
+        let bcedd = undefined;
+        let bbcedd = undefined;
+        let bbbcedd = undefined;
+        let aaabceabdd = undefined;
+        let aaaabaebcdd = undefined;
+        let aaaabaaebcdd = undefined;
+        let aaaaabaaebcdd = undefined;
+        let aaaaaabaaebcdd = undefined;
+        let abcdde = undefined;
+        let abcddae = undefined;
+        let abcadddea = undefined;
+        let abacadddea = undefined;
+        let abacaaddae = undefined;
+        let aabaacddaae = undefined;
+        let aabaacaaadde = undefined;
+        let aaabcaaaaadde = undefined;
+        let bbbbcbdde = undefined;
+        let bbbbcbbdde = undefined;
+        let bbbcbdde = undefined;
+        let aacabddae = undefined;
+        let aaaabcadde = undefined;
+        let aaaacbaddae = undefined;
+        let aaaaabcaadde = undefined;
+        try {
+            let aaaaacabddaae = {a: function b(c, d) {
+                throw c + d;
+            }};
+            aaaaacabddaae.a(1, 2);
+        } catch {
+            print(this.a)
+        }
+    }
+}
+
+obj.xx();
-- 
Gitee


From a03efc62f18ea5006792125beeb303abb28a7b04 Mon Sep 17 00:00:00 2001
From: hufeng <hufeng20@huawei.com>
Date: Fri, 4 Nov 2022 11:07:25 +0800
Subject: [PATCH 2/2] throw error when the spill regs count extend maximum

Signed-off-by: hufeng <hufeng20@huawei.com>
Change-Id: Iec293c1f3964eca41ea390e3ae9412f74fc7afc8
---
 es2panda/compiler/core/pandagen.h             |   7 +-
 es2panda/compiler/core/regAllocator.cpp       |   7 +-
 ...est-range-spill-fill-with-CFG-expected.txt |   1 +
 .../test-range-spill-fill-with-CFG.js         | 274 ++++++++++++++++++
 4 files changed, 286 insertions(+), 3 deletions(-)
 create mode 100644 es2panda/test/compiler/js/regAllocator/test-range-spill-fill-with-CFG-expected.txt
 create mode 100644 es2panda/test/compiler/js/regAllocator/test-range-spill-fill-with-CFG.js

diff --git a/es2panda/compiler/core/pandagen.h b/es2panda/compiler/core/pandagen.h
index 4e85174c87..7bdf525e81 100644
--- a/es2panda/compiler/core/pandagen.h
+++ b/es2panda/compiler/core/pandagen.h
@@ -141,9 +141,9 @@ public:
         return insns_;
     }
 
-    void SetInsns(ArenaList<IRNode *> newInsns)
+    void SetInsns(ArenaList<IRNode *> &newInsns)
     {
-        insns_ = newInsns;
+        insns_.assign(newInsns.begin(), newInsns.end());
     }
 
     ArenaMap<const IRNode *, int64_t> &TypedInsns()
@@ -158,6 +158,9 @@ public:
 
     VReg AllocReg()
     {
+        if (usedRegs_ > UINT16_MAX) {
+            throw Error(ErrorType::GENERIC, "Can't alloc new reg because all regs ran out");
+        }
         return usedRegs_++;
     }
 
diff --git a/es2panda/compiler/core/regAllocator.cpp b/es2panda/compiler/core/regAllocator.cpp
index 79410e310c..c6d9ac3537 100644
--- a/es2panda/compiler/core/regAllocator.cpp
+++ b/es2panda/compiler/core/regAllocator.cpp
@@ -109,6 +109,10 @@ void RegAllocator::AdjustInsRegWhenHasSpill()
         return;
     }
 
+    if ((spillRegs_ + pg_->TotalRegsNum()) > UINT16_MAX) {
+        throw Error(ErrorType::GENERIC, "Can't adjust spill insns when regs run out");
+    }
+
     ArenaList<IRNode *> newInsns(Allocator()->Adapter());
     auto &insns = pg_->Insns();
     for (auto it = insns.begin(); it != insns.end(); ++it) {
@@ -160,7 +164,8 @@ void RegAllocator::AdjustInsSpill(Span<VReg *> &registers, IRNode *ins, ArenaLis
         VReg spillReg = spillIndex_;
         if (regsKind[idx] == OperandKind::SRC_VREG || regsKind[idx] == OperandKind::SRC_DST_VREG) {
             Add<Mov>(newInsns, ins->Node(), spillReg, originReg);
-        } else {
+        }
+        if (regsKind[idx] == OperandKind::DST_VREG || regsKind[idx] == OperandKind::SRC_DST_VREG) {
             dstRegSpills_.push_back(std::make_pair(originReg, spillReg));
         }
         *reg = spillIndex_++;
diff --git a/es2panda/test/compiler/js/regAllocator/test-range-spill-fill-with-CFG-expected.txt b/es2panda/test/compiler/js/regAllocator/test-range-spill-fill-with-CFG-expected.txt
new file mode 100644
index 0000000000..709edb6d43
--- /dev/null
+++ b/es2panda/test/compiler/js/regAllocator/test-range-spill-fill-with-CFG-expected.txt
@@ -0,0 +1 @@
+obj's a
diff --git a/es2panda/test/compiler/js/regAllocator/test-range-spill-fill-with-CFG.js b/es2panda/test/compiler/js/regAllocator/test-range-spill-fill-with-CFG.js
new file mode 100644
index 0000000000..f8858536e9
--- /dev/null
+++ b/es2panda/test/compiler/js/regAllocator/test-range-spill-fill-with-CFG.js
@@ -0,0 +1,274 @@
+let obj = {
+    a: "obj's a",
+    xx : function xx() {
+        let a = undefined;
+        let aa = undefined;
+        let aaa = undefined;
+        let aaaa = undefined;
+        let aaaaa = undefined;
+        let aaaaaa = undefined;
+        let aaaaaaa = undefined;
+        let aaaaaaaa = undefined;
+        let b = undefined;
+        let bb = undefined;
+        let bbb = undefined;
+        let aaabab = undefined;
+        let aaaabab = undefined;
+        let aaaabaab = undefined;
+        let aaaaabaab = undefined;
+        let aaaaaabaab = undefined;
+        let ab = undefined;
+        let aba = undefined;
+        let abaa = undefined;
+        let abaaa = undefined;
+        let abaaaa = undefined;
+        let aabaaaa = undefined;
+        let aabaaaaa = undefined;
+        let aaabaaaaa = undefined;
+        let bbbbb = undefined;
+        let bbbbbb = undefined;
+        let bbbb = undefined;
+        let aaaba = undefined;
+        let aaaaba = undefined;
+        let aaaabaa = undefined;
+        let aaaaabaa = undefined;
+        let aaaaaabaa = undefined;
+        let c = undefined;
+        let ac = undefined;
+        let aac = undefined;
+        let aaac = undefined;
+        let aaaac = undefined;
+        let aaaaac = undefined;
+        let aaaaaac = undefined;
+        let aaaaaaac = undefined;
+        let aaaaaaaca = undefined;
+        let bc = undefined;
+        let bbc = undefined;
+        let bbbc = undefined;
+        let aaabcab = undefined;
+        let aaaababc = undefined;
+        let aaaabaabc = undefined;
+        let aaaaabaabc = undefined;
+        let aaaaaabaabc = undefined;
+        let abc = undefined;
+        let abca = undefined;
+        let abcaa = undefined;
+        let abacaa = undefined;
+        let abacaaa = undefined;
+        let aabaacaa = undefined;
+        let aabaacaaa = undefined;
+        let aaabcaaaaa = undefined;
+        let bbbbcb = undefined;
+        let bbbbcbb = undefined;
+        let bbbcb = undefined;
+        let aacaba = undefined;
+        let aaaabca = undefined;
+        let aaaacbaa = undefined;
+        let aaaaabcaa = undefined;
+        let aaaaacabaa = undefined;
+        let add = undefined;
+        let aadd = undefined;
+        let aaadd = undefined;
+        let aaaadd = undefined;
+        let aaaaadd = undefined;
+        let aaaaaadd = undefined;
+        let aaaaaadda = undefined;
+        let aaaaaaadda = undefined;
+        let bdd = undefined;
+        let bbdd = undefined;
+        let bbbdd = undefined;
+        let aaababdd = undefined;
+        let aaaabddab = undefined;
+        let aaaabddaab = undefined;
+        let aaaaaddbaab = undefined;
+        let aaaaaabddaab = undefined;
+        let ddab = undefined;
+        let abdda = undefined;
+        let abadda = undefined;
+        let abaddaa = undefined;
+        let abaaddaa = undefined;
+        let aabaaddaa = undefined;
+        let aabaaaddaa = undefined;
+        let aaabaaaddaa = undefined;
+        let bbbddbb = undefined;
+        let bbbddbbb = undefined;
+        let bbddbb = undefined;
+        let aaaddba = undefined;
+        let aaaddaba = undefined;
+        let aaaabaadd = undefined;
+        let aaaaabaadd = undefined;
+        let aaaaaabaadd = undefined;
+        let cdd = undefined;
+        let acdd = undefined;
+        let aacdd = undefined;
+        let aaacdd = undefined;
+        let aaaacddd = undefined;
+        let aaaaacddd = undefined;
+        let aaaaaacddd = undefined;
+        let aaaaaaacdd = undefined;
+        let aaaaaaacadd = undefined;
+        let bcdd = undefined;
+        let bbcdd = undefined;
+        let bbbcdd = undefined;
+        let aaabcabdd = undefined;
+        let aaaababcdd = undefined;
+        let aaaabaabcdd = undefined;
+        let aaaaabaabcdd = undefined;
+        let aaaaaabaabcdd = undefined;
+        let abcdd = undefined;
+        let abcdda = undefined;
+        let abcaddda = undefined;
+        let abacaddda = undefined;
+        let abacaadda = undefined;
+        let aabaacddaa = undefined;
+        let aabaacaaadd = undefined;
+        let aaabcaaaaadd = undefined;
+        let bbbbcbdd = undefined;
+        let bbbbcbbdd = undefined;
+        let bbbcbdd = undefined;
+        let aacabdda = undefined;
+        let aaaabcadd = undefined;
+        let aaaacbadda = undefined;
+        let aaaaabcaadd = undefined;
+        let aaaaacabddaa = undefined;
+        let ae = undefined;
+        let aaee = undefined;
+        let aaaee = undefined;
+        let aaaae = undefined;
+        let aaaaea = undefined;
+        let aaaaaea = undefined;
+        let aaaaaeaa = undefined;
+        let aaaaaaeaa = undefined;
+        let be = undefined;
+        let bbe = undefined;
+        let bbeb = undefined;
+        let aaabeab = undefined;
+        let aaaaebab = undefined;
+        let aaaabaeab = undefined;
+        let aaaaaebaab = undefined;
+        let aaaaaaebaab = undefined;
+        let abe = undefined;
+        let aeba = undefined;
+        let abeaa = undefined;
+        let abaeaa = undefined;
+        let abaeaaa = undefined;
+        let aabaeaaa = undefined;
+        let aabaaeaaa = undefined;
+        let aaabeaaaaa = undefined;
+        let bbbbeb = undefined;
+        let bbbbebb = undefined;
+        let bbbeb = undefined;
+        let aaaeba = undefined;
+        let aaaeaba = undefined;
+        let aaaeabaa = undefined;
+        let aaaeaabaa = undefined;
+        let aaaaeaabaa = undefined;
+        let ce = undefined;
+        let aec = undefined;
+        let aaec = undefined;
+        let aaaec = undefined;
+        let aaaeac = undefined;
+        let aaaaeac = undefined;
+        let aaaaeaac = undefined;
+        let aaaaaeaac = undefined;
+        let aaaaaeaaca = undefined;
+        let bce = undefined;
+        let bbce = undefined;
+        let bbbec = undefined;
+        let aaabceab = undefined;
+        let aaaabaebc = undefined;
+        let aaaabaeabc = undefined;
+        let aaaaabaeabc = undefined;
+        let aaaaaabeaabc = undefined;
+        let abce = undefined;
+        let abcea = undefined;
+        let abcaea = undefined;
+        let abacaea = undefined;
+        let abacaeaa = undefined;
+        let aabaeacaa = undefined;
+        let aabaaceaaa = undefined;
+        let aaabcaaeaaa = undefined;
+        let bbbbecb = undefined;
+        let bbbbcbeb = undefined;
+        let bbbceb = undefined;
+        let aacaeba = undefined;
+        let aaaaebca = undefined;
+        let aaaacbaea = undefined;
+        let aaaaabecaa = undefined;
+        let aaaaaceabaa = undefined;
+        let adde = undefined;
+        let aaded = undefined;
+        let aaaedd = undefined;
+        let aaaaedd = undefined;
+        let aaaaeadd = undefined;
+        let aaaaeaadd = undefined;
+        let aaaaaeadda = undefined;
+        let aaaaaaeadda = undefined;
+        let bded = undefined;
+        let bbedd = undefined;
+        let bbbded = undefined;
+        let aaababedd = undefined;
+        let aaaabdedab = undefined;
+        let aaaabddaeab = undefined;
+        let aaaaaeddbaab = undefined;
+        let aaaaaabeddaab = undefined;
+        let ddabe = undefined;
+        let abdeda = undefined;
+        let abadeda = undefined;
+        let abadedaa = undefined;
+        let abaaddeaa = undefined;
+        let aabaadedaa = undefined;
+        let aabaaaeddaa = undefined;
+        let aaabaaadedaa = undefined;
+        let bbbddebb = undefined;
+        let bbbddbebb = undefined;
+        let bbddebb = undefined;
+        let aaaddeba = undefined;
+        let aaaddaeba = undefined;
+        let aaaabeaadd = undefined;
+        let aaaaabaeadd = undefined;
+        let aaaaaabaeadd = undefined;
+        let cdde = undefined;
+        let acdde = undefined;
+        let aacdde = undefined;
+        let aaacdde = undefined;
+        let aaaacdded = undefined;
+        let aaaaacdded = undefined;
+        let aaaaaacdded = undefined;
+        let aaaaaaacdde = undefined;
+        let aaaaaaacadde = undefined;
+        let bcedd = undefined;
+        let bbcedd = undefined;
+        let bbbcedd = undefined;
+        let aaabceabdd = undefined;
+        let aaaabaebcdd = undefined;
+        let aaaabaaebcdd = undefined;
+        let aaaaabaaebcdd = undefined;
+        let aaaaaabaaebcdd = undefined;
+        let abcdde = undefined;
+        let abcddae = undefined;
+        let abcadddea = undefined;
+        let abacadddea = undefined;
+        let abacaaddae = undefined;
+        let aabaacddaae = undefined;
+        let aabaacaaadde = undefined;
+        let aaabcaaaaadde = undefined;
+        let bbbbcbdde = undefined;
+        let bbbbcbbdde = undefined;
+        let bbbcbdde = undefined;
+        let aacabddae = undefined;
+        let aaaabcadde = undefined;
+        let aaaacbaddae = undefined;
+        let aaaaabcaadde = undefined;
+        try {
+            let aaaaacabddaae = {a: function b(c, d, e, f) {
+                throw c + d + e + f;
+            }};
+            aaaaacabddaae.a(1, 2, 3, 4);
+        } catch {
+            print(this.a)
+        }
+    }
+}
+
+obj.xx();
-- 
Gitee