[1.8>1.9] [MERGE #4560 @leirocks] simplify xData deletion

leirocks · leirocks · commit cfcbe3b3d206 · 2018-01-22T08:58:37.000-08:00
Merge pull request #4560 from leirocks:ftfix change to not using jit code deletion job to do the work, instead always do it in side channel and before new xData registration
diff --git a/lib/Backend/CodeGenWorkItem.cpp b/lib/Backend/CodeGenWorkItem.cpp
@@ -205,7 +205,22 @@ void CodeGenWorkItem::OnWorkItemProcessFail(NativeCodeGenerator* codeGen)
 #if DBG
         this->allocation->allocation->isNotExecutableBecauseOOM = true;
 #endif
-        codeGen->FreeNativeCodeGenAllocation(this->allocation->allocation->address, nullptr);
+
+#if PDATA_ENABLED & defined(_WIN32)
+        if (this->entryPointInfo && this->entryPointInfo->GetXDataInfo()) 
+        {
+            void* functionTable = this->entryPointInfo->GetXDataInfo()->functionTable;
+            if (functionTable)
+            {
+                if (!DelayDeletingFunctionTable::AddEntry(functionTable))
+                {
+                    PHASE_PRINT_TESTTRACE1(Js::XDataPhase, _u("OnWorkItemProcessFail: Failed to add to slist, table: %llx\n"), functionTable);
+                    DelayDeletingFunctionTable::DeleteFunctionTable(functionTable);
+                }
+            }
+        }
+#endif
+        codeGen->FreeNativeCodeGenAllocation(this->allocation->allocation->address);
     }
 }
 
