X-Git-Url: https://git.saurik.com/apple/javascriptcore.git/blobdiff_plain/9dae56ea45a0f5f8136a5c93d6f3a7f99399ca73..14957cd040308e3eeec43d26bae5d76da13fcd85:/API/JSContextRef.cpp?ds=sidebyside diff --git a/API/JSContextRef.cpp b/API/JSContextRef.cpp index c331179..9c15b22 100644 --- a/API/JSContextRef.cpp +++ b/API/JSContextRef.cpp @@ -25,16 +25,21 @@ #include "config.h" #include "JSContextRef.h" +#include "JSContextRefPrivate.h" #include "APICast.h" #include "InitializeThreading.h" +#include +#include #include "JSCallbackObject.h" #include "JSClassRef.h" #include "JSGlobalObject.h" #include "JSObject.h" -#include +#include "UStringBuilder.h" +#include -#if PLATFORM(DARWIN) + +#if OS(DARWIN) #include static const int32_t webkitFirstVersionWithConcurrentGlobalContexts = 0x2100500; // 528.5.0 @@ -45,7 +50,7 @@ using namespace JSC; JSContextGroupRef JSContextGroupCreate() { initializeThreading(); - return toRef(JSGlobalData::create().releaseRef()); + return toRef(JSGlobalData::createContextGroup(ThreadStackTypeSmall).leakRef()); } JSContextGroupRef JSContextGroupRetain(JSContextGroupRef group) @@ -62,18 +67,18 @@ void JSContextGroupRelease(JSContextGroupRef group) JSGlobalContextRef JSGlobalContextCreate(JSClassRef globalObjectClass) { initializeThreading(); -#if PLATFORM(DARWIN) +#if OS(DARWIN) // When running on Tiger or Leopard, or if the application was linked before JSGlobalContextCreate was changed // to use a unique JSGlobalData, we use a shared one for compatibility. -#if !defined(BUILDING_ON_TIGER) && !defined(BUILDING_ON_LEOPARD) +#ifndef BUILDING_ON_LEOPARD if (NSVersionOfLinkTimeLibrary("JavaScriptCore") <= webkitFirstVersionWithConcurrentGlobalContexts) { #else { #endif - JSLock lock(true); + JSLock lock(LockForReal); return JSGlobalContextCreateInGroup(toRef(&JSGlobalData::sharedInstance()), globalObjectClass); } -#endif // PLATFORM(DARWIN) +#endif // OS(DARWIN) return JSGlobalContextCreateInGroup(0, globalObjectClass); } @@ -82,37 +87,35 @@ JSGlobalContextRef JSGlobalContextCreateInGroup(JSContextGroupRef group, JSClass { initializeThreading(); - JSLock lock(true); + JSLock lock(LockForReal); + RefPtr globalData = group ? PassRefPtr(toJS(group)) : JSGlobalData::createContextGroup(ThreadStackTypeSmall); - RefPtr globalData = group ? PassRefPtr(toJS(group)) : JSGlobalData::create(); + APIEntryShim entryShim(globalData.get(), false); #if ENABLE(JSC_MULTIPLE_THREADS) globalData->makeUsableFromMultipleThreads(); #endif if (!globalObjectClass) { - JSGlobalObject* globalObject = new (globalData.get()) JSGlobalObject; + JSGlobalObject* globalObject = new (globalData.get()) JSGlobalObject(*globalData, JSGlobalObject::createStructure(*globalData, jsNull())); return JSGlobalContextRetain(toGlobalRef(globalObject->globalExec())); } - JSGlobalObject* globalObject = new (globalData.get()) JSCallbackObject(globalObjectClass); + JSGlobalObject* globalObject = new (globalData.get()) JSCallbackObject(*globalData, globalObjectClass, JSCallbackObject::createStructure(*globalData, jsNull())); ExecState* exec = globalObject->globalExec(); - JSValuePtr prototype = globalObjectClass->prototype(exec); + JSValue prototype = globalObjectClass->prototype(exec); if (!prototype) prototype = jsNull(); - globalObject->resetPrototype(prototype); + globalObject->resetPrototype(*globalData, prototype); return JSGlobalContextRetain(toGlobalRef(exec)); } JSGlobalContextRef JSGlobalContextRetain(JSGlobalContextRef ctx) { ExecState* exec = toJS(ctx); - JSLock lock(exec); + APIEntryShim entryShim(exec); JSGlobalData& globalData = exec->globalData(); - - globalData.heap.registerThread(); - gcProtect(exec->dynamicGlobalObject()); globalData.ref(); return ctx; @@ -123,25 +126,43 @@ void JSGlobalContextRelease(JSGlobalContextRef ctx) ExecState* exec = toJS(ctx); JSLock lock(exec); - gcUnprotect(exec->dynamicGlobalObject()); - JSGlobalData& globalData = exec->globalData(); - if (globalData.refCount() == 2) { // One reference is held by JSGlobalObject, another added by JSGlobalContextRetain(). - // The last reference was released, this is our last chance to collect. - ASSERT(!globalData.heap.protectedObjectCount()); - ASSERT(!globalData.heap.isBusy()); + JSGlobalObject* dgo = exec->dynamicGlobalObject(); + IdentifierTable* savedIdentifierTable = wtfThreadData().setCurrentIdentifierTable(globalData.identifierTable); + + // One reference is held by JSGlobalObject, another added by JSGlobalContextRetain(). + bool releasingContextGroup = globalData.refCount() == 2; + bool releasingGlobalObject = Heap::heap(dgo)->unprotect(dgo); + // If this is the last reference to a global data, it should also + // be the only remaining reference to the global object too! + ASSERT(!releasingContextGroup || releasingGlobalObject); + + // An API 'JSGlobalContextRef' retains two things - a global object and a + // global data (or context group, in API terminology). + // * If this is the last reference to any contexts in the given context group, + // call destroy on the heap (the global data is being freed). + // * If this was the last reference to the global object, then unprotecting + // it may release a lot of GC memory - tickle the activity callback to + // garbage collect soon. + // * If there are more references remaining the the global object, then do nothing + // (specifically that is more protects, which we assume come from other JSGlobalContextRefs). + if (releasingContextGroup) { + globalData.clearBuiltinStructures(); globalData.heap.destroy(); - } else - globalData.heap.collect(); + } else if (releasingGlobalObject) { + globalData.heap.activityCallback()->synchronize(); + (*globalData.heap.activityCallback())(); + } globalData.deref(); + + wtfThreadData().setCurrentIdentifierTable(savedIdentifierTable); } JSObjectRef JSContextGetGlobalObject(JSContextRef ctx) { ExecState* exec = toJS(ctx); - exec->globalData().heap.registerThread(); - JSLock lock(exec); + APIEntryShim entryShim(exec); // It is necessary to call toThisObject to get the wrapper object when used with WebCore. return toRef(exec->lexicalGlobalObject()->toThisObject(exec)); @@ -152,3 +173,68 @@ JSContextGroupRef JSContextGetGroup(JSContextRef ctx) ExecState* exec = toJS(ctx); return toRef(&exec->globalData()); } + +JSGlobalContextRef JSContextGetGlobalContext(JSContextRef ctx) +{ + ExecState* exec = toJS(ctx); + APIEntryShim entryShim(exec); + + return toGlobalRef(exec->lexicalGlobalObject()->globalExec()); +} + +JSStringRef JSContextCreateBacktrace(JSContextRef ctx, unsigned maxStackSize) +{ + ExecState* exec = toJS(ctx); + JSLock lock(exec); + + unsigned count = 0; + UStringBuilder builder; + CallFrame* callFrame = exec; + UString functionName; + if (exec->callee()) { + if (asObject(exec->callee())->inherits(&InternalFunction::s_info)) { + functionName = asInternalFunction(exec->callee())->name(exec); + builder.append("#0 "); + builder.append(functionName); + builder.append("() "); + count++; + } + } + while (true) { + ASSERT(callFrame); + int signedLineNumber; + intptr_t sourceID; + UString urlString; + JSValue function; + + UString levelStr = UString::number(count); + + exec->interpreter()->retrieveLastCaller(callFrame, signedLineNumber, sourceID, urlString, function); + + if (function) + functionName = asFunction(function)->name(exec); + else { + // Caller is unknown, but if frame is empty we should still add the frame, because + // something called us, and gave us arguments. + if (count) + break; + } + unsigned lineNumber = signedLineNumber >= 0 ? signedLineNumber : 0; + if (!builder.isEmpty()) + builder.append("\n"); + builder.append("#"); + builder.append(levelStr); + builder.append(" "); + builder.append(functionName); + builder.append("() at "); + builder.append(urlString); + builder.append(":"); + builder.append(UString::number(lineNumber)); + if (!function || ++count == maxStackSize) + break; + callFrame = callFrame->callerFrame(); + } + return OpaqueJSString::create(builder.toUString()).leakRef(); +} + +