[1.10>master] [MERGE #5525 @leirocks] Use seperate error for xdata registration failures

Merge pull request #5525 from leirocks:xdata

Author: leirocks

lib/Backend/PDataManager.cpp

@@ -15,6 +15,7 @@
 void PDataManager::RegisterPdata(RUNTIME_FUNCTION* pdataStart, _In_ const ULONG_PTR functionStart, _In_ const ULONG_PTR functionEnd, _Out_ PVOID* pdataTable, ULONG entryCount, ULONG maxEntryCount)
 {
     BOOLEAN success = FALSE;
+    HRESULT hr = S_OK;
     if (AutoSystemInfo::Data.IsWin8OrLater())
     {
         Assert(pdataTable != NULL);
@@ -28,17 +29,22 @@ void PDataManager::RegisterPdata(RUNTIME_FUNCTION* pdataStart, _In_ const ULONG_
             /*RangeBase*/ functionStart,
             /*RangeEnd*/ functionEnd);
         success = NT_SUCCESS(status);
-        if (success)
-        {
-            Assert(pdataTable);
-        }
+        Assert(!success || pdataTable);
+        hr = status;
     }
     else
     {
         *pdataTable = pdataStart;
         success = RtlAddFunctionTable(pdataStart, entryCount, functionStart);
+        if (!success) 
+        {
+            hr = E_OUTOFMEMORY; // only OOM error can happen for RtlAddFunctionTable
+        }
+    }
+    if (!success)
+    {
+        Js::Throw::XDataRegistrationError(hr, functionStart);
     }
-    Js::Throw::CheckAndThrowOutOfMemory(success);
 }
 
 void PDataManager::UnregisterPdata(RUNTIME_FUNCTION* pdata)

lib/Common/Core/DelayLoadLibrary.cpp

@@ -112,6 +112,13 @@ NtdllLibrary::NTSTATUS NtdllLibrary::AddGrowableFunctionTable( _Out_ PVOID * Dyn
             }
         }
 
+#if DBG
+        // Validate the PDATA was not registered or already unregistered
+        ULONG_PTR            imageBase = 0;
+        RUNTIME_FUNCTION  *runtimeFunction = RtlLookupFunctionEntry((DWORD64)RangeBase, &imageBase, nullptr);
+        Assert(runtimeFunction == NULL);
+#endif
+
         *DynamicTable = nullptr;
         NTSTATUS status = addGrowableFunctionTable(DynamicTable,
             FunctionTable,

lib/Common/Exceptions/ReportError.cpp

@@ -10,7 +10,7 @@ void ReportFatalException(
     __in ULONG_PTR context,
     __in HRESULT exceptionCode,
     __in ErrorReason reasonCode,
-    __in ULONG scenario)
+    __in ULONG_PTR scenario)
 {
     // avoid the error text methods to be optimized out.
     UNREFERENCED_PARAMETER(scenario);
@@ -181,6 +181,11 @@ _NOINLINE void OutOfMemoryAllocationPolicy_unrecoverable_error()
     ReportFatalException(NULL, E_OUTOFMEMORY, Fatal_OutOfMemory, scenario);
 }
 
+_NOINLINE void XDataRegistration_unrecoverable_error(HRESULT hr, ULONG_PTR scenario)
+{
+    ReportFatalException(NULL, hr, Fatal_XDataRegistration, scenario);
+}
+
 ///////
 //
 // The following variety of OOM unrecoverable errors are similar to the ones above 

lib/Common/Exceptions/ReportError.h

@@ -30,13 +30,14 @@ enum ErrorReason
     Fatal_OutOfMemory = 22,
     // Unused = 23,
     Fatal_JsBuiltIn_Error = 24,
+    Fatal_XDataRegistration = 25,
 };
 
 extern "C" void ReportFatalException(
     __in ULONG_PTR context,
     __in HRESULT exceptionCode,
     __in ErrorReason reasonCode,
-    __in ULONG scenario);
+    __in ULONG_PTR scenario);
 
 // We can have other error handle code path with
 // unique call stack so we can collect data in Dr. Watson.
@@ -89,6 +90,8 @@ void OutOfMemoryTooManyPinnedObjects_unrecoverable_error_notvisible();
 void OutOfMemoryTooManyClosedContexts_unrecoverable_error_notvisible();
 void OutOfMemoryAllocationPolicy_unrecoverable_error_notvisible();
 
+void XDataRegistration_unrecoverable_error(HRESULT hr, ULONG_PTR scenario);
+
 inline void OutOfMemoryTooManyPinnedObjects_unrecoverable_error(BYTE visibility)
 {
     switch (visibility)

lib/Common/Exceptions/Throw.cpp

@@ -125,13 +125,21 @@ namespace Js {
         }
         throw OutOfMemoryException();
     }
