Move BailOutForElidedYield to ResumeJumpTable

This is to prevent us from accidentally inserting it in the middle of other instructions

Author: nhat-nguyen

lib/Backend/IRBuilder.cpp

@@ -7746,17 +7746,23 @@ IRBuilder::GeneratorJumpTable::BuildJumpTable()
     );
     this->m_irBuilder->AddInstr(instr, this->m_irBuilder->m_functionStartOffset);
 
+    IR::LabelInstr* functionBegin = IR::LabelInstr::New(Js::OpCode::Label, this->m_func);
+    LABELNAMESET(functionBegin, "GeneratorFunctionBegin");
+
     IR::LabelInstr* initCode = IR::LabelInstr::New(Js::OpCode::Label, this->m_func);
     LABELNAMESET(initCode, "GeneratorInitializationAndJumpTable");
 
     // BrNotAddr_A s2 nullptr $initializationCode
-    IR::BranchInstr* branchInstr = IR::BranchInstr::New(Js::OpCode::BrNotAddr_A, initCode, genFrameOpnd, IR::AddrOpnd::NewNull(this->m_func), this->m_func);
-    this->m_irBuilder->AddInstr(branchInstr, this->m_irBuilder->m_functionStartOffset);
+    IR::BranchInstr* skipCreateInterpreterFrame = IR::BranchInstr::New(Js::OpCode::BrNotAddr_A, initCode, genFrameOpnd, IR::AddrOpnd::NewNull(this->m_func), this->m_func);
+    this->m_irBuilder->AddInstr(skipCreateInterpreterFrame, this->m_irBuilder->m_functionStartOffset);
 
     // Create interpreter stack frame
     IR::Instr* createInterpreterFrame = IR::Instr::New(Js::OpCode::GeneratorCreateInterpreterStackFrame, genFrameOpnd /* dst */, genRegOpnd /* src */, this->m_func);
     this->m_irBuilder->AddInstr(createInterpreterFrame, this->m_irBuilder->m_functionStartOffset);
 
+    IR::BranchInstr* skipJumpTable = IR::BranchInstr::New(Js::OpCode::Br, functionBegin, this->m_func);
+    this->m_irBuilder->AddInstr(skipJumpTable, this->m_irBuilder->m_functionStartOffset);
+
     // Label to insert any initialization code
     // $initializationCode:
     this->m_irBuilder->AddInstr(initCode, this->m_irBuilder->m_functionStartOffset);
@@ -7791,6 +7797,10 @@ IRBuilder::GeneratorJumpTable::BuildJumpTable()
     instr->SetSrc1(curOffsetOpnd);
     this->m_irBuilder->AddInstr(instr, this->m_irBuilder->m_functionStartOffset);
 
+    this->m_func->m_bailOutForElidedYieldInsertionPoint = instr;
+
+    this->m_irBuilder->AddInstr(functionBegin, this->m_irBuilder->m_functionStartOffset);
+
     // Save these values for later use
     this->m_initLabel = initCode;
     this->m_generatorFrameOpnd = genFrameOpnd;

lib/Backend/Lower.cpp

