Changeset 121098 in webkit for trunk/Source/JavaScriptCore


Ignore:
Timestamp:
Jun 23, 2012, 6:41:40 AM (13 years ago)
Author:
[email protected]
Message:

Unreviewed, rolling out r121058.
​http://trac.webkit.org/changeset/121058
​https://bugs.webkit.org/show_bug.cgi?id=89809

Patch causes plugins tests to crash in GTK debug builds
(Requested by zdobersek on #webkit).

Patch by Sheriff Bot <​[email protected]> on 2012-06-23

Source/JavaScriptCore:

  • API/APIShims.h:

(JSC::APIEntryShimWithoutLock::APIEntryShimWithoutLock):
(JSC::APIEntryShimWithoutLock::~APIEntryShimWithoutLock):
(APIEntryShimWithoutLock):
(JSC::APIEntryShim::APIEntryShim):
(APIEntryShim):
(JSC::APICallbackShim::~APICallbackShim):

  • API/JSContextRef.cpp:

(JSGlobalContextCreate):
(JSGlobalContextCreateInGroup):
(JSGlobalContextRelease):
(JSContextCreateBacktrace):

  • JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
  • heap/CopiedSpace.cpp:

(JSC::CopiedSpace::tryAllocateSlowCase):

  • heap/Heap.cpp:

(JSC::Heap::protect):
(JSC::Heap::unprotect):
(JSC::Heap::collect):
(JSC::Heap::setActivityCallback):
(JSC::Heap::activityCallback):
(JSC::Heap::sweeper):

  • heap/Heap.h:

(Heap):

  • heap/HeapTimer.cpp:

(JSC::HeapTimer::~HeapTimer):
(JSC::HeapTimer::invalidate):
(JSC::HeapTimer::timerDidFire):
(JSC):

  • heap/HeapTimer.h:

(HeapTimer):

  • heap/IncrementalSweeper.cpp:

(JSC::IncrementalSweeper::doWork):
(JSC::IncrementalSweeper::create):

  • heap/IncrementalSweeper.h:

(IncrementalSweeper):

  • heap/MarkedAllocator.cpp:

(JSC::MarkedAllocator::allocateSlowCase):

  • heap/WeakBlock.cpp:

(JSC::WeakBlock::reap):

  • jsc.cpp:

(functionGC):
(functionReleaseExecutableMemory):
(jscmain):

  • runtime/Completion.cpp:

(JSC::checkSyntax):
(JSC::evaluate):

  • runtime/GCActivityCallback.h:

(DefaultGCActivityCallback):
(JSC::DefaultGCActivityCallback::create):

  • runtime/JSGlobalData.cpp:

(JSC::JSGlobalData::JSGlobalData):
(JSC::JSGlobalData::~JSGlobalData):
(JSC::JSGlobalData::sharedInstance):
(JSC::JSGlobalData::sharedInstanceInternal):

  • runtime/JSGlobalData.h:

(JSGlobalData):

  • runtime/JSGlobalObject.cpp:

(JSC::JSGlobalObject::~JSGlobalObject):
(JSC::JSGlobalObject::init):

  • runtime/JSLock.cpp:

(JSC):
(JSC::createJSLockCount):
(JSC::JSLock::lockCount):
(JSC::setLockCount):
(JSC::JSLock::JSLock):
(JSC::JSLock::lock):
(JSC::JSLock::unlock):
(JSC::JSLock::currentThreadIsHoldingLock):
(JSC::JSLock::DropAllLocks::DropAllLocks):
(JSC::JSLock::DropAllLocks::~DropAllLocks):

  • runtime/JSLock.h:

(JSC):
(JSLock):
(JSC::JSLock::JSLock):
(JSC::JSLock::~JSLock):
(DropAllLocks):

  • runtime/WeakGCMap.h:

(JSC::WeakGCMap::set):

  • testRegExp.cpp:

(realMain):

Source/WebCore:

  • bindings/js/GCController.cpp:

(WebCore::collect):
(WebCore::GCController::garbageCollectSoon):
(WebCore::GCController::garbageCollectNow):
(WebCore::GCController::discardAllCompiledCode):

  • bindings/js/JSCustomSQLStatementErrorCallback.cpp:

(WebCore::JSSQLStatementErrorCallback::handleEvent):

  • bindings/js/JSCustomVoidCallback.cpp:

(WebCore::JSCustomVoidCallback::handleEvent):

  • bindings/js/JSCustomXPathNSResolver.cpp:

(WebCore::JSCustomXPathNSResolver::lookupNamespaceURI):

  • bindings/js/JSErrorHandler.cpp:

(WebCore::JSErrorHandler::handleEvent):

  • bindings/js/JSEventCustom.cpp:

(WebCore::toJS):

  • bindings/js/JSEventListener.cpp:

(WebCore::JSEventListener::handleEvent):

  • bindings/js/JSInjectedScriptHostCustom.cpp:

(WebCore::InjectedScriptHost::nodeAsScriptValue):
(WebCore::JSInjectedScriptHost::inspectedObject):

  • bindings/js/JSInjectedScriptManager.cpp:

(WebCore::InjectedScriptManager::createInjectedScript):
(WebCore::InjectedScriptManager::canAccessInspectedWindow):

  • bindings/js/JSLazyEventListener.cpp:

(WebCore::JSLazyEventListener::initializeJSFunction):

  • bindings/js/JSMainThreadExecState.h:

(WebCore::JSMainThreadExecState::evaluate):

  • bindings/js/JSMutationCallbackCustom.cpp:

(WebCore::JSMutationCallback::handleEvent):

  • bindings/js/JSNodeFilterCondition.cpp:

(WebCore::JSNodeFilterCondition::acceptNode):

  • bindings/js/JSRequestAnimationFrameCallbackCustom.cpp:

(WebCore::JSRequestAnimationFrameCallback::handleEvent):

  • bindings/js/JavaScriptCallFrame.cpp:

(WebCore::JavaScriptCallFrame::evaluate):

  • bindings/js/PageScriptDebugServer.cpp:

(WebCore::PageScriptDebugServer::recompileAllJSFunctions):

  • bindings/js/ScheduledAction.cpp:

(WebCore::ScheduledAction::executeFunctionInContext):

  • bindings/js/ScriptCachedFrameData.cpp:

(WebCore::ScriptCachedFrameData::ScriptCachedFrameData):
(WebCore::ScriptCachedFrameData::restore):
(WebCore::ScriptCachedFrameData::clear):

  • bindings/js/ScriptController.cpp:

(WebCore::ScriptController::evaluateInWorld):
(WebCore::ScriptController::clearWindowShell):
(WebCore::ScriptController::initScript):
(WebCore::ScriptController::updateDocument):
(WebCore::ScriptController::cacheableBindingRootObject):
(WebCore::ScriptController::bindingRootObject):
(WebCore::ScriptController::windowScriptNPObject):
(WebCore::ScriptController::jsObjectForPluginElement):
(WebCore::ScriptController::clearScriptObjects):

  • bindings/js/ScriptControllerMac.mm:

(WebCore::ScriptController::windowScriptObject):

  • bindings/js/ScriptDebugServer.cpp:

(WebCore::ScriptDebugServer::dispatchDidPause):

  • bindings/js/ScriptEventListener.cpp:

(WebCore::eventListenerHandlerBody):
(WebCore::eventListenerHandlerLocation):

  • bindings/js/ScriptFunctionCall.cpp:

(WebCore::ScriptCallArgumentHandler::appendArgument):
(WebCore::ScriptFunctionCall::call):
(WebCore::ScriptFunctionCall::construct):
(WebCore::ScriptCallback::call):

  • bindings/js/ScriptObject.cpp:

(WebCore::ScriptGlobalObject::set):
(WebCore::ScriptGlobalObject::get):
(WebCore::ScriptGlobalObject::remove):

  • bindings/js/ScriptValue.cpp:

(WebCore::ScriptValue::getString):
(WebCore::ScriptValue::toInspectorValue):

  • bindings/js/WorkerScriptController.cpp:

(WebCore::WorkerScriptController::~WorkerScriptController):
(WebCore::WorkerScriptController::initScript):
(WebCore::WorkerScriptController::evaluate):
(WebCore::WorkerScriptController::disableEval):

  • bindings/objc/WebScriptObject.mm:

(_didExecute):
(-[WebScriptObject _setImp:originRootObject:rootObject:]):
(-[WebScriptObject _setOriginRootObject:andRootObject:]):
(-[WebScriptObject dealloc]):
(-[WebScriptObject finalize]):
(-[WebScriptObject callWebScriptMethod:withArguments:]):
(-[WebScriptObject evaluateWebScript:]):
(-[WebScriptObject setValue:forKey:]):
(-[WebScriptObject valueForKey:]):
(-[WebScriptObject removeWebScriptKey:]):
(-[WebScriptObject hasWebScriptKey:]):
(-[WebScriptObject stringRepresentation]):
(-[WebScriptObject webScriptValueAtIndex:]):
(-[WebScriptObject setWebScriptValueAtIndex:value:]):
(+[WebScriptObject _convertValueToObjcValue:originRootObject:rootObject:]):

  • bindings/scripts/CodeGeneratorJS.pm:

(GenerateCallbackImplementation):

  • bindings/scripts/test/JS/JSTestCallback.cpp:

(WebCore::JSTestCallback::callbackWithNoParam):
(WebCore::JSTestCallback::callbackWithClass1Param):
(WebCore::JSTestCallback::callbackWithClass2Param):
(WebCore::JSTestCallback::callbackWithStringList):
(WebCore::JSTestCallback::callbackWithBoolean):
(WebCore::JSTestCallback::callbackRequiresThisToPass):

  • bridge/NP_jsobject.cpp:

(_NPN_InvokeDefault):
(_NPN_Invoke):
(_NPN_Evaluate):
(_NPN_GetProperty):
(_NPN_SetProperty):
(_NPN_RemoveProperty):
(_NPN_HasProperty):
(_NPN_HasMethod):
(_NPN_Enumerate):
(_NPN_Construct):

  • bridge/c/c_class.cpp:

(JSC::Bindings::CClass::~CClass):
(JSC::Bindings::CClass::methodsNamed):
(JSC::Bindings::CClass::fieldNamed):

  • bridge/c/c_instance.cpp:

(JSC::Bindings::CInstance::moveGlobalExceptionToExecState):
(JSC::Bindings::CInstance::invokeMethod):
(JSC::Bindings::CInstance::invokeDefaultMethod):
(JSC::Bindings::CInstance::invokeConstruct):
(JSC::Bindings::CInstance::getPropertyNames):

  • bridge/c/c_runtime.cpp:

(JSC::Bindings::CField::valueFromInstance):
(JSC::Bindings::CField::setValueToInstance):

  • bridge/c/c_utility.cpp:

(JSC::Bindings::convertValueToNPVariant):
(JSC::Bindings::convertNPVariantToValue):

  • bridge/jni/jni_jsobject.mm:

(JavaJSObject::call):
(JavaJSObject::eval):
(JavaJSObject::getMember):
(JavaJSObject::setMember):
(JavaJSObject::removeMember):
(JavaJSObject::getSlot):
(JavaJSObject::setSlot):
(JavaJSObject::toString):
(JavaJSObject::convertValueToJObject):
(JavaJSObject::convertJObjectToValue):

  • bridge/jni/jni_objc.mm:

(JSC::Bindings::dispatchJNICall):

  • bridge/jni/jsc/JNIUtilityPrivate.cpp:

(JSC::Bindings::convertValueToJValue):

  • bridge/jni/jsc/JavaClassJSC.cpp:

(JavaClass::JavaClass):
(JavaClass::~JavaClass):

  • bridge/jni/jsc/JavaInstanceJSC.cpp:

(JavaInstance::stringValue):

  • bridge/jni/jsc/JavaMethodJSC.cpp:

(appendClassName):
(JavaMethod::signature):

  • bridge/jni/jsc/JavaStringJSC.h:

(JSC::Bindings::JavaString::JavaString):
(JSC::Bindings::JavaString::~JavaString):
(JSC::Bindings::JavaString::utf8):
(JSC::Bindings::JavaString::init):

  • bridge/jsc/BridgeJSC.cpp:

(JSC::Bindings::Instance::createRuntimeObject):
(JSC::Bindings::Instance::newRuntimeObject):

  • bridge/objc/objc_instance.mm:

(ObjcInstance::moveGlobalExceptionToExecState):
(ObjcInstance::invokeObjcMethod):
(ObjcInstance::invokeDefaultMethod):
(ObjcInstance::setValueOfUndefinedField):
(ObjcInstance::getValueOfUndefinedField):

  • bridge/objc/objc_runtime.mm:

(JSC::Bindings::ObjcField::valueFromInstance):
(JSC::Bindings::ObjcField::setValueToInstance):

  • bridge/objc/objc_utility.mm:

(JSC::Bindings::convertValueToObjcValue):
(JSC::Bindings::convertNSStringToString):
(JSC::Bindings::convertObjcValueToValue):

  • bridge/qt/qt_instance.cpp:

(JSC::Bindings::QtInstance::~QtInstance):
(JSC::Bindings::QtInstance::getQtInstance):
(JSC::Bindings::QtInstance::newRuntimeObject):

  • bridge/qt/qt_pixmapruntime.cpp:

(JSC::Bindings::QtPixmapInstance::createPixmapRuntimeObject):

  • bridge/qt/qt_runtime.cpp:

(JSC::Bindings::convertValueToQVariant):
(JSC::Bindings::convertQVariantToValue):
(JSC::Bindings::QtRuntimeMetaMethod::call):
(JSC::Bindings::QtRuntimeConnectionMethod::call):

  • bridge/qt/qt_runtime_qt4.cpp:

(JSC::Bindings::convertValueToQVariant):
(JSC::Bindings::convertQVariantToValue):
(JSC::Bindings::QtRuntimeMetaMethod::call):
(JSC::Bindings::QtRuntimeConnectionMethod::call):

  • html/HTMLCanvasElement.cpp:

(WebCore::HTMLCanvasElement::createImageBuffer):

  • html/HTMLImageLoader.cpp:

(WebCore::HTMLImageLoader::notifyFinished):

  • plugins/PluginView.cpp:

(WebCore::PluginView::start):
(WebCore::PluginView::stop):
(WebCore::PluginView::performRequest):
(WebCore::PluginView::npObject):
(WebCore::PluginView::privateBrowsingStateChanged):

  • plugins/blackberry/PluginViewBlackBerry.cpp:

(WebCore::PluginView::dispatchNPEvent):
(WebCore::PluginView::setNPWindowIfNeeded):
(WebCore::PluginView::platformStart):
(WebCore::PluginView::getWindowInfo):

  • plugins/efl/PluginViewEfl.cpp:

(WebCore::PluginView::dispatchNPEvent):

  • plugins/gtk/PluginViewGtk.cpp:

(WebCore::PluginView::dispatchNPEvent):
(WebCore::PluginView::handleKeyboardEvent):
(WebCore::PluginView::handleMouseEvent):
(WebCore::PluginView::setNPWindowIfNeeded):
(WebCore::PluginView::platformStart):

  • plugins/mac/PluginViewMac.mm:

(WebCore::PluginView::setNPWindowIfNeeded):
(WebCore::PluginView::dispatchNPEvent):

  • plugins/qt/PluginViewQt.cpp:

(WebCore::PluginView::dispatchNPEvent):
(WebCore::PluginView::setNPWindowIfNeeded):
(WebCore::PluginView::platformStart):

  • plugins/win/PluginViewWin.cpp:

(WebCore::PluginView::dispatchNPEvent):
(WebCore::PluginView::handleKeyboardEvent):
(WebCore::PluginView::handleMouseEvent):
(WebCore::PluginView::setNPWindowRect):

  • testing/js/WebCoreTestSupport.cpp:

(WebCoreTestSupport::injectInternalsObject):
(WebCoreTestSupport::resetInternalsObject):

  • xml/XMLHttpRequest.cpp:

(WebCore::XMLHttpRequest::dropProtection):

Source/WebKit/blackberry:

  • Api/BlackBerryGlobal.cpp:

(BlackBerry::WebKit::clearMemoryCaches):

  • WebCoreSupport/ClientExtension.cpp:
  • WebCoreSupport/PagePopupBlackBerry.cpp:

(WebCore::PagePopupBlackBerry::installDomFunction):

  • WebKitSupport/DumpRenderTreeSupport.cpp:

(DumpRenderTreeSupport::computedStyleIncludingVisitedInfo):

Source/WebKit/efl:

  • ewk/ewk_frame.cpp:

(ewk_frame_script_execute):

  • ewk/ewk_view.cpp:

(ewk_view_js_object_add):

Source/WebKit/gtk:

  • WebCoreSupport/DumpRenderTreeSupportGtk.cpp:

(DumpRenderTreeSupportGtk::gcCountJavascriptObjects):

Source/WebKit/mac:

  • DOM/WebDOMOperations.mm:

(JSC):

  • Misc/WebCoreStatistics.mm:

(+[WebCoreStatistics javaScriptObjectsCount]):
(+[WebCoreStatistics javaScriptGlobalObjectsCount]):
(+[WebCoreStatistics javaScriptProtectedObjectsCount]):
(+[WebCoreStatistics javaScriptProtectedGlobalObjectsCount]):
(+[WebCoreStatistics javaScriptProtectedObjectTypeCounts]):
(+[WebCoreStatistics javaScriptObjectTypeCounts]):
(+[WebCoreStatistics shouldPrintExceptions]):
(+[WebCoreStatistics setShouldPrintExceptions:]):
(+[WebCoreStatistics memoryStatistics]):
(+[WebCoreStatistics javaScriptReferencedObjectsCount]):

  • Plugins/Hosted/NetscapePluginInstanceProxy.mm:

(WebKit::NetscapePluginInstanceProxy::evaluate):
(WebKit::NetscapePluginInstanceProxy::invoke):
(WebKit::NetscapePluginInstanceProxy::invokeDefault):
(WebKit::NetscapePluginInstanceProxy::construct):
(WebKit::NetscapePluginInstanceProxy::getProperty):
(WebKit::NetscapePluginInstanceProxy::setProperty):
(WebKit::NetscapePluginInstanceProxy::removeProperty):
(WebKit::NetscapePluginInstanceProxy::hasMethod):
(WebKit::NetscapePluginInstanceProxy::enumerate):
(WebKit::NetscapePluginInstanceProxy::addValueToArray):
(WebKit::NetscapePluginInstanceProxy::moveGlobalExceptionToExecState):

  • Plugins/WebNetscapePluginStream.mm:

(WebNetscapePluginStream::wantsAllStreams):

  • Plugins/WebNetscapePluginView.mm:

(-[WebNetscapePluginView sendEvent:isDrawRect:]):
(-[WebNetscapePluginView privateBrowsingModeDidChange]):
(-[WebNetscapePluginView setWindowIfNecessary]):
(-[WebNetscapePluginView createPluginScriptableObject]):
(-[WebNetscapePluginView getFormValue:]):
(-[WebNetscapePluginView evaluateJavaScriptPluginRequest:]):
(-[WebNetscapePluginView webFrame:didFinishLoadWithReason:]):
(-[WebNetscapePluginView loadPluginRequest:]):
(-[WebNetscapePluginView _printedPluginBitmap]):

  • Plugins/WebPluginController.mm:

(+[WebPluginController plugInViewWithArguments:fromPluginPackage:]):
(-[WebPluginController stopOnePlugin:]):
(-[WebPluginController destroyOnePlugin:]):
(-[WebPluginController startAllPlugins]):
(-[WebPluginController addPlugin:]):

  • WebView/WebFrame.mm:

(-[WebFrame _stringByEvaluatingJavaScriptFromString:forceUserGesture:]):
(-[WebFrame _stringByEvaluatingJavaScriptFromString:withGlobalObject:inScriptWorld:]):

  • WebView/WebScriptDebugDelegate.mm:

(-[WebScriptCallFrame scopeChain]):
(-[WebScriptCallFrame evaluateWebScript:]):

  • WebView/WebView.mm:

(+[WebView _reportException:inContext:]):
(-[WebView aeDescByEvaluatingJavaScriptFromString:]):
(-[WebView _computedStyleIncludingVisitedInfo:forElement:]):

Source/WebKit/qt:

  • Api/qwebframe.cpp:

(QWebFramePrivate::addQtSenderToGlobalObject):
(QWebFrame::addToJavaScriptWindowObject):

  • WebCoreSupport/DumpRenderTreeSupportQt.cpp:

(DumpRenderTreeSupportQt::injectInternalsObject):
(DumpRenderTreeSupportQt::resetInternalsObject):

Source/WebKit/win:

  • WebCoreStatistics.cpp:

(WebCoreStatistics::javaScriptObjectsCount):
(WebCoreStatistics::javaScriptGlobalObjectsCount):
(WebCoreStatistics::javaScriptProtectedObjectsCount):
(WebCoreStatistics::javaScriptProtectedGlobalObjectsCount):
(WebCoreStatistics::javaScriptProtectedObjectTypeCounts):

  • WebFrame.cpp:

(WebFrame::stringByEvaluatingJavaScriptInScriptWorld):

  • WebJavaScriptCollector.cpp:

(WebJavaScriptCollector::objectCount):

  • WebView.cpp:

(WebView::stringByEvaluatingJavaScriptFromString):
(WebView::reportException):
(WebView::elementFromJS):

Source/WebKit2:

  • Shared/mac/WebMemorySampler.mac.mm:

(WebKit::WebMemorySampler::sampleWebKit):

  • WebProcess/InjectedBundle/InjectedBundle.cpp:

(WebKit::InjectedBundle::javaScriptObjectsCount):
(WebKit::InjectedBundle::reportException):

  • WebProcess/Plugins/Netscape/JSNPObject.cpp:

(WebKit::JSNPObject::callMethod):
(WebKit::JSNPObject::callObject):
(WebKit::JSNPObject::callConstructor):
(WebKit::JSNPObject::put):
(WebKit::JSNPObject::deleteProperty):
(WebKit::JSNPObject::getOwnPropertyNames):
(WebKit::JSNPObject::propertyGetter):

  • WebProcess/Plugins/Netscape/NPJSObject.cpp:

(WebKit::NPJSObject::hasMethod):
(WebKit::NPJSObject::invoke):
(WebKit::NPJSObject::invokeDefault):
(WebKit::NPJSObject::hasProperty):
(WebKit::NPJSObject::getProperty):
(WebKit::NPJSObject::setProperty):
(WebKit::NPJSObject::removeProperty):
(WebKit::NPJSObject::enumerate):
(WebKit::NPJSObject::construct):

  • WebProcess/Plugins/Netscape/NPRuntimeObjectMap.cpp:

(WebKit::NPRuntimeObjectMap::convertJSValueToNPVariant):
(WebKit::NPRuntimeObjectMap::evaluate):
(WebKit::NPRuntimeObjectMap::moveGlobalExceptionToExecState):

  • WebProcess/WebPage/WebFrame.cpp:

(WebKit::WebFrame::jsWrapperForWorld):
(WebKit::WebFrame::computedStyleIncludingVisitedInfo):

  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::runJavaScriptInMainFrame):

  • WebProcess/WebProcess.cpp:

(WebKit::WebProcess::getWebCoreStatistics):

Location:
trunk/Source/JavaScriptCore
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/API/APIShims.h

    r121058 r121098  
    2929#include "CallFrame.h"
    3030#include "GCActivityCallback.h"
    31 #include "IncrementalSweeper.h"
    3231#include "JSLock.h"
    3332#include <wtf/WTFThreadData.h>
    … …  
    3635
    3736class APIEntryShimWithoutLock {
    38 public:
    39     enum RefGlobalDataTag { DontRefGlobalData = 0, RefGlobalData };
    40 
    4137protected:
    42     APIEntryShimWithoutLock(JSGlobalData* globalData, bool registerThread, RefGlobalDataTag shouldRefGlobalData)
    43         : m_shouldRefGlobalData(shouldRefGlobalData)
    44         , m_globalData(globalData)
     38    APIEntryShimWithoutLock(JSGlobalData* globalData, bool registerThread)
     39        : m_globalData(globalData)
    4540        , m_entryIdentifierTable(wtfThreadData().setCurrentIdentifierTable(globalData->identifierTable))
    4641    {
    47         if (shouldRefGlobalData)
    48             m_globalData->ref();
    4942        UNUSED_PARAM(registerThread);
    5043        if (registerThread)
    5144            globalData->heap.machineThreads().addCurrentThread();
    5245        m_globalData->heap.activityCallback()->synchronize();
    53         m_globalData->heap.sweeper()->synchronize();
     46        m_globalData->timeoutChecker.start();
    5447    }
    5548
    5649    ~APIEntryShimWithoutLock()
    5750    {
     51        m_globalData->timeoutChecker.stop();
    5852        wtfThreadData().setCurrentIdentifierTable(m_entryIdentifierTable);
    59         if (m_shouldRefGlobalData)
    60             m_globalData->deref();
    6153    }
    6254
    63 protected:
    64     RefGlobalDataTag m_shouldRefGlobalData;
     55private:
    6556    JSGlobalData* m_globalData;
    6657    IdentifierTable* m_entryIdentifierTable;
    … …  
    7162    // Normal API entry
    7263    APIEntryShim(ExecState* exec, bool registerThread = true)
    73         : APIEntryShimWithoutLock(&exec->globalData(), registerThread, RefGlobalData)
     64        : APIEntryShimWithoutLock(&exec->globalData(), registerThread)
     65        , m_lock(exec)
    7466    {
    75         init();
    76     }
    77 
    78     // This constructor is necessary for HeapTimer to prevent it from accidentally resurrecting
    79     // the ref count of a "dead" JSGlobalData.
    80     APIEntryShim(JSGlobalData* globalData, RefGlobalDataTag refGlobalData, bool registerThread = true)
    81         : APIEntryShimWithoutLock(globalData, registerThread, refGlobalData)
    82     {
    83         init();
    8467    }
    8568
    8669    // JSPropertyNameAccumulator only has a globalData.
    8770    APIEntryShim(JSGlobalData* globalData, bool registerThread = true)
    88         : APIEntryShimWithoutLock(globalData, registerThread, RefGlobalData)
     71        : APIEntryShimWithoutLock(globalData, registerThread)
     72        , m_lock(globalData->isSharedInstance() ? LockForReal : SilenceAssertionsOnly)
    8973    {
    90         init();
    91     }
    92 
    93     ~APIEntryShim()
    94     {
    95         m_globalData->timeoutChecker.stop();
    96         m_globalData->apiLock().unlock();
    9774    }
    9875
    9976private:
    100     void init()
    101     {
    102         m_globalData->apiLock().lock();
    103         m_globalData->timeoutChecker.start();
    104     }
     77    JSLock m_lock;
    10578};
    10679
    … …  
    11689    ~APICallbackShim()
    11790    {
     91        m_globalData->heap.activityCallback()->synchronize();
    11892        wtfThreadData().setCurrentIdentifierTable(m_globalData->identifierTable);
    11993    }

  • trunk/Source/JavaScriptCore/API/JSContextRef.cpp

    r121058 r121098  
    7979    // we use a shared one for backwards compatibility.
    8080    if (NSVersionOfLinkTimeLibrary("JavaScriptCore") <= webkitFirstVersionWithConcurrentGlobalContexts) {
     81        JSLock lock(LockForReal);
    8182        return JSGlobalContextCreateInGroup(toRef(&JSGlobalData::sharedInstance()), globalObjectClass);
    8283    }
    … …  
    9091    initializeThreading();
    9192
     93    JSLock lock(LockForReal);
    9294    RefPtr<JSGlobalData> globalData = group ? PassRefPtr<JSGlobalData>(toJS(group)) : JSGlobalData::createContextGroup(ThreadStackTypeSmall);
    9395
    9496    APIEntryShim entryShim(globalData.get(), false);
     97
    9598    globalData->makeUsableFromMultipleThreads();
    9699
    … …  
    122125void JSGlobalContextRelease(JSGlobalContextRef ctx)
    123126{
    124     IdentifierTable* savedIdentifierTable;
    125     ExecState* exec = toJS(ctx);
    126     {
    127         JSLockHolder lock(exec);
    128 
    129         JSGlobalData& globalData = exec->globalData();
    130         savedIdentifierTable = wtfThreadData().setCurrentIdentifierTable(globalData.identifierTable);
    131 
    132         bool protectCountIsZero = Heap::heap(exec->dynamicGlobalObject())->unprotect(exec->dynamicGlobalObject());
    133         if (protectCountIsZero)
    134             globalData.heap.reportAbandonedObjectGraph();
    135         globalData.deref();
    136     }
     127    ExecState* exec = toJS(ctx);
     128    JSLock lock(exec);
     129
     130    JSGlobalData& globalData = exec->globalData();
     131    IdentifierTable* savedIdentifierTable = wtfThreadData().setCurrentIdentifierTable(globalData.identifierTable);
     132
     133    bool protectCountIsZero = Heap::heap(exec->dynamicGlobalObject())->unprotect(exec->dynamicGlobalObject());
     134    if (protectCountIsZero) {
     135        globalData.heap.activityCallback()->synchronize();
     136        globalData.heap.reportAbandonedObjectGraph();
     137    }
     138    globalData.deref();
    137139
    138140    wtfThreadData().setCurrentIdentifierTable(savedIdentifierTable);
    … …  
    165167{
    166168    ExecState* exec = toJS(ctx);
    167     JSLockHolder lock(exec);
     169    JSLock lock(exec);
    168170
    169171    unsigned count = 0;

  • trunk/Source/JavaScriptCore/ChangeLog

    r121083 r121098  
     12012-06-23  Sheriff Bot  <[email protected]>
     2
     3        Unreviewed, rolling out r121058.
     4        http://trac.webkit.org/changeset/121058
     5        https://bugs.webkit.org/show_bug.cgi?id=89809
     6
     7        Patch causes plugins tests to crash in GTK debug builds
     8        (Requested by zdobersek on #webkit).
     9
     10        * API/APIShims.h:
     11        (JSC::APIEntryShimWithoutLock::APIEntryShimWithoutLock):
     12        (JSC::APIEntryShimWithoutLock::~APIEntryShimWithoutLock):
     13        (APIEntryShimWithoutLock):
     14        (JSC::APIEntryShim::APIEntryShim):
     15        (APIEntryShim):
     16        (JSC::APICallbackShim::~APICallbackShim):
     17        * API/JSContextRef.cpp:
     18        (JSGlobalContextCreate):
     19        (JSGlobalContextCreateInGroup):
     20        (JSGlobalContextRelease):
     21        (JSContextCreateBacktrace):
     22        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
     23        * heap/CopiedSpace.cpp:
     24        (JSC::CopiedSpace::tryAllocateSlowCase):
     25        * heap/Heap.cpp:
     26        (JSC::Heap::protect):
     27        (JSC::Heap::unprotect):
     28        (JSC::Heap::collect):
     29        (JSC::Heap::setActivityCallback):
     30        (JSC::Heap::activityCallback):
     31        (JSC::Heap::sweeper):
     32        * heap/Heap.h:
     33        (Heap):
     34        * heap/HeapTimer.cpp:
     35        (JSC::HeapTimer::~HeapTimer):
     36        (JSC::HeapTimer::invalidate):
     37        (JSC::HeapTimer::timerDidFire):
     38        (JSC):
     39        * heap/HeapTimer.h:
     40        (HeapTimer):
     41        * heap/IncrementalSweeper.cpp:
     42        (JSC::IncrementalSweeper::doWork):
     43        (JSC::IncrementalSweeper::create):
     44        * heap/IncrementalSweeper.h:
     45        (IncrementalSweeper):
     46        * heap/MarkedAllocator.cpp:
     47        (JSC::MarkedAllocator::allocateSlowCase):
     48        * heap/WeakBlock.cpp:
     49        (JSC::WeakBlock::reap):
     50        * jsc.cpp:
     51        (functionGC):
     52        (functionReleaseExecutableMemory):
     53        (jscmain):
     54        * runtime/Completion.cpp:
     55        (JSC::checkSyntax):
     56        (JSC::evaluate):
     57        * runtime/GCActivityCallback.h:
     58        (DefaultGCActivityCallback):
     59        (JSC::DefaultGCActivityCallback::create):
     60        * runtime/JSGlobalData.cpp:
     61        (JSC::JSGlobalData::JSGlobalData):
     62        (JSC::JSGlobalData::~JSGlobalData):
     63        (JSC::JSGlobalData::sharedInstance):
     64        (JSC::JSGlobalData::sharedInstanceInternal):
     65        * runtime/JSGlobalData.h:
     66        (JSGlobalData):
     67        * runtime/JSGlobalObject.cpp:
     68        (JSC::JSGlobalObject::~JSGlobalObject):
     69        (JSC::JSGlobalObject::init):
     70        * runtime/JSLock.cpp:
     71        (JSC):
     72        (JSC::createJSLockCount):
     73        (JSC::JSLock::lockCount):
     74        (JSC::setLockCount):
     75        (JSC::JSLock::JSLock):
     76        (JSC::JSLock::lock):
     77        (JSC::JSLock::unlock):
     78        (JSC::JSLock::currentThreadIsHoldingLock):
     79        (JSC::JSLock::DropAllLocks::DropAllLocks):
     80        (JSC::JSLock::DropAllLocks::~DropAllLocks):
     81        * runtime/JSLock.h:
     82        (JSC):
     83        (JSLock):
     84        (JSC::JSLock::JSLock):
     85        (JSC::JSLock::~JSLock):
     86        (DropAllLocks):
     87        * runtime/WeakGCMap.h:
     88        (JSC::WeakGCMap::set):
     89        * testRegExp.cpp:
     90        (realMain):
     91
    1922012-06-22  Alexandru Chiculita  <[email protected]>
    293

  • trunk/Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def

    r121058 r121098  
    77    ??0DateInstance@JSC@@IAE@PAVExecState@1@PAVStructure@1@@Z
    88    ??0DefaultGCActivityCallback@JSC@@QAE@PAVHeap@1@@Z
    9     ??0DropAllLocks@JSLock@JSC@@QAE@PAVExecState@2@@Z
    10     ??0DropAllLocks@JSLock@JSC@@QAE@PAVJSGlobalData@2@@Z
     9    ??0DropAllLocks@JSLock@JSC@@QAE@W4JSLockBehavior@2@@Z
    1110    ??0DynamicGlobalObjectScope@JSC@@QAE@AAVJSGlobalData@1@PAVJSGlobalObject@1@@Z
    1211    ??0InternalFunction@JSC@@IAE@PAVJSGlobalObject@1@PAVStructure@1@@Z
    13     ??0JSLockHolder@JSC@@QAE@AAVJSGlobalData@1@@Z
    14     ??0JSLockHolder@JSC@@QAE@PAVExecState@1@@Z
    15     ??0JSLockHolder@JSC@@QAE@PAVJSGlobalData@1@@Z
     12    ??0JSLock@JSC@@QAE@PAVExecState@1@@Z
    1613    ??0MD5@WTF@@QAE@XZ
    1714    ??0Mutex@WTF@@QAE@XZ
    … …  
    3633    ??1JSGlobalData@JSC@@QAE@XZ
    3734    ??1JSGlobalObject@JSC@@QAE@XZ
    38     ??1JSLockHolder@JSC@@QAE@XZ
    3935    ??1Mutex@WTF@@QAE@XZ
    4036    ??1RefCountedLeakCounter@WTF@@QAE@XZ
    … …  
    128124    ?cryptographicallyRandomValues@WTF@@YAXPAXI@Z
    129125    ?currentThread@WTF@@YAIXZ
     126    ?currentThreadIsHoldingLock@JSLock@JSC@@SA_NXZ
    130127    ?currentTime@WTF@@YANXZ
    131128    ?data@CString@WTF@@QBEPBDXZ
    … …  
    239236    ?jsString@JSC@@YAPAVJSString@1@PAVJSGlobalData@1@ABVUString@1@@Z
    240237    ?length@CString@WTF@@QBEIXZ
    241     ?lock@JSLock@JSC@@QAEXXZ
     238    ?lock@JSLock@JSC@@SAXW4JSLockBehavior@2@@Z
    242239    ?lock@Mutex@WTF@@QAEXXZ
    243240    ?lockAtomicallyInitializedStaticMutex@WTF@@YAXXZ
     241    ?lockCount@JSLock@JSC@@SAHXZ
    244242    ?match@RegExp@JSC@@QAEHAAVJSGlobalData@2@ABVUString@2@IAAV?$Vector@H$0CA@@WTF@@@Z
    245243    ?materializePropertyMap@Structure@JSC@@AAEXAAVJSGlobalData@2@@Z
    … …  
    326324    ?substringSharingImpl@UString@JSC@@QBE?AV12@II@Z
    327325    ?suggestedNewPropertyStorageSize@Structure@JSC@@QAEIXZ
    328     ?sweeper@Heap@JSC@@QAEPAVIncrementalSweeper@2@XZ
    329326    ?synthesizePrototype@JSValue@JSC@@QBEPAVJSObject@2@PAVExecState@2@@Z
    330327    ?thisObject@DebuggerCallFrame@JSC@@QBEPAVJSObject@2@XZ
    … …  
    356353    ?tryLock@Mutex@WTF@@QAE_NXZ
    357354    ?type@DebuggerCallFrame@JSC@@QBE?AW4Type@12@XZ
    358     ?unlock@JSLock@JSC@@QAEXXZ
     355    ?unlock@JSLock@JSC@@SAXW4JSLockBehavior@2@@Z
    359356    ?unlock@Mutex@WTF@@QAEXXZ
    360357    ?unlockAtomicallyInitializedStaticMutex@WTF@@YAXXZ

  • trunk/Source/JavaScriptCore/heap/CopiedSpace.cpp

    r121058 r121098  
    6767        return tryAllocateOversize(bytes, outPtr);
    6868   
    69     ASSERT(m_heap->globalData()->apiLock().currentThreadIsHoldingLock());
    7069    m_heap->didAllocate(m_allocator.currentCapacity());
    7170

  • trunk/Source/JavaScriptCore/heap/Heap.cpp

    r121058 r121098  
    161161}
    162162
    163 static inline bool isValidSharedInstanceThreadState(JSGlobalData* globalData)
    164 {
    165     return globalData->apiLock().currentThreadIsHoldingLock();
     163static inline bool isValidSharedInstanceThreadState()
     164{
     165    if (!JSLock::lockCount())
     166        return false;
     167
     168    if (!JSLock::currentThreadIsHoldingLock())
     169        return false;
     170
     171    return true;
    166172}
    167173
    … …  
    171177        return false;
    172178
    173     if (globalData->isSharedInstance() && !isValidSharedInstanceThreadState(globalData))
     179    if (globalData->isSharedInstance() && !isValidSharedInstanceThreadState())
    174180        return false;
    175181
    … …  
    322328{
    323329    ASSERT(k);
    324     ASSERT(m_globalData->apiLock().currentThreadIsHoldingLock());
     330    ASSERT(JSLock::currentThreadIsHoldingLock() || !m_globalData->isSharedInstance());
    325331
    326332    if (!k.isCell())
    … …  
    333339{
    334340    ASSERT(k);
    335     ASSERT(m_globalData->apiLock().currentThreadIsHoldingLock());
     341    ASSERT(JSLock::currentThreadIsHoldingLock() || !m_globalData->isSharedInstance());
    336342
    337343    if (!k.isCell())
    … …  
    687693   
    688694    GCPHASE(Collect);
    689     ASSERT(globalData()->apiLock().currentThreadIsHoldingLock());
    690695    ASSERT(globalData()->identifierTable == wtfThreadData().currentIdentifierTable());
    691696    ASSERT(m_isSafeToCollect);
    … …  
    773778}
    774779
    775 void Heap::setActivityCallback(GCActivityCallback* activityCallback)
     780void Heap::setActivityCallback(PassOwnPtr<GCActivityCallback> activityCallback)
    776781{
    777782    m_activityCallback = activityCallback;
    … …  
    780785GCActivityCallback* Heap::activityCallback()
    781786{
    782     return m_activityCallback;
     787    return m_activityCallback.get();
    783788}
    784789
    785790IncrementalSweeper* Heap::sweeper()
    786791{
    787     return m_sweeper;
     792    return m_sweeper.get();
    788793}
    789794

  • trunk/Source/JavaScriptCore/heap/Heap.h

    r121058 r121098  
    100100
    101101        JS_EXPORT_PRIVATE GCActivityCallback* activityCallback();
    102         JS_EXPORT_PRIVATE void setActivityCallback(GCActivityCallback*);
     102        JS_EXPORT_PRIVATE void setActivityCallback(PassOwnPtr<GCActivityCallback>);
    103103        JS_EXPORT_PRIVATE void setGarbageCollectionTimerEnabled(bool);
    104104
    105         JS_EXPORT_PRIVATE IncrementalSweeper* sweeper();
     105        IncrementalSweeper* sweeper();
    106106
    107107        // true if an allocation or collection is in progress
    … …  
    238238        double m_lastCodeDiscardTime;
    239239
     240        OwnPtr<GCActivityCallback> m_activityCallback;
     241        OwnPtr<IncrementalSweeper> m_sweeper;
     242       
    240243        DoublyLinkedList<ExecutableBase> m_compiledCode;
    241        
    242         GCActivityCallback* m_activityCallback;
    243         IncrementalSweeper* m_sweeper;
    244244    };
    245245

  • trunk/Source/JavaScriptCore/heap/HeapTimer.cpp

    r121058 r121098  
    2727#include "HeapTimer.h"
    2828
    29 #include "APIShims.h"
    30 #include "JSObject.h"
    31 #include "JSString.h"
    32 #include "ScopeChain.h"
    3329#include <wtf/Threading.h>
    3430
    … …  
    5147HeapTimer::~HeapTimer()
    5248{
    53     CFRunLoopRemoveTimer(m_runLoop.get(), m_timer.get(), kCFRunLoopCommonModes);
    54     CFRunLoopTimerInvalidate(m_timer.get());
     49    invalidate();
    5550}
    5651
    … …  
    6661void HeapTimer::invalidate()
    6762{
    68     m_globalData = 0;
    69     CFRunLoopTimerSetNextFireDate(m_timer.get(), CFAbsoluteTimeGetCurrent() - s_decade);
    70 }
    71 
    72 void HeapTimer::didStartVMShutdown()
    73 {
    74     if (CFRunLoopGetCurrent() == m_runLoop.get()) {
    75         invalidate();
    76         delete this;
    77         return;
    78     }
    79     ASSERT(!m_globalData->apiLock().currentThreadIsHoldingLock());
    80     MutexLocker locker(m_shutdownMutex);
    81     invalidate();
     63    CFRunLoopRemoveTimer(m_runLoop.get(), m_timer.get(), kCFRunLoopCommonModes);
     64    CFRunLoopTimerInvalidate(m_timer.get());
    8265}
    8366
    … …  
    8568{
    8669    HeapTimer* agent = static_cast<HeapTimer*>(info);
    87     agent->m_shutdownMutex.lock();
    88     if (!agent->m_globalData) {
    89         agent->m_shutdownMutex.unlock();
    90         delete agent;
    91         return;
    92     }
    93     {
    94         // We don't ref here to prevent us from resurrecting the ref count of a "dead" JSGlobalData.
    95         APIEntryShim shim(agent->m_globalData, APIEntryShimWithoutLock::DontRefGlobalData);
    96         agent->doWork();
    97     }
    98     agent->m_shutdownMutex.unlock();
     70    agent->doWork();
    9971}
    10072
    … …  
    11082}
    11183
    112 void HeapTimer::didStartVMShutdown()
    113 {
    114     delete this;
    115 }
    116 
    11784void HeapTimer::synchronize()
    11885{
    … …  
    12390}
    12491
     92
    12593#endif
    12694   

  • trunk/Source/JavaScriptCore/heap/HeapTimer.h

    r121058 r121098  
    2828
    2929#include <wtf/RetainPtr.h>
    30 #include <wtf/Threading.h>
    3130
    3231#if USE(CF)
    … …  
    4847   
    4948    virtual ~HeapTimer();
    50 
    51     void didStartVMShutdown();
     49   
    5250    virtual void synchronize();
    5351    virtual void doWork() = 0;
    … …  
    6260    RetainPtr<CFRunLoopRef> m_runLoop;
    6361    CFRunLoopTimerContext m_context;
    64 
    65     Mutex m_shutdownMutex;
    6662#endif
    6763   

  • trunk/Source/JavaScriptCore/heap/IncrementalSweeper.cpp

    r121058 r121098  
    4646void IncrementalSweeper::doWork()
    4747{
     48    APIEntryShim shim(m_globalData);
    4849    doSweep(WTF::monotonicallyIncreasingTime());
    4950}
    … …  
    5556}
    5657
    57 IncrementalSweeper* IncrementalSweeper::create(Heap* heap)
     58PassOwnPtr<IncrementalSweeper> IncrementalSweeper::create(Heap* heap)
    5859{
    59     return new IncrementalSweeper(heap, CFRunLoopGetCurrent());
     60    return adoptPtr(new IncrementalSweeper(heap, CFRunLoopGetCurrent()));
    6061}
    6162
    … …  
    109110}
    110111
    111 IncrementalSweeper* IncrementalSweeper::create(Heap* heap)
     112PassOwnPtr<IncrementalSweeper> IncrementalSweeper::create(Heap* heap)
    112113{
    113     return new IncrementalSweeper(heap->globalData());
     114    return adoptPtr(new IncrementalSweeper(heap->globalData()));
    114115}
    115116

  • trunk/Source/JavaScriptCore/heap/IncrementalSweeper.h

    r121058 r121098  
    4040class IncrementalSweeper : public HeapTimer {
    4141public:
    42     static IncrementalSweeper* create(Heap*);
     42    static PassOwnPtr<IncrementalSweeper> create(Heap*);
    4343    void startSweeping(const HashSet<MarkedBlock*>& blockSnapshot);
    4444    virtual void doWork();

  • trunk/Source/JavaScriptCore/heap/MarkedAllocator.cpp

    r121058 r121098  
    44#include "GCActivityCallback.h"
    55#include "Heap.h"
    6 #include "JSGlobalData.h"
    76#include <wtf/CurrentTime.h>
    87
    … …  
    5857void* MarkedAllocator::allocateSlowCase()
    5958{
    60     ASSERT(m_heap->globalData()->apiLock().currentThreadIsHoldingLock());
    6159#if COLLECT_ON_EVERY_ALLOCATION
    6260    m_heap->collectAllGarbage();

  • trunk/Source/JavaScriptCore/heap/WeakBlock.cpp

    r121058 r121098  
    128128            continue;
    129129
    130         if (Heap::isMarked(weakImpl->jsValue().asCell())) {
    131             ASSERT(weakImpl->state() == WeakImpl::Live);
     130        if (Heap::isMarked(weakImpl->jsValue().asCell()))
    132131            continue;
    133         }
    134132
    135133        weakImpl->setState(WeakImpl::Dead);

  • trunk/Source/JavaScriptCore/jsc.cpp

    r121058 r121098  
    300300EncodedJSValue JSC_HOST_CALL functionGC(ExecState* exec)
    301301{
    302     JSLockHolder lock(exec);
     302    JSLock lock(SilenceAssertionsOnly);
    303303    exec->heap()->collectAllGarbage();
    304304    return JSValue::encode(jsUndefined());
    … …  
    308308EncodedJSValue JSC_HOST_CALL functionReleaseExecutableMemory(ExecState* exec)
    309309{
    310     JSLockHolder lock(exec);
     310    JSLock lock(SilenceAssertionsOnly);
    311311    exec->globalData().releaseExecutableMemory();
    312312    return JSValue::encode(jsUndefined());
    … …  
    668668int jscmain(int argc, char** argv)
    669669{
    670    
     670    JSLock lock(SilenceAssertionsOnly);
     671
    671672    RefPtr<JSGlobalData> globalData = JSGlobalData::create(ThreadStackTypeLarge, LargeHeap);
    672     JSLockHolder lock(globalData.get());
    673673
    674674    CommandLine options;

  • trunk/Source/JavaScriptCore/runtime/Completion.cpp

    r121058 r121098  
    3838bool checkSyntax(ExecState* exec, const SourceCode& source, JSValue* returnedException)
    3939{
    40     JSLockHolder lock(exec);
     40    JSLock lock(exec);
    4141    ASSERT(exec->globalData().identifierTable == wtfThreadData().currentIdentifierTable());
    4242
    … …  
    5454JSValue evaluate(ExecState* exec, ScopeChainNode* scopeChain, const SourceCode& source, JSValue thisValue, JSValue* returnedException)
    5555{
    56     JSLockHolder lock(exec);
     56    JSLock lock(exec);
    5757    ASSERT(exec->globalData().identifierTable == wtfThreadData().currentIdentifierTable());
    5858    if (exec->globalData().isCollectorBusy())

  • trunk/Source/JavaScriptCore/runtime/GCActivityCallback.h

    r121058 r121098  
    7070class DefaultGCActivityCallback : public GCActivityCallback {
    7171public:
    72     static DefaultGCActivityCallback* create(Heap*);
     72    static PassOwnPtr<DefaultGCActivityCallback> create(Heap*);
    7373
    7474    DefaultGCActivityCallback(Heap*);
    … …  
    9292};
    9393
    94 inline DefaultGCActivityCallback* DefaultGCActivityCallback::create(Heap* heap)
     94inline PassOwnPtr<DefaultGCActivityCallback> DefaultGCActivityCallback::create(Heap* heap)
    9595{
    96     return new DefaultGCActivityCallback(heap);
     96    return adoptPtr(new DefaultGCActivityCallback(heap));
    9797}
    9898

  • trunk/Source/JavaScriptCore/runtime/JSGlobalData.cpp

    r121058 r121098  
    3535#include "DebuggerActivation.h"
    3636#include "FunctionConstructor.h"
    37 #include "GCActivityCallback.h"
    3837#include "GetterSetter.h"
    3938#include "HostCallReturnValue.h"
    40 #include "IncrementalSweeper.h"
    4139#include "Interpreter.h"
    4240#include "JSActivation.h"
    … …  
    181179    interpreter = new Interpreter;
    182180
     181    if (isSharedInstance())
     182        turnOffVerifier();
     183
    183184    // Need to be careful to keep everything consistent here
    184     JSLockHolder lock(this);
    185185    IdentifierTable* existingEntryIdentifierTable = wtfThreadData().setCurrentIdentifierTable(identifierTable);
     186    JSLock lock(SilenceAssertionsOnly);
    186187    structureStructure.set(*this, Structure::createStructure(*this));
    187188    debuggerActivationStructure.set(*this, DebuggerActivation::createStructure(*this, 0, jsNull()));
    … …  
    222223JSGlobalData::~JSGlobalData()
    223224{
    224     ASSERT(!m_apiLock.currentThreadIsHoldingLock());
    225     heap.activityCallback()->didStartVMShutdown();
    226     heap.sweeper()->didStartVMShutdown();
    227225    heap.lastChanceToFinalize();
    228226
    … …  
    314312JSGlobalData& JSGlobalData::sharedInstance()
    315313{
    316     GlobalJSLock globalLock;
    317314    JSGlobalData*& instance = sharedInstanceInternal();
    318315    if (!instance) {
    … …  
    325322JSGlobalData*& JSGlobalData::sharedInstanceInternal()
    326323{
     324    ASSERT(JSLock::currentThreadIsHoldingLock());
    327325    static JSGlobalData* sharedInstance;
    328326    return sharedInstance;

  • trunk/Source/JavaScriptCore/runtime/JSGlobalData.h

    r121058 r121098  
    3636#include "Intrinsic.h"
    3737#include "JITStubs.h"
    38 #include "JSLock.h"
    3938#include "JSValue.h"
    4039#include "LLIntData.h"
    … …  
    4847#include <wtf/Forward.h>
    4948#include <wtf/HashMap.h>
     49#include <wtf/RefCounted.h>
    5050#include <wtf/SimpleStats.h>
    51 #include <wtf/ThreadSafeRefCounted.h>
    5251#include <wtf/ThreadSpecific.h>
    5352#include <wtf/WTFThreadData.h>
    … …  
    154153#endif
    155154
    156     class JSGlobalData : public ThreadSafeRefCounted<JSGlobalData> {
     155    class JSGlobalData : public RefCounted<JSGlobalData> {
    157156    public:
    158157        // WebCore has a one-to-one mapping of threads to JSGlobalDatas;
    … …  
    182181        void makeUsableFromMultipleThreads() { heap.machineThreads().makeUsableFromMultipleThreads(); }
    183182
    184     private:
    185         JSLock m_apiLock;
    186 
    187     public:
    188183        Heap heap; // The heap is our first data member to ensure that it's destructed after all the objects that reference it.
    189184
    … …  
    415410#undef registerTypedArrayFunction
    416411
    417         JSLock& apiLock() { return m_apiLock; }
    418 
    419412    private:
    420413        friend class LLIntOffsetsExtractor;

  • trunk/Source/JavaScriptCore/runtime/JSGlobalObject.cpp

    r121058 r121098  
    115115JSGlobalObject::~JSGlobalObject()
    116116{
     117    ASSERT(JSLock::currentThreadIsHoldingLock());
     118
    117119    if (m_debugger)
    118120        m_debugger->detach(this);
    … …  
    129131void JSGlobalObject::init(JSObject* thisValue)
    130132{
    131     ASSERT(globalData().apiLock().currentThreadIsHoldingLock());
     133    ASSERT(JSLock::currentThreadIsHoldingLock());
    132134   
    133135    m_globalScopeChain.set(globalData(), this, ScopeChainNode::create(0, this, &globalData(), this, thisValue));

  • trunk/Source/JavaScriptCore/runtime/JSLock.cpp

    r121058 r121098  
    2424#include "Heap.h"
    2525#include "CallFrame.h"
    26 #include "JSGlobalObject.h"
    2726#include "JSObject.h"
    2827#include "ScopeChain.h"
    … …  
    4039
    4140// Acquire this mutex before accessing lock-related data.
    42 static pthread_mutex_t giantGlobalJSLock = PTHREAD_MUTEX_INITIALIZER;
    43 
    44 GlobalJSLock::GlobalJSLock()
    45 {
    46     pthread_mutex_lock(&giantGlobalJSLock);
    47 }
    48 
    49 GlobalJSLock::~GlobalJSLock()
    50 {
    51     pthread_mutex_unlock(&giantGlobalJSLock);
    52 }
    53 
    54 JSLockHolder::JSLockHolder(ExecState* exec)
    55     : m_globalData(&exec->globalData())
    56 {
    57     m_globalData->apiLock().lock();
    58 }
    59 
    60 JSLockHolder::JSLockHolder(JSGlobalData* globalData)
    61     : m_globalData(globalData)
    62 {
    63     m_globalData->apiLock().lock();
    64 }
    65 
    66 JSLockHolder::JSLockHolder(JSGlobalData& globalData)
    67     : m_globalData(&globalData)
    68 {
    69     m_globalData->apiLock().lock();
    70 }
    71 
    72 JSLockHolder::~JSLockHolder()
    73 {
    74     m_globalData->apiLock().unlock();
    75 }
    76 
    77 JSLock::JSLock()
    78     : m_lockCount(0)
    79 {
    80     m_spinLock.Init();
    81 }
    82 
    83 JSLock::~JSLock()
    84 {
    85 }
    86 
    87 void JSLock::lock()
    88 {
    89     ThreadIdentifier currentThread = WTF::currentThread();
    90     {
    91         SpinLockHolder holder(&m_spinLock);
    92         if (m_ownerThread == currentThread && m_lockCount) {
    93             m_lockCount++;
    94             return;
    95         }
    96     }
    97 
    98     m_lock.lock();
    99 
    100     SpinLockHolder holder(&m_spinLock);
    101     m_ownerThread = currentThread;
    102     ASSERT(!m_lockCount);
    103     m_lockCount = 1;
    104 }
    105 
    106 void JSLock::unlock()
    107 {
    108     ASSERT(currentThreadIsHoldingLock());
    109 
    110     SpinLockHolder holder(&m_spinLock);
    111     m_lockCount--;
    112 
    113     if (!m_lockCount)
    114         m_lock.unlock();
     41static pthread_mutex_t JSMutex = PTHREAD_MUTEX_INITIALIZER;
     42
     43// Thread-specific key that tells whether a thread holds the JSMutex, and how many times it was taken recursively.
     44pthread_key_t JSLockCount;
     45
     46static void createJSLockCount()
     47{
     48    pthread_key_create(&JSLockCount, 0);
     49}
     50
     51pthread_once_t createJSLockCountOnce = PTHREAD_ONCE_INIT;
     52
     53// Lock nesting count.
     54intptr_t JSLock::lockCount()
     55{
     56    pthread_once(&createJSLockCountOnce, createJSLockCount);
     57
     58    return reinterpret_cast<intptr_t>(pthread_getspecific(JSLockCount));
     59}
     60
     61static void setLockCount(intptr_t count)
     62{
     63    ASSERT(count >= 0);
     64    pthread_setspecific(JSLockCount, reinterpret_cast<void*>(count));
     65}
     66
     67JSLock::JSLock(ExecState* exec)
     68    : m_lockBehavior(exec->globalData().isSharedInstance() ? LockForReal : SilenceAssertionsOnly)
     69{
     70    lock(m_lockBehavior);
     71}
     72
     73JSLock::JSLock(JSGlobalData* globalData)
     74    : m_lockBehavior(globalData->isSharedInstance() ? LockForReal : SilenceAssertionsOnly)
     75{
     76    lock(m_lockBehavior);
     77}
     78
     79void JSLock::lock(JSLockBehavior lockBehavior)
     80{
     81#ifdef NDEBUG
     82    // Locking "not for real" is a debug-only feature.
     83    if (lockBehavior == SilenceAssertionsOnly)
     84        return;
     85#endif
     86
     87    pthread_once(&createJSLockCountOnce, createJSLockCount);
     88
     89    intptr_t currentLockCount = lockCount();
     90    if (!currentLockCount && lockBehavior == LockForReal) {
     91        int result = pthread_mutex_lock(&JSMutex);
     92        ASSERT_UNUSED(result, !result);
     93    }
     94    setLockCount(currentLockCount + 1);
     95}
     96
     97void JSLock::unlock(JSLockBehavior lockBehavior)
     98{
     99    ASSERT(lockCount());
     100
     101#ifdef NDEBUG
     102    // Locking "not for real" is a debug-only feature.
     103    if (lockBehavior == SilenceAssertionsOnly)
     104        return;
     105#endif
     106
     107    intptr_t newLockCount = lockCount() - 1;
     108    setLockCount(newLockCount);
     109    if (!newLockCount && lockBehavior == LockForReal) {
     110        int result = pthread_mutex_unlock(&JSMutex);
     111        ASSERT_UNUSED(result, !result);
     112    }
    115113}
    116114
    117115void JSLock::lock(ExecState* exec)
    118116{
    119     exec->globalData().apiLock().lock();
     117    lock(exec->globalData().isSharedInstance() ? LockForReal : SilenceAssertionsOnly);
    120118}
    121119
    122120void JSLock::unlock(ExecState* exec)
    123121{
    124     exec->globalData().apiLock().unlock();
     122    unlock(exec->globalData().isSharedInstance() ? LockForReal : SilenceAssertionsOnly);
    125123}
    126124
    127125bool JSLock::currentThreadIsHoldingLock()
    128126{
    129     return m_lockCount && m_ownerThread == WTF::currentThread();
     127    pthread_once(&createJSLockCountOnce, createJSLockCount);
     128    return !!pthread_getspecific(JSLockCount);
    130129}
    131130
    … …  
    151150// write over the second thread's call frames.
    152151//
    153 // To avoid JS stack corruption we enforce a policy of only ever allowing two
     152// In avoid JS stack corruption we enforce a policy of only ever allowing two
    154153// threads to use a JS context concurrently, and only allowing the second of
    155154// these threads to execute until it has completed and fully returned from its
    … …  
    160159// again through a callback, then the locks will not be dropped when DropAllLocks
    161160// is called (since lockDropDepth is non-zero).  Since this thread is still holding
    162 // the locks, only it will be able to re-enter JSC (either be returning from the
     161// the locks, only it will re able to re-enter JSC (either be returning from the
    163162// callback, or by re-entering through another call to evaulate script or call
    164163// function).
    … …  
    170169// would likely increase complexity and overhead.
    171170//
    172 
    173 // This function returns the number of locks that were dropped.
    174 unsigned JSLock::dropAllLocks()
    175 {
    176     if (m_lockDropDepth++)
    177         return 0;
    178 
    179     return dropAllLocksUnconditionally();
    180 }
    181 
    182 unsigned JSLock::dropAllLocksUnconditionally()
    183 {
    184     unsigned lockCount = m_lockCount;
    185     for (unsigned i = 0; i < lockCount; i++)
    186         unlock();
    187 
    188     return lockCount;
    189 }
    190 
    191 void JSLock::grabAllLocks(unsigned lockCount)
    192 {
    193     for (unsigned i = 0; i < lockCount; i++)
    194         lock();
    195 
    196     m_lockDropDepth--;
    197 }
     171static unsigned lockDropDepth = 0;
    198172
    199173JSLock::DropAllLocks::DropAllLocks(ExecState* exec)
    200     : m_lockCount(0)
    201     , m_globalData(&exec->globalData())
    202 {
    203     m_lockCount = m_globalData->apiLock().dropAllLocks();
    204 }
    205 
    206 JSLock::DropAllLocks::DropAllLocks(JSGlobalData* globalData)
    207     : m_lockCount(0)
    208     , m_globalData(globalData)
    209 {
    210     m_lockCount = m_globalData->apiLock().dropAllLocks();
     174    : m_lockBehavior(exec->globalData().isSharedInstance() ? LockForReal : SilenceAssertionsOnly)
     175{
     176    pthread_once(&createJSLockCountOnce, createJSLockCount);
     177
     178    if (lockDropDepth++) {
     179        m_lockCount = 0;
     180        return;
     181    }
     182
     183    m_lockCount = JSLock::lockCount();
     184    for (intptr_t i = 0; i < m_lockCount; i++)
     185        JSLock::unlock(m_lockBehavior);
     186}
     187
     188JSLock::DropAllLocks::DropAllLocks(JSLockBehavior JSLockBehavior)
     189    : m_lockBehavior(JSLockBehavior)
     190{
     191    pthread_once(&createJSLockCountOnce, createJSLockCount);
     192
     193    if (lockDropDepth++) {
     194        m_lockCount = 0;
     195        return;
     196    }
     197
     198    // It is necessary to drop even "unreal" locks, because having a non-zero lock count
     199    // will prevent a real lock from being taken.
     200
     201    m_lockCount = JSLock::lockCount();
     202    for (intptr_t i = 0; i < m_lockCount; i++)
     203        JSLock::unlock(m_lockBehavior);
    211204}
    212205
    213206JSLock::DropAllLocks::~DropAllLocks()
    214207{
    215     m_globalData->apiLock().grabAllLocks(m_lockCount);
     208    for (intptr_t i = 0; i < m_lockCount; i++)
     209        JSLock::lock(m_lockBehavior);
     210
     211    --lockDropDepth;
    216212}
    217213
    218214#else // (OS(DARWIN) || USE(PTHREADS))
    219215
    220 GlobalJSLock::GlobalJSLock()
    221 {
    222 }
    223 
    224 GlobalJSLock::~GlobalJSLock()
    225 {
    226 }
    227 
    228 JSLockHolder::JSLockHolder(JSGlobalData*)
    229 {
    230 }
    231 
    232 JSLockHolder::JSLockHolder(JSGlobalData&)
    233 {
    234 }
    235 
    236 JSLockHolder::JSLockHolder(ExecState*)
    237 {
    238 }
    239 
    240 JSLockHolder::~JSLockHolder()
    241 {
    242 }
    243 
    244 JSLock::JSLock()
    245 {
    246 }
    247 
    248 JSLock::~JSLock()
    249 {
     216JSLock::JSLock(ExecState*)
     217    : m_lockBehavior(SilenceAssertionsOnly)
     218{
     219}
     220
     221// If threading support is off, set the lock count to a constant value of 1 so ssertions
     222// that the lock is held don't fail
     223intptr_t JSLock::lockCount()
     224{
     225    return 1;
    250226}
    251227
    … …  
    255231}
    256232
    257 void JSLock::lock()
    258 {
    259 }
    260 
    261 void JSLock::unlock()
     233void JSLock::lock(JSLockBehavior)
     234{
     235}
     236
     237void JSLock::unlock(JSLockBehavior)
    262238{
    263239}
    … …  
    271247}
    272248
    273 void JSLock::lock(JSGlobalData&)
    274 {
    275 }
    276 
    277 void JSLock::unlock(JSGlobalData&)
    278 {
    279 }
    280 
    281 unsigned JSLock::dropAllLocks()
    282 {
    283     return 0;
    284 }
    285 
    286 unsigned JSLock::dropAllLocksUnconditionally()
    287 {
    288     return 0;
    289 }
    290 
    291 void JSLock::grabAllLocks(unsigned)
    292 {
    293 }
    294 
    295249JSLock::DropAllLocks::DropAllLocks(ExecState*)
    296250{
    297251}
    298252
    299 JSLock::DropAllLocks::DropAllLocks(JSGlobalData*)
     253JSLock::DropAllLocks::DropAllLocks(JSLockBehavior)
    300254{
    301255}

  • trunk/Source/JavaScriptCore/runtime/JSLock.h

    r121058 r121098  
    2424#include <wtf/Assertions.h>
    2525#include <wtf/Noncopyable.h>
    26 #include <wtf/RefPtr.h>
    27 #include <wtf/TCSpinLock.h>
    28 #include <wtf/Threading.h>
    2926
    3027namespace JSC {
    … …  
    3431    // JavaScript data structure or that interacts with shared state
    3532    // such as the protect count hash table. The simplest way to lock
    36     // is to create a local JSLockHolder object in the scope where the lock
    37     // must be held and pass it the context that requires protection.
    38     // The lock is recursive so nesting is ok. The JSLock
     33    // is to create a local JSLock object in the scope where the lock
     34    // must be held. The lock is recursive so nesting is ok. The JSLock
    3935    // object also acts as a convenience short-hand for running important
    4036    // initialization routines.
    … …  
    4945    // thread acquired it to begin with.
    5046
     47    // For contexts other than the single shared one, implicit locking is not done,
     48    // but we still need to perform all the counting in order to keep debug
     49    // assertions working, so that clients that use the shared context don't break.
     50
    5151    class ExecState;
    5252    class JSGlobalData;
    5353
    54     // This class is used to protect the initialization of the legacy single
    55     // shared JSGlobalData.
    56     class GlobalJSLock {
    57         WTF_MAKE_NONCOPYABLE(GlobalJSLock);
    58     public:
    59         JS_EXPORT_PRIVATE GlobalJSLock();
    60         JS_EXPORT_PRIVATE ~GlobalJSLock();
    61     };
    62 
    63     class JSLockHolder {
    64     public:
    65         JS_EXPORT_PRIVATE JSLockHolder(JSGlobalData*);
    66         JS_EXPORT_PRIVATE JSLockHolder(JSGlobalData&);
    67         JS_EXPORT_PRIVATE JSLockHolder(ExecState*);
    68 
    69         JS_EXPORT_PRIVATE ~JSLockHolder();
    70     private:
    71         RefPtr<JSGlobalData> m_globalData;
    72     };
     54    enum JSLockBehavior { SilenceAssertionsOnly, LockForReal };
    7355
    7456    class JSLock {
    7557        WTF_MAKE_NONCOPYABLE(JSLock);
    7658    public:
    77         JSLock();
    78         JS_EXPORT_PRIVATE ~JSLock();
     59        JS_EXPORT_PRIVATE JSLock(ExecState*);
     60        JSLock(JSGlobalData*);
    7961
    80         JS_EXPORT_PRIVATE void lock();
    81         JS_EXPORT_PRIVATE void unlock();
     62        JSLock(JSLockBehavior lockBehavior)
     63            : m_lockBehavior(lockBehavior)
     64        {
     65#ifdef NDEBUG
     66            // Locking "not for real" is a debug-only feature.
     67            if (lockBehavior == SilenceAssertionsOnly)
     68                return;
     69#endif
     70            lock(lockBehavior);
     71        }
    8272
     73        ~JSLock()
     74        {
     75#ifdef NDEBUG
     76            // Locking "not for real" is a debug-only feature.
     77            if (m_lockBehavior == SilenceAssertionsOnly)
     78                return;
     79#endif
     80            unlock(m_lockBehavior);
     81        }
     82       
     83        JS_EXPORT_PRIVATE static void lock(JSLockBehavior);
     84        JS_EXPORT_PRIVATE static void unlock(JSLockBehavior);
    8385        static void lock(ExecState*);
    8486        static void unlock(ExecState*);
    85         static void lock(JSGlobalData&);
    86         static void unlock(JSGlobalData&);
    8787
    88         JS_EXPORT_PRIVATE bool currentThreadIsHoldingLock();
     88        JS_EXPORT_PRIVATE static intptr_t lockCount();
     89        JS_EXPORT_PRIVATE static bool currentThreadIsHoldingLock();
    8990
    90         unsigned dropAllLocks();
    91         unsigned dropAllLocksUnconditionally();
    92         void grabAllLocks(unsigned lockCount);
    93 
    94         SpinLock m_spinLock;
    95         Mutex m_lock;
    96         ThreadIdentifier m_ownerThread;
    97         intptr_t m_lockCount;
    98         unsigned m_lockDropDepth;
     91        JSLockBehavior m_lockBehavior;
    9992
    10093        class DropAllLocks {
    … …  
    10295        public:
    10396            JS_EXPORT_PRIVATE DropAllLocks(ExecState* exec);
    104             JS_EXPORT_PRIVATE DropAllLocks(JSGlobalData*);
     97            JS_EXPORT_PRIVATE DropAllLocks(JSLockBehavior);
    10598            JS_EXPORT_PRIVATE ~DropAllLocks();
    10699           
    107100        private:
    108101            intptr_t m_lockCount;
    109             RefPtr<JSGlobalData> m_globalData;
     102            JSLockBehavior m_lockBehavior;
    110103        };
    111104    };

  • trunk/Source/JavaScriptCore/runtime/WeakGCMap.h

    r121058 r121098  
    7676    }
    7777
    78     void set(JSGlobalData& globalData, const KeyType& key, ExternalType value)
     78    void set(JSGlobalData&, const KeyType& key, ExternalType value)
    7979    {
    80         ASSERT_UNUSED(globalData, globalData.apiLock().currentThreadIsHoldingLock());
    8180        typename MapType::AddResult result = m_map.add(key, 0);
    8281        if (!result.isNewEntry)

  • trunk/Source/JavaScriptCore/testRegExp.cpp

    r121058 r121098  
    496496int realMain(int argc, char** argv)
    497497{
     498    JSLock lock(SilenceAssertionsOnly);
     499
    498500    RefPtr<JSGlobalData> globalData = JSGlobalData::create(ThreadStackTypeLarge, LargeHeap);
    499     JSLockHolder lock(globalData.get());
    500501
    501502    CommandLine options;
Note: See TracChangeset for help on using the changeset viewer.