diff --git a/lib/Backend/EmitBuffer.cpp b/lib/Backend/EmitBuffer.cpp
@@ -55,6 +55,7 @@ template <typename TAlloc, typename TPreReservedAlloc, class SyncObject>
 void
 EmitBufferManager<TAlloc, TPreReservedAlloc, SyncObject>::FreeAllocations(bool release)
 {
+    DelayDeletingFunctionTable::Clear();
     AutoRealOrFakeCriticalSection<SyncObject> autoCs(&this->criticalSection);
 
 #if DBG_DUMP
@@ -191,9 +192,10 @@ EmitBufferManager<TAlloc, TPreReservedAlloc, SyncObject>::NewAllocation(size_t b
 
 template <typename TAlloc, typename TPreReservedAlloc, class SyncObject>
 bool
-EmitBufferManager<TAlloc, TPreReservedAlloc, SyncObject>::FreeAllocation(void* address, void** functionTable)
+EmitBufferManager<TAlloc, TPreReservedAlloc, SyncObject>::FreeAllocation(void* address)
 {
     AutoRealOrFakeCriticalSection<SyncObject> autoCs(&this->criticalSection);
+
 #if _M_ARM
     address = (void*)((uintptr_t)address & ~0x1); // clear the thumb bit
 #endif
@@ -243,14 +245,6 @@ EmitBufferManager<TAlloc, TPreReservedAlloc, SyncObject>::FreeAllocation(void* a
             }
             VerboseHeapTrace(_u("Freeing 0x%p, allocation: 0x%p\n"), address, allocation->allocation->address);
 
-#if PDATA_ENABLED && defined(_WIN32)
-            if (functionTable && *functionTable)
-            {
-                NtdllLibrary::Instance->DeleteGrowableFunctionTable(*functionTable);
-                *functionTable = nullptr;
-            }
-#endif
-
             this->allocationHeap.Free(allocation->allocation);
             this->allocator->Free(allocation, sizeof(TEmitBufferAllocation));
 
diff --git a/lib/Backend/EmitBuffer.h b/lib/Backend/EmitBuffer.h
@@ -46,7 +46,7 @@ class EmitBufferManager
     bool ProtectBufferWithExecuteReadWriteForInterpreter(TEmitBufferAllocation* allocation);
     bool CommitBufferForInterpreter(TEmitBufferAllocation* allocation, _In_reads_bytes_(bufferSize) BYTE* pBuffer, _In_ size_t bufferSize);
     void CompletePreviousAllocation(TEmitBufferAllocation* allocation);
-    bool FreeAllocation(void* address, void** functionTable);
+    bool FreeAllocation(void* address);
     //Ends here
 
     bool IsInHeap(void* address);
diff --git a/lib/Backend/NativeCodeGenerator.cpp b/lib/Backend/NativeCodeGenerator.cpp
@@ -1117,6 +1117,7 @@ NativeCodeGenerator::CodeGen(PageAllocator * pageAllocator, CodeGenWorkItem* wor
     }
 
 #if defined(TARGET_64)
+    DelayDeletingFunctionTable::Clear();
     XDataAllocation * xdataInfo = HeapNewZ(XDataAllocation);
     xdataInfo->address = (byte*)jitWriteData.xdataAddr;
     XDataAllocator::Register(xdataInfo, jitWriteData.codeAddress, jitWriteData.codeSize);
@@ -3214,14 +3215,14 @@ NativeCodeGenerator::EnterScriptStart()
 }
 
 void
-FreeNativeCodeGenAllocation(Js::ScriptContext *scriptContext, Js::JavascriptMethod codeAddress, Js::JavascriptMethod thunkAddress, void** functionTable)
+FreeNativeCodeGenAllocation(Js::ScriptContext *scriptContext, Js::JavascriptMethod codeAddress, Js::JavascriptMethod thunkAddress)
 {
     if (!scriptContext->GetNativeCodeGenerator())
     { 
         return;
     }
 
-    scriptContext->GetNativeCodeGenerator()->QueueFreeNativeCodeGenAllocation((void*)codeAddress, (void*)thunkAddress, functionTable);
+    scriptContext->GetNativeCodeGenerator()->QueueFreeNativeCodeGenAllocation((void*)codeAddress, (void*)thunkAddress);
 }
 
 bool TryReleaseNonHiPriWorkItem(Js::ScriptContext* scriptContext, CodeGenWorkItem* workItem)
@@ -3252,30 +3253,22 @@ bool NativeCodeGenerator::TryReleaseNonHiPriWorkItem(CodeGenWorkItem* workItem)
 }
 
 void
-NativeCodeGenerator::FreeNativeCodeGenAllocation(void* codeAddress, void** functionTable)
+NativeCodeGenerator::FreeNativeCodeGenAllocation(void* codeAddress)
 {
     if (JITManager::GetJITManager()->IsOOPJITEnabled())
     {
-        // function table delete in content process
-#if PDATA_ENABLED && defined(_WIN32)
-        if (functionTable && *functionTable)
-        {
-            NtdllLibrary::Instance->DeleteGrowableFunctionTable(*functionTable);
-            *functionTable = nullptr;
-        }
-#endif
         ThreadContext * context = this->scriptContext->GetThreadContext();
         HRESULT hr = JITManager::GetJITManager()->FreeAllocation(context->GetRemoteThreadContextAddr(), (intptr_t)codeAddress);
         JITManager::HandleServerCallResult(hr, RemoteCallType::MemFree);
     }
     else if(this->backgroundAllocators)
     {
-        this->backgroundAllocators->emitBufferManager.FreeAllocation(codeAddress, functionTable);
+        this->backgroundAllocators->emitBufferManager.FreeAllocation(codeAddress);
     }
 }
 
 void
-NativeCodeGenerator::QueueFreeNativeCodeGenAllocation(void* codeAddress, void * thunkAddress, void** functionTable)
+NativeCodeGenerator::QueueFreeNativeCodeGenAllocation(void* codeAddress, void * thunkAddress)
 {
     ASSERT_THREAD();
 
@@ -3305,24 +3298,24 @@ NativeCodeGenerator::QueueFreeNativeCodeGenAllocation(void* codeAddress, void *
     // OOP JIT will always queue a job
 
     // The foreground allocators may have been used
-    if (this->foregroundAllocators && this->foregroundAllocators->emitBufferManager.FreeAllocation(codeAddress, functionTable))
+    if (this->foregroundAllocators && this->foregroundAllocators->emitBufferManager.FreeAllocation(codeAddress))
     {
         return;
     }
 
     // The background allocators were used. Queue a job to free the allocation from the background thread.
-    this->freeLoopBodyManager.QueueFreeLoopBodyJob(codeAddress, thunkAddress, functionTable);
+    this->freeLoopBodyManager.QueueFreeLoopBodyJob(codeAddress, thunkAddress);
 }
 
-void NativeCodeGenerator::FreeLoopBodyJobManager::QueueFreeLoopBodyJob(void* codeAddress, void * thunkAddress, void** functionTable)
+void NativeCodeGenerator::FreeLoopBodyJobManager::QueueFreeLoopBodyJob(void* codeAddress, void * thunkAddress)
 {
     Assert(!this->isClosed);
 
-    FreeLoopBodyJob* job = HeapNewNoThrow(FreeLoopBodyJob, this, codeAddress, thunkAddress, *functionTable);
+    FreeLoopBodyJob* job = HeapNewNoThrow(FreeLoopBodyJob, this, codeAddress, thunkAddress);
 
     if (job == nullptr)
     {
-        FreeLoopBodyJob stackJob(this, codeAddress, thunkAddress, *functionTable, false /* heapAllocated */);
+        FreeLoopBodyJob stackJob(this, codeAddress, thunkAddress, false /* heapAllocated */);
 
         {
             AutoOptionalCriticalSection lock(Processor()->GetCriticalSection());
@@ -3346,9 +3339,6 @@ void NativeCodeGenerator::FreeLoopBodyJobManager::QueueFreeLoopBodyJob(void* cod
             HeapDelete(job);
         }
     }
-
-    // function table successfully transferred to background job
-    *functionTable = nullptr;
 }
 
 #ifdef PROFILE_EXEC
diff --git a/lib/Backend/NativeCodeGenerator.h b/lib/Backend/NativeCodeGenerator.h
@@ -104,10 +104,10 @@ void SetProfileMode(BOOL fSet);
     void UpdateQueueForDebugMode();
     bool IsBackgroundJIT() const;
     void EnterScriptStart();
-    void FreeNativeCodeGenAllocation(void* codeAddress, void** functionTable);
+    void FreeNativeCodeGenAllocation(void* codeAddress);
     bool TryReleaseNonHiPriWorkItem(CodeGenWorkItem* workItem);
 
-    void QueueFreeNativeCodeGenAllocation(void* codeAddress, void* thunkAddress, void** functionTable);
+    void QueueFreeNativeCodeGenAllocation(void* codeAddress, void* thunkAddress);
 
     bool IsClosed() { return isClosed; }
     void AddWorkItem(CodeGenWorkItem* workItem);
@@ -201,19 +201,17 @@ void SetProfileMode(BOOL fSet);
     class FreeLoopBodyJob: public JsUtil::Job
     {
     public:
-        FreeLoopBodyJob(JsUtil::JobManager *const manager, void* codeAddress, void* thunkAddress, void* functionTable, bool isHeapAllocated = true):
+        FreeLoopBodyJob(JsUtil::JobManager *const manager, void* codeAddress, void* thunkAddress, bool isHeapAllocated = true):
           JsUtil::Job(manager),
           codeAddress(codeAddress),
           thunkAddress(thunkAddress),
-          functionTable(functionTable),
           heapAllocated(isHeapAllocated)
         {
         }
 
         bool heapAllocated;
         void* codeAddress;
         void* thunkAddress;
-        void* functionTable;
     };
 
     class FreeLoopBodyJobManager sealed: public WaitableJobManager
@@ -281,9 +279,8 @@ void SetProfileMode(BOOL fSet);
         {
             FreeLoopBodyJob* freeLoopBodyJob = static_cast<FreeLoopBodyJob*>(job);
 
-            void* functionTable = freeLoopBodyJob->functionTable;
             // Free Loop Body
-            nativeCodeGen->FreeNativeCodeGenAllocation(freeLoopBodyJob->codeAddress, &functionTable);
+            nativeCodeGen->FreeNativeCodeGenAllocation(freeLoopBodyJob->codeAddress);
 
             return true;
         }
@@ -306,7 +303,7 @@ void SetProfileMode(BOOL fSet);
             }
         }
 
-        void QueueFreeLoopBodyJob(void* codeAddress, void* thunkAddress, void** functionTable);
+        void QueueFreeLoopBodyJob(void* codeAddress, void* thunkAddress);
 
     private:
         NativeCodeGenerator* nativeCodeGen;
diff --git a/lib/Backend/PDataManager.cpp b/lib/Backend/PDataManager.cpp
@@ -46,7 +46,7 @@ void PDataManager::UnregisterPdata(RUNTIME_FUNCTION* pdata)
     if (AutoSystemInfo::Data.IsWin8OrLater())
     {
         // TODO: need to move to background?
-        NtdllLibrary::Instance->DeleteGrowableFunctionTable(pdata);
+        DelayDeletingFunctionTable::DeleteFunctionTable(pdata);
     }
     else
     {
diff --git a/lib/Common/BackendApi.h b/lib/Common/BackendApi.h
@@ -62,7 +62,7 @@ void UpdateNativeCodeGeneratorForDebugMode(NativeCodeGenerator* nativeCodeGen);
 CriticalSection *GetNativeCodeGenCriticalSection(NativeCodeGenerator *pNativeCodeGen);
 bool TryReleaseNonHiPriWorkItem(Js::ScriptContext* scriptContext, CodeGenWorkItem* workItem);
 void NativeCodeGenEnterScriptStart(NativeCodeGenerator * nativeCodeGen);
-void FreeNativeCodeGenAllocation(Js::ScriptContext* scriptContext, Js::JavascriptMethod codeAddress, Js::JavascriptMethod thunkAddress, void** functionTable);
+void FreeNativeCodeGenAllocation(Js::ScriptContext* scriptContext, Js::JavascriptMethod codeAddress, Js::JavascriptMethod thunkAddress);
 InProcCodeGenAllocators* GetForegroundAllocator(NativeCodeGenerator * nativeCodeGen, PageAllocator* pageallocator);
 void GenerateFunction(NativeCodeGenerator * nativeCodeGen, Js::FunctionBody * functionBody, Js::ScriptFunction * function = NULL);
 void GenerateLoopBody(NativeCodeGenerator * nativeCodeGen, Js::FunctionBody * functionBody, Js::LoopHeader * loopHeader, Js::EntryPointInfo* entryPointInfo, uint localCount, Js::Var localSlots[]);
diff --git a/lib/Common/ConfigFlagsList.h b/lib/Common/ConfigFlagsList.h
@@ -371,6 +371,7 @@ PHASE(All)
         PHASE(DeferSourceLoad)
         PHASE(ObjectMutationBreakpoint)
         PHASE(NativeCodeData)
+        PHASE(XData)
 #undef PHASE
 #endif
 
diff --git a/lib/Common/Core/DelayLoadLibrary.cpp b/lib/Common/Core/DelayLoadLibrary.cpp
@@ -82,12 +82,17 @@ DWORD NtdllLibrary::AddGrowableFunctionTable( _Out_ PVOID * DynamicTable,
                 return 1;
             }
         }
-        return addGrowableFunctionTable(DynamicTable,
+        DWORD status = addGrowableFunctionTable(DynamicTable,
             FunctionTable,
             EntryCount,
             MaximumEntryCount,
             RangeBase,
             RangeEnd);
+#if _M_X64
+        PHASE_PRINT_TESTTRACE1(Js::XDataPhase, _u("Register: Begin: %llx, End: %x, Unwind: %llx, RangeBase: %llx, RangeEnd: %llx, table: %llx, Status: %x\n"),
+            FunctionTable->BeginAddress, FunctionTable->EndAddress, FunctionTable->UnwindInfoAddress, RangeBase, RangeEnd, *DynamicTable, status);
+#endif
+        return status;
     }
     return 1;
 }