@@ -3010,7 +3010,6 @@ Lowerer::LowerRange(IR::Instr *instrStart, IR::Instr *instrEnd, bool defaultDoFa
 
         case Js::OpCode::GeneratorResumeJumpTable:
         {
-            this->m_lowerGeneratorHelper.InsertBailOutForElidedYield();
             this->m_lowerGeneratorHelper.LowerGeneratorResumeJumpTable(instr);
             break;
         }
@@ -29079,49 +29078,6 @@ void Lowerer::LowerGeneratorHelper::InsertNullOutGeneratorFrameInEpilogue(IR::La
     InsertMove(indirOpnd, addrOpnd, insertionPoint);
 }
 
-void
-Lowerer::LowerGeneratorHelper::InsertBailOutForElidedYield()
-{
-    IR::LabelInstr* bailOutNoSaveLabel = nullptr;
-
-    this->func->MapUntilYieldOffsetResumeLabels([this, &bailOutNoSaveLabel](int, const YieldOffsetResumeLabel& yorl)
-    {
-        if (yorl.Second() == nullptr)
-        {
-            if (bailOutNoSaveLabel == nullptr)
-            {
-                bailOutNoSaveLabel = IR::LabelInstr::New(Js::OpCode::Label, this->func);
-            }
-
-            return true;
-        }
-
-        return false;
-    });
-
-    // Insert the bailoutnosave label somewhere along with a call to BailOutNoSave helper
-    if (bailOutNoSaveLabel != nullptr)
-    {
-        bailOutNoSaveLabel->m_hasNonBranchRef = true;
-        bailOutNoSaveLabel->isOpHelper = true;
-
-        IR::Instr* exitPrevInstr = this->GetEpilogueForReturnStatements()->m_prev;
-        IR::Instr* bailOutCall = IR::Instr::New(Js::OpCode::Call, this->func);
-        IR::Instr* branchToEpilogue = IR::BranchInstr::New(LowererMD::MDUncondBranchOpcode, this->GetEpilogueForBailOut(), this->func);
-
-        exitPrevInstr->InsertBefore(bailOutNoSaveLabel);
-        exitPrevInstr->InsertBefore(bailOutCall);
-        exitPrevInstr->InsertBefore(branchToEpilogue);
-
-        IR::RegOpnd* frameRegOpnd = IR::RegOpnd::New(nullptr, LowererMD::GetRegFramePointer(), TyMachPtr, this->func);
-        this->lowererMD.LoadHelperArgument(bailOutCall, frameRegOpnd);
-        this->lowererMD.ChangeToHelperCall(bailOutCall, IR::HelperNoSaveRegistersBailOutForElidedYield);
-
-        this->func->m_bailOutNoSaveLabel = bailOutNoSaveLabel;
-        LABELNAMESET(bailOutNoSaveLabel, "GeneratorBailOutForElidedYield");
-    }
-}
-
 void
 Lowerer::LowerGeneratorHelper::EnsureEpilogueLabels()
 {
@@ -29165,30 +29121,76 @@ Lowerer::LowerGeneratorHelper::LowerGeneratorResumeJumpTable(IR::Instr* jumpTabl
     Assert(this->func->GetJITFunctionBody()->IsCoroutine());
     Assert(jumpTableInstr->m_opcode == Js::OpCode::GeneratorResumeJumpTable);
 
+    IR::LabelInstr* bailOutForElidedYield = this->InsertBailOutForElidedYield();
+
     IR::Opnd* srcOpnd = jumpTableInstr->UnlinkSrc1();
 
-    this->func->MapYieldOffsetResumeLabels([this, &srcOpnd, &jumpTableInstr](int i, const YieldOffsetResumeLabel& yorl)
+    this->func->MapYieldOffsetResumeLabels([this, &srcOpnd, &jumpTableInstr, &bailOutForElidedYield](int i, const YieldOffsetResumeLabel& yorl)
     {
         uint32 offset = yorl.First();
-        IR::LabelInstr* label = yorl.Second();
+        IR::LabelInstr* resumeLabel = yorl.Second();
 
-        if (label != nullptr && label->m_hasNonBranchRef)
+        if (resumeLabel != nullptr)
         {
+            Assert(resumeLabel->IsGeneratorBailInInstr());
             // Also fix up the bailout at the label with the jump to epilog that was not emitted in GenerateBailOut()
-            this->lowerer->GenerateJumpToEpilogForBailOut(label->m_prev->GetBailOutInfo(), label->m_prev, this->GetEpilogueForBailOut());
+            this->lowerer->GenerateJumpToEpilogForBailOut(resumeLabel->m_prev->GetBailOutInfo(), resumeLabel->m_prev, this->GetEpilogueForBailOut());
         }
-        else if (label == nullptr)
+        else if (resumeLabel == nullptr)
         {
-            label = this->func->m_bailOutNoSaveLabel;
+            resumeLabel = bailOutForElidedYield;
         }
 
         // For each offset label pair, insert a compare of the offset and branch if equal to the label
-        this->lowerer->InsertCompareBranch(srcOpnd, IR::IntConstOpnd::New(offset, TyUint32, this->func), Js::OpCode::BrSrEq_A, label, jumpTableInstr);
+        this->lowerer->InsertCompareBranch(srcOpnd, IR::IntConstOpnd::New(offset, TyUint32, this->func), Js::OpCode::BrSrEq_A, resumeLabel, jumpTableInstr);
     });
 
     jumpTableInstr->Remove();
 }
 
+IR::LabelInstr*
+Lowerer::LowerGeneratorHelper::InsertBailOutForElidedYield()
+{
+    IR::LabelInstr* bailOutNoSaveLabel = nullptr;
+
+    this->func->MapUntilYieldOffsetResumeLabels([this, &bailOutNoSaveLabel](int, const YieldOffsetResumeLabel& yorl)
+    {
+        if (yorl.Second() == nullptr)
+        {
+            if (bailOutNoSaveLabel == nullptr)
+            {
+                bailOutNoSaveLabel = IR::LabelInstr::New(Js::OpCode::Label, this->func);
+            }
+
+            return true;
+        }
+
+        return false;
+    });
+
+    // Insert the bailoutnosave label somewhere along with a call to BailOutNoSave helper
+    if (bailOutNoSaveLabel != nullptr)
+    {
+        bailOutNoSaveLabel->m_hasNonBranchRef = true;
+
+        IR::Instr* insertionPoint = this->func->m_bailOutForElidedYieldInsertionPoint->m_next;
+        IR::Instr* bailOutCall = IR::Instr::New(Js::OpCode::Call, this->func);
+        IR::Instr* branchToEpilogue = IR::BranchInstr::New(LowererMD::MDUncondBranchOpcode, this->GetEpilogueForBailOut(), this->func);
+
+        insertionPoint->InsertBefore(bailOutNoSaveLabel);
+        insertionPoint->InsertBefore(bailOutCall);
+        insertionPoint->InsertBefore(branchToEpilogue);
+
+        IR::RegOpnd* frameRegOpnd = IR::RegOpnd::New(nullptr, LowererMD::GetRegFramePointer(), TyMachPtr, this->func);
+        this->lowererMD.LoadHelperArgument(bailOutCall, frameRegOpnd);
+        this->lowererMD.ChangeToHelperCall(bailOutCall, IR::HelperNoSaveRegistersBailOutForElidedYield);
+
+        LABELNAMESET(bailOutNoSaveLabel, "GeneratorBailOutForElidedYield");
+    }
+
+    return bailOutNoSaveLabel;
+}
+
 void
 Lowerer::LowerGeneratorHelper::LowerCreateInterpreterStackFrameForGenerator(IR::Instr* instr)
 {

lib/Backend/Lower.h

@@ -885,7 +885,7 @@ class Lowerer
         // They could still be hit if an active generator object had been paused at such a yield point when
         // the function body was JITed. So safe guard such a case by having the native code simply jump back
         // to the interpreter for such yield points.
-        void InsertBailOutForElidedYield();
+        IR::LabelInstr* InsertBailOutForElidedYield();
 
         void LowerGeneratorResumeJumpTable(IR::Instr* jumpTableInstr);
         void LowerCreateInterpreterStackFrameForGenerator(IR::Instr* instr);