-    void Throw::CheckAndThrowOutOfMemory(BOOLEAN status)
+
+#if !defined(_M_IX86) && defined(_WIN32)
+    void Throw::XDataRegistrationError(HRESULT hr, ULONG_PTR funcStart)
     {
-        if (!status)
+        ULONG_PTR            imageBase = 0;
+        RUNTIME_FUNCTION  *runtimeFunction = RtlLookupFunctionEntry(funcStart, &imageBase, nullptr);
+
+        if (JsUtil::ExternalApi::GetCurrentThreadContextId())
         {
-            OutOfMemory();
+            XDataRegistration_unrecoverable_error(hr, (ULONG_PTR)runtimeFunction);
         }
+        throw OutOfMemoryException();
     }
+#endif
+
     void Throw::StackOverflow(ScriptContext *scriptContext, PVOID returnAddress)
     {
 #ifdef ENABLE_DEBUG_CONFIG_OPTIONS

lib/Common/Exceptions/Throw.h

@@ -30,7 +30,10 @@ namespace Js {
 #ifdef ENABLE_JS_BUILTINS
         static void __declspec(noreturn) FatalJsBuiltInError();
 #endif
-        static void CheckAndThrowOutOfMemory(BOOLEAN status);
+
+#if !defined(_M_IX86) && defined(_WIN32)
+        static void XDataRegistrationError(HRESULT hr, ULONG_PTR funcStart);
+#endif
 
         static bool ReportAssert(__in LPCSTR fileName, uint lineNumber, __in LPCSTR error, __in LPCSTR message);
         static void LogAssert();

lib/Common/Memory/amd64/XDataAllocator.cpp

@@ -124,29 +124,33 @@ void XDataAllocator::Register(XDataAllocation * xdataInfo, ULONG_PTR functionSta
     xdataInfo->pdata.EndAddress = (DWORD)(xdataInfo->pdata.BeginAddress + functionSize);
     xdataInfo->pdata.UnwindInfoAddress = (DWORD)((intptr_t)xdataInfo->address - baseAddress);
 
+    HRESULT hr = S_OK;
     BOOLEAN success = FALSE;
     if (AutoSystemInfo::Data.IsWin8OrLater())
     {
-#if DBG
-        // Validate the PDATA was not registered or unregistered
-        ULONG64            imageBase = 0;
-        RUNTIME_FUNCTION  *runtimeFunction = RtlLookupFunctionEntry((DWORD64)functionStart, &imageBase, nullptr);
-        Assert(runtimeFunction == NULL);
-#endif
-
         NTSTATUS status = NtdllLibrary::Instance->AddGrowableFunctionTable(&xdataInfo->functionTable,
             &xdataInfo->pdata,
             /*MaxEntryCount*/ 1,
             /*Valid entry count*/ 1,
             /*RangeBase*/ functionStart,
             /*RangeEnd*/ functionStart + functionSize);
         success = NT_SUCCESS(status);
+        hr = status;
+        
     }
     else
     {
         success = RtlAddFunctionTable(&xdataInfo->pdata, 1, functionStart);
+        if (!success)
+        {
+            hr = E_OUTOFMEMORY; // only OOM error can happen for RtlAddFunctionTable
+        }
+    }
+
+    if (!success)
+    {
+        Js::Throw::XDataRegistrationError(hr, functionStart);
     }
-    Js::Throw::CheckAndThrowOutOfMemory(success);
 
 #if DBG
     // Validate that the PDATA registration succeeded

lib/Common/Memory/arm/XDataAllocator.cpp

@@ -88,7 +88,10 @@ void XDataAllocator::Register(XDataAllocation * xdataInfo, DWORD functionStart,
         /*RangeBase*/ functionStart,
         /*RangeEnd*/ functionStart + functionSize);
 
-    Js::Throw::CheckAndThrowOutOfMemory(NT_SUCCESS(status));
+    if (!NT_SUCCESS(status))
+    {
+        Js::Throw::XDataRegistrationError(status, functionStart);
+    }
 
 #else  // !_WIN32
     Assert(ReadHead(xdataInfo->address));  // should be non-empty .eh_frame

lib/Common/Memory/arm64/XDataAllocator.cpp

@@ -132,11 +132,12 @@ void XDataAllocator::Register(XDataAllocation * xdataInfo, ULONG_PTR functionSta
         /*RangeBase*/ functionStart,
         /*RangeEnd*/ functionStart + functionSize);
     BOOLEAN success = NT_SUCCESS(status);
-    if (success)
+    Assert(!success || xdataInfo->functionTable != nullptr);
+
+    if (!success)
     {
-        Assert(xdataInfo->functionTable != nullptr);
+        Js::Throw::XDataRegistrationError(status, functionStart);
     }
-    Js::Throw::CheckAndThrowOutOfMemory(success);
 
 #if DBG
     // Validate that the PDATA registration succeeded