more experimenting

Author: wyrichte

lib/Runtime/Base/FunctionBody.cpp

@@ -8823,14 +8823,14 @@ namespace Js
 
     // Convert this function's return address to point to this function's LazyBailOutThunk. Also Thunk. Also put
     // a BailOutRecord on the stack for the thunk to use. Returns true if successful return address conversion.
-    void EntryPointInfo::ConvertFuncRetAddrToLazyBailOutThunk(BYTE **addressOfInstructionPointer, BYTE *stackFramePointer)
+    bool EntryPointInfo::ConvertFuncRetAddrToLazyBailOutThunk(BYTE **addressOfInstructionPointer, BYTE *stackFramePointer)
     {
         NativeEntryPointData* nativeEntryPointData = GetProcSpecificNativeEntryPoint();
 
         // This frame does not have a LazyBailOut; no need to jmp to the thunk, this frame can return normally.
         if (!nativeEntryPointData->GetHasLazyBailOut())
         {
-            return;
+            return false;
         }
 
         BYTE* instructionPointer = *addressOfInstructionPointer;
@@ -8845,7 +8845,7 @@ namespace Js
 
         if (bailOutRecord == nullptr)
         {
-            return;
+            return false;
         }
 
         // Change the instruction pointer of the frame to our thunk so that when
@@ -8861,7 +8861,7 @@ namespace Js
         BYTE *addressOfLazyBailOutRecordSlot = stackFramePointer + nativeEntryPointData->GetLazyBailOutRecordSlotOffset();
         *(reinterpret_cast<intptr_t *>(addressOfLazyBailOutRecordSlot)) = reinterpret_cast<intptr_t>(bailOutRecord);
 
-        return;
+        return true;
     }
 
     void EntryPointInfo::FreeJitTransferData()
@@ -9139,7 +9139,8 @@ namespace Js
         callsCount(0),
         jitMode(ExecutionMode::Interpreter),
         functionProxy(functionProxy),
-        nextEntryPoint(nullptr)
+        nextEntryPoint(nullptr),
+        shouldNotDelete(false)
     {
     }
 
@@ -9282,6 +9283,12 @@ namespace Js
 
     }
 
+    void FunctionEntryPointInfo::Invalidate(bool prolongEntryPoint)
+    {
+        return;
+    }
+
+
     FunctionEntryPointInfo* FunctionEntryPointInfo::InvalidateRet(bool prolongEntryPoint)
     {
         Assert(!this->functionProxy->IsDeferred());

lib/Runtime/Base/FunctionBody.h

@@ -583,7 +583,7 @@ namespace Js
         bool HasInlinees();
 
         // Unabbreviated: Convert this function's return address to the function's LazyBailOut thunk.
-        void ConvertFuncRetAddrToLazyBailOutThunk(BYTE **addressOfInstructionPointer, BYTE *framePointer);
+        bool ConvertFuncRetAddrToLazyBailOutThunk(BYTE **addressOfInstructionPointer, BYTE *framePointer);
 
         void CleanupNativeCode(ScriptContext * scriptContext);
 #if DBG_DUMP
@@ -624,6 +624,7 @@ namespace Js
         Field(uint32) lastCallsCount;
         Field(DWORD_PTR) lboNativeAddr;
         Field(ptrdiff_t) lboCodeSize;
+        Field(bool) shouldNotDelete;
 
     private:
         Field(ExecutionMode) jitMode;

lib/Runtime/Base/ThreadContext.cpp

@@ -3711,8 +3711,12 @@ ThreadContext::InvalidatePropertyGuardEntry(
             this->recyclableData->constructorCacheInvalidationCount = 0;
         }
     }
-
+    
+    /*
     if (propertyGuardEntry->hasLazyBailOut)
+    {
+    */
+    if (propertyGuardEntry->lazyBailOutEntryPoints && propertyGuardEntry->lazyBailOutEntryPoints->Count() > 0)
     {
         Assert(propertyGuardEntry->lazyBailOutEntryPoints);
         Assert(propertyGuardEntry->lazyBailOutEntryPoints->Count() > 0);
@@ -3748,15 +3752,23 @@ ThreadContext::InvalidatePropertyGuardEntry(
                         //       should set a flag on functionEntryPoint->scriptContext when ConvertFuncRetAddrToLazyBailOutThunk
                         //       returns false. Then, when an expected scenario completes, we should unset that flag. Once
                         //       ScriptContext closes, we should assert that the flag should be off.
-                        functionEntryPoint->ConvertFuncRetAddrToLazyBailOutThunk(
+                        bool didConvertRetAddrToThunk = functionEntryPoint->ConvertFuncRetAddrToLazyBailOutThunk(
                             stackWalker.GetCurrentAddressOfInstructionPointer(),
                             static_cast<BYTE*>(stackWalker.GetFramePointer())
                         );
+
+                        if (!didConvertRetAddrToThunk)
+                        {
+                            functionEntryPoint->shouldNotDelete = true;
+                        }
                     }
                 }
             }
         }
     }
+    /*
+    }
+    */
 
     if (propertyGuardEntry->lazyBailOutEntryPoints && propertyGuardEntry->lazyBailOutEntryPoints->Count() > 0)
     {
@@ -3767,16 +3779,20 @@ ThreadContext::InvalidatePropertyGuardEntry(
 
         }
 
-        propertyGuardEntry->lazyBailOutEntryPoints->Map([=](Js::FunctionEntryPointInfo* lazyBailOutEntryPoint, BYTE& dummy, const RecyclerWeakReference<Js::EntryPointInfo>* infoWeakRef)
+        propertyGuardEntry->lazyBailOutEntryPoints->Map([=](Js::EntryPointInfo* lazyBailOutEntryPoint, BYTE& dummy, const RecyclerWeakReference<Js::EntryPointInfo>* infoWeakRef)
         {
             if (lazyBailOutEntryPoint->IsCleanedUp())
             {
                 return;
             }
             OUTPUT_TRACE2(Js::LazyBailoutPhase, lazyBailOutEntryPoint->GetFunctionBody(), _u("Lazy bailout - Invalidation due to property: %s \n"), propertyRecord->GetBuffer());
-            Js::FunctionEntryPointInfo* newEntryPoint = lazyBailOutEntryPoint->InvalidateRet(true);
-            newEntryPoint->lboCodeSize = lazyBailOutEntryPoint->GetCodeSize();
-            newEntryPoint->lboNativeAddr = lazyBailOutEntryPoint->GetNativeAddress();
+            if (!((Js::FunctionEntryPointInfo*)(lazyBailOutEntryPoint))->shouldNotDelete)
+            {
+                /*Js::FunctionEntryPointInfo* newEntryPoint = */((Js::FunctionEntryPointInfo*)(lazyBailOutEntryPoint))->InvalidateRet(true);
+                ((Js::FunctionEntryPointInfo*)(lazyBailOutEntryPoint))->shouldNotDelete = false;
+            }
+            //newEntryPoint->lboCodeSize = lazyBailOutEntryPoint->GetCodeSize();
+            //newEntryPoint->lboNativeAddr = lazyBailOutEntryPoint->GetNativeAddress();
         });
 
         // TODO: make function.