chakra-core
diff --git a/‎lib/Backend/BackwardPass.cpp
Copy file name to clipboard
+16-15Lines changed: 16 additions & 15 deletions b/‎lib/Backend/BackwardPass.cpp
Copy file name to clipboard
+16-15Lines changed: 16 additions & 15 deletions
diff --git a/‎lib/Backend/BailOut.cpp
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎lib/Backend/BailOut.cpp
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎lib/Backend/BailOutKind.h
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions b/‎lib/Backend/BailOutKind.h
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions
@@ -48,7 +48,7 @@ bool
 BackwardPass::DoByteCodeUpwardExposedUsed() const
 {
     return (this->tag == Js::DeadStorePhase && this->func->hasBailout) ||
-        (this->func->HasTry() && this->func->DoOptimizeTryCatch() && this->tag == Js::BackwardPhase);
+        (this->func->HasTry() && this->func->DoOptimizeTry() && this->tag == Js::BackwardPhase);
 }
 
 bool
@@ -114,7 +114,7 @@ BackwardPass::DoDeadStore(Func* func)
 {
     return
         !PHASE_OFF(Js::DeadStorePhase, func) &&
-        (!func->HasTry() || func->DoOptimizeTryCatch());
+        (!func->HasTry() || func->DoOptimizeTry());
 }
 
 bool
@@ -1111,7 +1111,7 @@ BackwardPass::MergeSuccBlocksInfo(BasicBlock * block)
             Assert(block->typesNeedingKnownObjectLayout == nullptr);
             Assert(block->fieldHoistCandidates == nullptr);
             // byteCodeUpwardExposedUsed is required to populate the writeThroughSymbolsSet for the try region in the backwards pass
-            Assert(block->byteCodeUpwardExposedUsed == nullptr || (this->tag == Js::BackwardPhase && this->func->HasTry() && this->func->DoOptimizeTryCatch()));
+            Assert(block->byteCodeUpwardExposedUsed == nullptr || (this->tag == Js::BackwardPhase && this->func->HasTry() && this->func->DoOptimizeTry()));
             Assert(block->byteCodeRestoreSyms == nullptr);
             Assert(block->stackSymToFinalType == nullptr);
             Assert(block->stackSymToGuardedProperties == nullptr);
