Changeset 181250 in webkit

Timestamp:

Mar 8, 2015 4:58:40 PM (9 years ago)

Author:

akling@apple.com

Message:

JITThunks keeps finalized Weaks around, pinning WeakBlocks.
<​https://webkit.org/b/142454>

Reviewed by Darin Adler.

Make JITThunks a WeakHandleOwner so it can keep its host function map free of stale entries.
This fixes an issue I was seeing where a bunch of WeakBlocks stuck around with nothing but
finalized Weak<NativeExecutable> entries.

• jit/JITThunks.h:
• jit/JITThunks.cpp:

(JSC::JITThunks::finalize): Make JITThunks inherit from WeakHandleOwner so it can receive
a callback when the NativeExecutables get garbage collected.

(JSC::JITThunks::hostFunctionStub): Pass 'this' as the handle owner when creating Weaks.

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• jit/JITThunks.cpp (modified) (3 diffs)
• jit/JITThunks.h (modified) (3 diffs)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2015-03-08  Andreas Kling  <akling@apple.com>
+
+        JITThunks keeps finalized Weaks around, pinning WeakBlocks.
+        <https://webkit.org/b/142454>
+
+        Reviewed by Darin Adler.
+
+        Make JITThunks a WeakHandleOwner so it can keep its host function map free of stale entries.
+        This fixes an issue I was seeing where a bunch of WeakBlocks stuck around with nothing but
+        finalized Weak<NativeExecutable> entries.
+
+        * jit/JITThunks.h:
+        * jit/JITThunks.cpp:
+        (JSC::JITThunks::finalize): Make JITThunks inherit from WeakHandleOwner so it can receive
+        a callback when the NativeExecutables get garbage collected.
+
+        (JSC::JITThunks::hostFunctionStub): Pass 'this' as the handle owner when creating Weaks.
+
 2015-03-08  Andreas Kling  <akling@apple.com>
 

trunk/Source/JavaScriptCore/jit/JITThunks.cpp

@@ -77 +77 @@
 }
 
+void JITThunks::finalize(Handle<Unknown> handle, void*)
+{
+    auto* nativeExecutable = jsCast<NativeExecutable*>(handle.get().asCell());
+    weakRemove(*m_hostFunctionStubMap, std::make_pair(nativeExecutable->function(), nativeExecutable->constructor()), nativeExecutable);
+}
+
 NativeExecutable* JITThunks::hostFunctionStub(VM* vm, NativeFunction function, NativeFunction constructor)
 {
@@ -90 +96 @@
         adoptRef(new NativeJITCode(MacroAssemblerCodeRef::createSelfManagedCodeRef(ctiNativeConstruct(vm)), JITCode::HostCallThunk)),
         constructor, NoIntrinsic);
-    weakAdd(*m_hostFunctionStubMap, std::make_pair(function, constructor), Weak<NativeExecutable>(nativeExecutable));
+    weakAdd(*m_hostFunctionStubMap, std::make_pair(function, constructor), Weak<NativeExecutable>(nativeExecutable, this));
     return nativeExecutable;
 }
@@ -112 +118 @@
     
     NativeExecutable* nativeExecutable = NativeExecutable::create(*vm, forCall, function, forConstruct, callHostFunctionAsConstructor, intrinsic);
-    weakAdd(*m_hostFunctionStubMap, std::make_pair(function, &callHostFunctionAsConstructor), Weak<NativeExecutable>(nativeExecutable));
+    weakAdd(*m_hostFunctionStubMap, std::make_pair(function, &callHostFunctionAsConstructor), Weak<NativeExecutable>(nativeExecutable, this));
     return nativeExecutable;
 }

trunk/Source/JavaScriptCore/jit/JITThunks.h

@@ -35 +35 @@
 #include "ThunkGenerator.h"
 #include "Weak.h"
+#include "WeakHandleOwner.h"
 #include "WeakInlines.h"
 #include <wtf/HashMap.h>
@@ -45 +46 @@
 class NativeExecutable;
 
-class JITThunks {
+class JITThunks final : private WeakHandleOwner {
 public:
     JITThunks();
-    ~JITThunks();
+    virtual ~JITThunks();
 
     MacroAssemblerCodePtr ctiNativeCall(VM*);
@@ -65 +66 @@
     typedef Mutex Lock;
     typedef MutexLocker Locker;
+
+    void finalize(Handle<Unknown>, void* context) override;
     
     typedef HashMap<ThunkGenerator, MacroAssemblerCodeRef> CTIStubMap;