@@ -107,6 +112,8 @@ VOID NtdllLibrary::DeleteGrowableFunctionTable( _In_ PVOID DynamicTable )
             }
         }
         deleteGrowableFunctionTable(DynamicTable);
+
+        PHASE_PRINT_TESTTRACE1(Js::XDataPhase, _u("UnRegister: table: %llx\n"), DynamicTable);
     }
 }
 
diff --git a/lib/Common/Memory/DelayDeletingFunctionTable.cpp b/lib/Common/Memory/DelayDeletingFunctionTable.cpp
@@ -64,7 +64,7 @@ void DelayDeletingFunctionTable::Clear()
         while (entry)
         {
             FunctionTableNode* list = (FunctionTableNode*)entry;
-            NtdllLibrary::Instance->DeleteGrowableFunctionTable(list->functionTable);
+            DeleteFunctionTable(list->functionTable);
             _aligned_free(entry);
             entry = InterlockedPopEntrySList(Head);
         }
@@ -79,4 +79,11 @@ bool DelayDeletingFunctionTable::IsEmpty()
 #else
     return true;
 #endif
+}
+
+void DelayDeletingFunctionTable::DeleteFunctionTable(void* functionTable)
+{
+#if PDATA_ENABLED && defined(_WIN32)
+    NtdllLibrary::Instance->DeleteGrowableFunctionTable(functionTable);
+#endif
 }