@@ -1847,7 +1847,7 @@ BackwardPass::ProcessBailOutInfo(IR::Instr * instr)
     {
         // We don't need to fill in the bailout instruction in backward pass
         Assert(this->func->hasBailout || !instr->HasBailOutInfo());
-        Assert(!instr->HasBailOutInfo() || instr->GetBailOutInfo()->byteCodeUpwardExposedUsed == nullptr || (this->func->HasTry() && this->func->DoOptimizeTryCatch()));
+        Assert(!instr->HasBailOutInfo() || instr->GetBailOutInfo()->byteCodeUpwardExposedUsed == nullptr || (this->func->HasTry() && this->func->DoOptimizeTry()));
 
         if (instr->IsByteCodeUsesInstr())
         {
@@ -2298,7 +2298,7 @@ BackwardPass::ProcessBailOutInfo(IR::Instr * instr, BailOutInfo * bailOutInfo)
     // The byteCodeUpwardExposedUsed should only be assigned once. The only case which would break this
     // assumption is when we are optimizing a function having try-catch. In that case, we need the
     // byteCodeUpwardExposedUsed analysis in the initial backward pass too.
-    Assert(bailOutInfo->byteCodeUpwardExposedUsed == nullptr || (this->func->HasTry() && this->func->DoOptimizeTryCatch()));
+    Assert(bailOutInfo->byteCodeUpwardExposedUsed == nullptr || (this->func->HasTry() && this->func->DoOptimizeTry()));
 
     // Make a copy of the byteCodeUpwardExposedUsed so we can remove the constants
     if (!this->IsPrePass())
@@ -2765,7 +2765,7 @@ BackwardPass::ProcessBlock(BasicBlock * block)
                 }
                 case Js::OpCode::Catch:
                 {
-                    if (this->func->DoOptimizeTryCatch() && !this->IsPrePass())
+                    if (this->func->DoOptimizeTry() && !this->IsPrePass())
                     {
                         // Execute the "Catch" in the JIT'ed code, and bailout to the next instruction. This way, the bailout will restore the exception object automatically.
                         IR::BailOutInstr* bailOnException = IR::BailOutInstr::New(Js::OpCode::BailOnException, IR::BailOutOnException, instr->m_next, instr->m_func);
@@ -2792,15 +2792,15 @@ BackwardPass::ProcessBlock(BasicBlock * block)
             this->ProcessInlineeEnd(instr);
         }
 
-        if (instr->IsLabelInstr() && instr->m_next->m_opcode == Js::OpCode::Catch)
+        if ((instr->IsLabelInstr() && instr->m_next->m_opcode == Js::OpCode::Catch) || (instr->IsLabelInstr() && instr->m_next->m_opcode == Js::OpCode::Finally))
         {
             if (!this->currentRegion)
             {
-                Assert(!this->func->DoOptimizeTryCatch() && !(this->func->IsSimpleJit() && this->func->hasBailout));
+                Assert(!this->func->DoOptimizeTry() && !(this->func->IsSimpleJit() && this->func->hasBailout));
             }
             else
             {
-                Assert(this->currentRegion->GetType() == RegionTypeCatch);
+                Assert(this->currentRegion->GetType() == RegionTypeCatch || this->currentRegion->GetType() == RegionTypeFinally);
                 Region * matchingTryRegion = this->currentRegion->GetMatchingTryRegion();
                 Assert(matchingTryRegion);
 
@@ -2827,10 +2827,11 @@ BackwardPass::ProcessBlock(BasicBlock * block)
 #if DBG
         if (instr->m_opcode == Js::OpCode::TryCatch)
         {
-            if (!this->IsPrePass() && (this->func->DoOptimizeTryCatch() || (this->func->IsSimpleJit() && this->func->hasBailout)))
+            if (!this->IsPrePass() && (this->func->DoOptimizeTry() || (this->func->IsSimpleJit() && this->func->hasBailout)))
             {
                 Assert(instr->m_next->IsLabelInstr() && (instr->m_next->AsLabelInstr()->GetRegion() != nullptr));
                 Region * tryRegion = instr->m_next->AsLabelInstr()->GetRegion();
+                Assert(tryRegion && tryRegion->GetType() == RegionType::RegionTypeTry && tryRegion->GetMatchingCatchRegion() != nullptr);
                 Assert(tryRegion->writeThroughSymbolsSet);
             }
         }
@@ -7496,16 +7497,16 @@ BackwardPass::FoldCmBool(IR::Instr *instr)
 }
 
 void
-BackwardPass::SetWriteThroughSymbolsSetForRegion(BasicBlock * catchBlock, Region * tryRegion)
+BackwardPass::SetWriteThroughSymbolsSetForRegion(BasicBlock * catchOrFinallyBlock, Region * tryRegion)
 {
     tryRegion->writeThroughSymbolsSet = JitAnew(this->func->m_alloc, BVSparse<JitArenaAllocator>, this->func->m_alloc);
 
     if (this->DoByteCodeUpwardExposedUsed())
     {
-        Assert(catchBlock->byteCodeUpwardExposedUsed);
-        if (!catchBlock->byteCodeUpwardExposedUsed->IsEmpty())
+        Assert(catchOrFinallyBlock->byteCodeUpwardExposedUsed);
+        if (!catchOrFinallyBlock->byteCodeUpwardExposedUsed->IsEmpty())
         {
-            FOREACH_BITSET_IN_SPARSEBV(id, catchBlock->byteCodeUpwardExposedUsed)
+            FOREACH_BITSET_IN_SPARSEBV(id, catchOrFinallyBlock->byteCodeUpwardExposedUsed)
             {
                 tryRegion->writeThroughSymbolsSet->Set(id);
             }
@@ -7550,7 +7551,7 @@ BackwardPass::SetWriteThroughSymbolsSetForRegion(BasicBlock * catchBlock, Region
 bool
 BackwardPass::CheckWriteThroughSymInRegion(Region* region, StackSym* sym)
 {
-    if (region->GetType() == RegionTypeRoot || region->GetType() == RegionTypeFinally)
+    if (region->GetType() == RegionTypeRoot)
     {
         return false;
     }
 
@@ -1050,7 +1050,7 @@ Js::Var BailOutRecord::BailOut(BailOutRecord const * bailOutRecord)
     void * argoutRestoreAddr = nullptr;
 #ifdef _M_IX86
     void * addressOfRetAddress = _AddressOfReturnAddress();
-    if (bailOutRecord->ehBailoutData && (bailOutRecord->ehBailoutData->catchOffset != 0))
+    if (bailOutRecord->ehBailoutData && (bailOutRecord->ehBailoutData->catchOffset != 0 || bailOutRecord->ehBailoutData->finallyOffset != 0 || bailOutRecord->ehBailoutData->ht == Js::HandlerType::HT_Finally))
     {
         // For a bailout in argument evaluation from an EH region, the esp is offset by the TryCatch helper's frame. So, the argouts are not at the offsets
         // stored in the bailout record, which are relative to ebp. Need to restore the argouts from the actual value of esp before calling the Bailout helper
@@ -2708,7 +2708,7 @@ Js::Var BranchBailOutRecord::BailOut(BranchBailOutRecord const * bailOutRecord,
     void * argoutRestoreAddr = nullptr;
 #ifdef _M_IX86
     void * addressOfRetAddress = _AddressOfReturnAddress();
-    if (bailOutRecord->ehBailoutData && (bailOutRecord->ehBailoutData->catchOffset != 0))
+    if (bailOutRecord->ehBailoutData && (bailOutRecord->ehBailoutData->catchOffset != 0 || bailOutRecord->ehBailoutData->finallyOffset != 0 || bailOutRecord->ehBailoutData->ht == Js::HandlerType::HT_Finally))
     {
         argoutRestoreAddr = (void *)((char*)addressOfRetAddress + ((2 + 1) * MachPtr)); // Account for the parameters and return address of this function
     }
 
@@ -46,6 +46,7 @@ BAIL_OUT_KIND(LazyBailOut,                          0)
 BAIL_OUT_KIND(BailOutOnFailedHoistedLoopCountBasedBoundCheck, 0)
 BAIL_OUT_KIND(BailOutForGeneratorYield,             0)
 BAIL_OUT_KIND(BailOutOnException,                   0)
+BAIL_OUT_KIND(BailOutOnEarlyExit,                   0)
 
 // SIMD_JS
 BAIL_OUT_KIND(BailOutSimd128F4Only,                 0)
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ bool`
`48`	`48`	`BackwardPass::DoByteCodeUpwardExposedUsed() const`
`49`	`49`	`{`
`50`	`50`	`return (this->tag == Js::DeadStorePhase && this->func->hasBailout) \|\|`
`51`		`- (this->func->HasTry() && this->func->DoOptimizeTryCatch() && this->tag == Js::BackwardPhase);`
	`51`	`+ (this->func->HasTry() && this->func->DoOptimizeTry() && this->tag == Js::BackwardPhase);`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`bool`
`@@ -114,7 +114,7 @@ BackwardPass::DoDeadStore(Func* func)`
`114`	`114`	`{`
`115`	`115`	`return`
`116`	`116`	`!PHASE_OFF(Js::DeadStorePhase, func) &&`
`117`		`- (!func->HasTry() \|\| func->DoOptimizeTryCatch());`
	`117`	`+ (!func->HasTry() \|\| func->DoOptimizeTry());`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`bool`
`@@ -1111,7 +1111,7 @@ BackwardPass::MergeSuccBlocksInfo(BasicBlock * block)`
`1111`	`1111`	`Assert(block->typesNeedingKnownObjectLayout == nullptr);`
`1112`	`1112`	`Assert(block->fieldHoistCandidates == nullptr);`
`1113`	`1113`	`// byteCodeUpwardExposedUsed is required to populate the writeThroughSymbolsSet for the try region in the backwards pass`
`1114`		`- Assert(block->byteCodeUpwardExposedUsed == nullptr \|\| (this->tag == Js::BackwardPhase && this->func->HasTry() && this->func->DoOptimizeTryCatch()));`
	`1114`	`+ Assert(block->byteCodeUpwardExposedUsed == nullptr \|\| (this->tag == Js::BackwardPhase && this->func->HasTry() && this->func->DoOptimizeTry()));`
`1115`	`1115`	`Assert(block->byteCodeRestoreSyms == nullptr);`
`1116`	`1116`	`Assert(block->stackSymToFinalType == nullptr);`
`1117`	`1117`	`Assert(block->stackSymToGuardedProperties == nullptr);`
`@@ -1847,7 +1847,7 @@ BackwardPass::ProcessBailOutInfo(IR::Instr * instr)`
`1847`	`1847`	`{`
`1848`	`1848`	`// We don't need to fill in the bailout instruction in backward pass`
`1849`	`1849`	`Assert(this->func->hasBailout \|\| !instr->HasBailOutInfo());`
`1850`		`- Assert(!instr->HasBailOutInfo() \|\| instr->GetBailOutInfo()->byteCodeUpwardExposedUsed == nullptr \|\| (this->func->HasTry() && this->func->DoOptimizeTryCatch()));`
	`1850`	`+ Assert(!instr->HasBailOutInfo() \|\| instr->GetBailOutInfo()->byteCodeUpwardExposedUsed == nullptr \|\| (this->func->HasTry() && this->func->DoOptimizeTry()));`
`1851`	`1851`
`1852`	`1852`	`if (instr->IsByteCodeUsesInstr())`
`1853`	`1853`	`{`
`@@ -2298,7 +2298,7 @@ BackwardPass::ProcessBailOutInfo(IR::Instr * instr, BailOutInfo * bailOutInfo)`
`2298`	`2298`	`// The byteCodeUpwardExposedUsed should only be assigned once. The only case which would break this`
`2299`	`2299`	`// assumption is when we are optimizing a function having try-catch. In that case, we need the`
`2300`	`2300`	`// byteCodeUpwardExposedUsed analysis in the initial backward pass too.`
`2301`		`- Assert(bailOutInfo->byteCodeUpwardExposedUsed == nullptr \|\| (this->func->HasTry() && this->func->DoOptimizeTryCatch()));`
	`2301`	`+ Assert(bailOutInfo->byteCodeUpwardExposedUsed == nullptr \|\| (this->func->HasTry() && this->func->DoOptimizeTry()));`
`2302`	`2302`
`2303`	`2303`	`// Make a copy of the byteCodeUpwardExposedUsed so we can remove the constants`
`2304`	`2304`	`if (!this->IsPrePass())`
`@@ -2765,7 +2765,7 @@ BackwardPass::ProcessBlock(BasicBlock * block)`
`2765`	`2765`	`}`
`2766`	`2766`	`case Js::OpCode::Catch:`
`2767`	`2767`	`{`
`2768`		`- if (this->func->DoOptimizeTryCatch() && !this->IsPrePass())`
	`2768`	`+ if (this->func->DoOptimizeTry() && !this->IsPrePass())`
`2769`	`2769`	`{`
`2770`	`2770`	`// Execute the "Catch" in the JIT'ed code, and bailout to the next instruction. This way, the bailout will restore the exception object automatically.`
`2771`	`2771`	`IR::BailOutInstr* bailOnException = IR::BailOutInstr::New(Js::OpCode::BailOnException, IR::BailOutOnException, instr->m_next, instr->m_func);`
`@@ -2792,15 +2792,15 @@ BackwardPass::ProcessBlock(BasicBlock * block)`
`2792`	`2792`	`this->ProcessInlineeEnd(instr);`
`2793`	`2793`	`}`
`2794`	`2794`
`2795`		`- if (instr->IsLabelInstr() && instr->m_next->m_opcode == Js::OpCode::Catch)`
	`2795`	`+ if ((instr->IsLabelInstr() && instr->m_next->m_opcode == Js::OpCode::Catch) \|\| (instr->IsLabelInstr() && instr->m_next->m_opcode == Js::OpCode::Finally))`
`2796`	`2796`	`{`
`2797`	`2797`	`if (!this->currentRegion)`
`2798`	`2798`	`{`
`2799`		`- Assert(!this->func->DoOptimizeTryCatch() && !(this->func->IsSimpleJit() && this->func->hasBailout));`
	`2799`	`+ Assert(!this->func->DoOptimizeTry() && !(this->func->IsSimpleJit() && this->func->hasBailout));`
`2800`	`2800`	`}`
`2801`	`2801`	`else`
`2802`	`2802`	`{`
`2803`		`- Assert(this->currentRegion->GetType() == RegionTypeCatch);`
	`2803`	`+ Assert(this->currentRegion->GetType() == RegionTypeCatch \|\| this->currentRegion->GetType() == RegionTypeFinally);`
`2804`	`2804`	`Region * matchingTryRegion = this->currentRegion->GetMatchingTryRegion();`
`2805`	`2805`	`Assert(matchingTryRegion);`
`2806`	`2806`
`@@ -2827,10 +2827,11 @@ BackwardPass::ProcessBlock(BasicBlock * block)`
`2827`	`2827`	`#if DBG`
`2828`	`2828`	`if (instr->m_opcode == Js::OpCode::TryCatch)`
`2829`	`2829`	`{`
`2830`		`- if (!this->IsPrePass() && (this->func->DoOptimizeTryCatch() \|\| (this->func->IsSimpleJit() && this->func->hasBailout)))`
	`2830`	`+ if (!this->IsPrePass() && (this->func->DoOptimizeTry() \|\| (this->func->IsSimpleJit() && this->func->hasBailout)))`
`2831`	`2831`	`{`
`2832`	`2832`	`Assert(instr->m_next->IsLabelInstr() && (instr->m_next->AsLabelInstr()->GetRegion() != nullptr));`
`2833`	`2833`	`Region * tryRegion = instr->m_next->AsLabelInstr()->GetRegion();`
	`2834`	`+ Assert(tryRegion && tryRegion->GetType() == RegionType::RegionTypeTry && tryRegion->GetMatchingCatchRegion() != nullptr);`
`2834`	`2835`	`Assert(tryRegion->writeThroughSymbolsSet);`
`2835`	`2836`	`}`
`2836`	`2837`	`}`
`@@ -7496,16 +7497,16 @@ BackwardPass::FoldCmBool(IR::Instr *instr)`
`7496`	`7497`	`}`
`7497`	`7498`
`7498`	`7499`	`void`
`7499`		`-BackwardPass::SetWriteThroughSymbolsSetForRegion(BasicBlock * catchBlock, Region * tryRegion)`
	`7500`	`+BackwardPass::SetWriteThroughSymbolsSetForRegion(BasicBlock * catchOrFinallyBlock, Region * tryRegion)`
`7500`	`7501`	`{`
`7501`	`7502`	`tryRegion->writeThroughSymbolsSet = JitAnew(this->func->m_alloc, BVSparse<JitArenaAllocator>, this->func->m_alloc);`
`7502`	`7503`
`7503`	`7504`	`if (this->DoByteCodeUpwardExposedUsed())`
`7504`	`7505`	`{`
`7505`		`- Assert(catchBlock->byteCodeUpwardExposedUsed);`
`7506`		`- if (!catchBlock->byteCodeUpwardExposedUsed->IsEmpty())`
	`7506`	`+ Assert(catchOrFinallyBlock->byteCodeUpwardExposedUsed);`
	`7507`	`+ if (!catchOrFinallyBlock->byteCodeUpwardExposedUsed->IsEmpty())`
`7507`	`7508`	`{`
`7508`		`- FOREACH_BITSET_IN_SPARSEBV(id, catchBlock->byteCodeUpwardExposedUsed)`
	`7509`	`+ FOREACH_BITSET_IN_SPARSEBV(id, catchOrFinallyBlock->byteCodeUpwardExposedUsed)`
`7509`	`7510`	`{`
`7510`	`7511`	`tryRegion->writeThroughSymbolsSet->Set(id);`
`7511`	`7512`	`}`
`@@ -7550,7 +7551,7 @@ BackwardPass::SetWriteThroughSymbolsSetForRegion(BasicBlock * catchBlock, Region`
`7550`	`7551`	`bool`
`7551`	`7552`	`BackwardPass::CheckWriteThroughSymInRegion(Region* region, StackSym* sym)`
`7552`	`7553`	`{`
`7553`		`- if (region->GetType() == RegionTypeRoot \|\| region->GetType() == RegionTypeFinally)`
	`7554`	`+ if (region->GetType() == RegionTypeRoot)`
`7554`	`7555`	`{`
`7555`	`7556`	`return false;`
`7556`	`7557`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1050,7 +1050,7 @@ Js::Var BailOutRecord::BailOut(BailOutRecord const * bailOutRecord)`
`1050`	`1050`	`void * argoutRestoreAddr = nullptr;`
`1051`	`1051`	`#ifdef _M_IX86`
`1052`	`1052`	`void * addressOfRetAddress = _AddressOfReturnAddress();`
`1053`		`- if (bailOutRecord->ehBailoutData && (bailOutRecord->ehBailoutData->catchOffset != 0))`
	`1053`	`+ if (bailOutRecord->ehBailoutData && (bailOutRecord->ehBailoutData->catchOffset != 0 \|\| bailOutRecord->ehBailoutData->finallyOffset != 0 \|\| bailOutRecord->ehBailoutData->ht == Js::HandlerType::HT_Finally))`
`1054`	`1054`	`{`
`1055`	`1055`	`// For a bailout in argument evaluation from an EH region, the esp is offset by the TryCatch helper's frame. So, the argouts are not at the offsets`
`1056`	`1056`	`// stored in the bailout record, which are relative to ebp. Need to restore the argouts from the actual value of esp before calling the Bailout helper`
`@@ -2708,7 +2708,7 @@ Js::Var BranchBailOutRecord::BailOut(BranchBailOutRecord const * bailOutRecord,`
`2708`	`2708`	`void * argoutRestoreAddr = nullptr;`
`2709`	`2709`	`#ifdef _M_IX86`
`2710`	`2710`	`void * addressOfRetAddress = _AddressOfReturnAddress();`
`2711`		`- if (bailOutRecord->ehBailoutData && (bailOutRecord->ehBailoutData->catchOffset != 0))`
	`2711`	`+ if (bailOutRecord->ehBailoutData && (bailOutRecord->ehBailoutData->catchOffset != 0 \|\| bailOutRecord->ehBailoutData->finallyOffset != 0 \|\| bailOutRecord->ehBailoutData->ht == Js::HandlerType::HT_Finally))`
`2712`	`2712`	`{`
`2713`	`2713`	`argoutRestoreAddr = (void )((char)addressOfRetAddress + ((2 + 1) * MachPtr)); // Account for the parameters and return address of this function`
`2714`	`2714`	`}`