diff --git a/lib/Common/Memory/XDataAllocator.h b/lib/Common/Memory/XDataAllocator.h
@@ -32,4 +32,5 @@ struct DelayDeletingFunctionTable
     static bool AddEntry(FunctionTableHandle ft);
     static void Clear();
     static bool IsEmpty();
+    static void DeleteFunctionTable(void* functionTable);
 };
diff --git a/lib/Common/Memory/amd64/XDataAllocator.cpp b/lib/Common/Memory/amd64/XDataAllocator.cpp
@@ -134,10 +134,7 @@ void XDataAllocator::Register(XDataAllocation * xdataInfo, ULONG_PTR functionSta
             /*RangeBase*/ functionStart,
             /*RangeEnd*/ functionStart + functionSize);
         success = NT_SUCCESS(status);
-        if (success)
-        {
-            Assert(xdataInfo->functionTable != nullptr);
-        }
+        Assert(success && xdataInfo->functionTable != nullptr);
     }
     else
     {
diff --git a/lib/JITServer/JITServer.cpp b/lib/JITServer/JITServer.cpp
@@ -676,7 +676,7 @@ ServerFreeAllocation(
 
     return ServerCallWrapper(context, [&]()->HRESULT
     {
-        context->GetCodeGenAllocators()->emitBufferManager.FreeAllocation((void*)codeAddress, nullptr);
+        context->GetCodeGenAllocators()->emitBufferManager.FreeAllocation((void*)codeAddress);
         return S_OK;
     });
 }
diff --git a/lib/Runtime/Base/FunctionBody.cpp b/lib/Runtime/Base/FunctionBody.cpp
diff --git a/lib/Runtime/Base/FunctionBody.h b/lib/Runtime/Base/FunctionBody.h
diff --git a/lib/Runtime/Base/ScriptContext.cpp b/lib/Runtime/Base/ScriptContext.cpp
diff --git a/lib/Runtime/Base/ScriptContext.h b/lib/Runtime/Base/ScriptContext.h

Original file line number	Diff line number	Diff line change
`@@ -1117,6 +1117,7 @@ NativeCodeGenerator::CodeGen(PageAllocator * pageAllocator, CodeGenWorkItem* wor`
`1117`	`1117`	`}`
`1118`	`1118`
`1119`	`1119`	`#if defined(TARGET_64)`
	`1120`	`+ DelayDeletingFunctionTable::Clear();`
`1120`	`1121`	`XDataAllocation * xdataInfo = HeapNewZ(XDataAllocation);`
`1121`	`1122`	`xdataInfo->address = (byte*)jitWriteData.xdataAddr;`
`1122`	`1123`	`XDataAllocator::Register(xdataInfo, jitWriteData.codeAddress, jitWriteData.codeSize);`
`@@ -3214,14 +3215,14 @@ NativeCodeGenerator::EnterScriptStart()`
`3214`	`3215`	`}`
`3215`	`3216`
`3216`	`3217`	`void`
`3217`		`-FreeNativeCodeGenAllocation(Js::ScriptContext scriptContext, Js::JavascriptMethod codeAddress, Js::JavascriptMethod thunkAddress, void* functionTable)`
	`3218`	`+FreeNativeCodeGenAllocation(Js::ScriptContext *scriptContext, Js::JavascriptMethod codeAddress, Js::JavascriptMethod thunkAddress)`
`3218`	`3219`	`{`
`3219`	`3220`	`if (!scriptContext->GetNativeCodeGenerator())`
`3220`	`3221`	`{`
`3221`	`3222`	`return;`
`3222`	`3223`	`}`
`3223`	`3224`
`3224`		`- scriptContext->GetNativeCodeGenerator()->QueueFreeNativeCodeGenAllocation((void)codeAddress, (void)thunkAddress, functionTable);`
	`3225`	`+ scriptContext->GetNativeCodeGenerator()->QueueFreeNativeCodeGenAllocation((void)codeAddress, (void)thunkAddress);`
`3225`	`3226`	`}`
`3226`	`3227`
`3227`	`3228`	`bool TryReleaseNonHiPriWorkItem(Js::ScriptContext* scriptContext, CodeGenWorkItem* workItem)`
`@@ -3252,30 +3253,22 @@ bool NativeCodeGenerator::TryReleaseNonHiPriWorkItem(CodeGenWorkItem* workItem)`
`3252`	`3253`	`}`
`3253`	`3254`
`3254`	`3255`	`void`
`3255`		`-NativeCodeGenerator::FreeNativeCodeGenAllocation(void* codeAddress, void** functionTable)`
	`3256`	`+NativeCodeGenerator::FreeNativeCodeGenAllocation(void* codeAddress)`
`3256`	`3257`	`{`
`3257`	`3258`	`if (JITManager::GetJITManager()->IsOOPJITEnabled())`
`3258`	`3259`	`{`
`3259`		`- // function table delete in content process`
`3260`		`-#if PDATA_ENABLED && defined(_WIN32)`
`3261`		`- if (functionTable && *functionTable)`
`3262`		`- {`
`3263`		`- NtdllLibrary::Instance->DeleteGrowableFunctionTable(*functionTable);`
`3264`		`- *functionTable = nullptr;`
`3265`		`- }`
`3266`		`-#endif`
`3267`	`3260`	`ThreadContext * context = this->scriptContext->GetThreadContext();`
`3268`	`3261`	`HRESULT hr = JITManager::GetJITManager()->FreeAllocation(context->GetRemoteThreadContextAddr(), (intptr_t)codeAddress);`
`3269`	`3262`	`JITManager::HandleServerCallResult(hr, RemoteCallType::MemFree);`
`3270`	`3263`	`}`
`3271`	`3264`	`else if(this->backgroundAllocators)`
`3272`	`3265`	`{`
`3273`		`- this->backgroundAllocators->emitBufferManager.FreeAllocation(codeAddress, functionTable);`
	`3266`	`+ this->backgroundAllocators->emitBufferManager.FreeAllocation(codeAddress);`
`3274`	`3267`	`}`
`3275`	`3268`	`}`
`3276`	`3269`
`3277`	`3270`	`void`
`3278`		`-NativeCodeGenerator::QueueFreeNativeCodeGenAllocation(void* codeAddress, void * thunkAddress, void** functionTable)`
	`3271`	`+NativeCodeGenerator::QueueFreeNativeCodeGenAllocation(void* codeAddress, void * thunkAddress)`
`3279`	`3272`	`{`
`3280`	`3273`	`ASSERT_THREAD();`
`3281`	`3274`
`@@ -3305,24 +3298,24 @@ NativeCodeGenerator::QueueFreeNativeCodeGenAllocation(void* codeAddress, void *`
`3305`	`3298`	`// OOP JIT will always queue a job`
`3306`	`3299`
`3307`	`3300`	`// The foreground allocators may have been used`
`3308`		`- if (this->foregroundAllocators && this->foregroundAllocators->emitBufferManager.FreeAllocation(codeAddress, functionTable))`
	`3301`	`+ if (this->foregroundAllocators && this->foregroundAllocators->emitBufferManager.FreeAllocation(codeAddress))`
`3309`	`3302`	`{`
`3310`	`3303`	`return;`
`3311`	`3304`	`}`
`3312`	`3305`
`3313`	`3306`	`// The background allocators were used. Queue a job to free the allocation from the background thread.`
`3314`		`- this->freeLoopBodyManager.QueueFreeLoopBodyJob(codeAddress, thunkAddress, functionTable);`
	`3307`	`+ this->freeLoopBodyManager.QueueFreeLoopBodyJob(codeAddress, thunkAddress);`
`3315`	`3308`	`}`
`3316`	`3309`
`3317`		`-void NativeCodeGenerator::FreeLoopBodyJobManager::QueueFreeLoopBodyJob(void* codeAddress, void * thunkAddress, void** functionTable)`
	`3310`	`+void NativeCodeGenerator::FreeLoopBodyJobManager::QueueFreeLoopBodyJob(void* codeAddress, void * thunkAddress)`
`3318`	`3311`	`{`
`3319`	`3312`	`Assert(!this->isClosed);`
`3320`	`3313`
`3321`		`- FreeLoopBodyJob* job = HeapNewNoThrow(FreeLoopBodyJob, this, codeAddress, thunkAddress, *functionTable);`
	`3314`	`+ FreeLoopBodyJob* job = HeapNewNoThrow(FreeLoopBodyJob, this, codeAddress, thunkAddress);`
`3322`	`3315`
`3323`	`3316`	`if (job == nullptr)`
`3324`	`3317`	`{`
`3325`		`- FreeLoopBodyJob stackJob(this, codeAddress, thunkAddress, functionTable, false / heapAllocated */);`
	`3318`	`+ FreeLoopBodyJob stackJob(this, codeAddress, thunkAddress, false /* heapAllocated */);`
`3326`	`3319`
`3327`	`3320`	`{`
`3328`	`3321`	`AutoOptionalCriticalSection lock(Processor()->GetCriticalSection());`
`@@ -3346,9 +3339,6 @@ void NativeCodeGenerator::FreeLoopBodyJobManager::QueueFreeLoopBodyJob(void* cod`
`3346`	`3339`	`HeapDelete(job);`
`3347`	`3340`	`}`
`3348`	`3341`	`}`
`3349`		`-`
`3350`		`- // function table successfully transferred to background job`
`3351`		`- *functionTable = nullptr;`
`3352`	`3342`	`}`
`3353`	`3343`
`3354`	`3344`	`#ifdef PROFILE_EXEC`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ void PDataManager::UnregisterPdata(RUNTIME_FUNCTION* pdata)`
`46`	`46`	`if (AutoSystemInfo::Data.IsWin8OrLater())`
`47`	`47`	`{`
`48`	`48`	`// TODO: need to move to background?`
`49`		`- NtdllLibrary::Instance->DeleteGrowableFunctionTable(pdata);`
	`49`	`+ DelayDeletingFunctionTable::DeleteFunctionTable(pdata);`
`50`	`50`	`}`
`51`	`51`	`else`
`52`	`52`	`{`
Original file line number	Diff line number	Diff line change
`@@ -82,12 +82,17 @@ DWORD NtdllLibrary::AddGrowableFunctionTable( _Out_ PVOID * DynamicTable,`
`82`	`82`	`return 1;`
`83`	`83`	`}`
`84`	`84`	`}`
`85`		`- return addGrowableFunctionTable(DynamicTable,`
	`85`	`+ DWORD status = addGrowableFunctionTable(DynamicTable,`
`86`	`86`	`FunctionTable,`
`87`	`87`	`EntryCount,`
`88`	`88`	`MaximumEntryCount,`
`89`	`89`	`RangeBase,`
`90`	`90`	`RangeEnd);`
	`91`	`+#if _M_X64`
	`92`	`+ PHASE_PRINT_TESTTRACE1(Js::XDataPhase, _u("Register: Begin: %llx, End: %x, Unwind: %llx, RangeBase: %llx, RangeEnd: %llx, table: %llx, Status: %x\n"),`
	`93`	`+ FunctionTable->BeginAddress, FunctionTable->EndAddress, FunctionTable->UnwindInfoAddress, RangeBase, RangeEnd, *DynamicTable, status);`
	`94`	`+#endif`
	`95`	`+ return status;`
`91`	`96`	`}`
`92`	`97`	`return 1;`
`93`	`98`	`}`
`@@ -107,6 +112,8 @@ VOID NtdllLibrary::DeleteGrowableFunctionTable( _In_ PVOID DynamicTable )`
`107`	`112`	`}`
`108`	`113`	`}`
`109`	`114`	`deleteGrowableFunctionTable(DynamicTable);`
	`115`	`+`
	`116`	`+ PHASE_PRINT_TESTTRACE1(Js::XDataPhase, _u("UnRegister: table: %llx\n"), DynamicTable);`
`110`	`117`	`}`
`111`	`118`	`}`
`112`	`119`