void JSEventListener::markJSFunction(MarkStack& markStack)
{
if (m_jsFunction)
markStack.append(m_jsFunction);
if (m_globalObject)
markStack.append(m_globalObject);
}
void SmallStrings::markChildren(MarkStack& markStack)
{
/*
Our hypothesis is that small strings are very common. So, we cache them
to avoid GC churn. However, in cases where this hypothesis turns out to
be false -- including the degenerate case where all JavaScript execution
has terminated -- we don't want to waste memory.
To test our hypothesis, we check if any small string has been marked. If
so, it's probably reasonable to mark the rest. If not, we clear the cache.
*/
bool isAnyStringMarked = isMarked(m_emptyString);
for (unsigned i = 0; i < numCharactersToStore && !isAnyStringMarked; ++i)
isAnyStringMarked = isMarked(m_singleCharacterStrings[i]);
if (!isAnyStringMarked) {
clear();
return;
}
if (m_emptyString)
markStack.append(m_emptyString);
for (unsigned i = 0; i < numCharactersToStore; ++i) {
if (m_singleCharacterStrings[i])
markStack.append(m_singleCharacterStrings[i]);
}
}
void ScopeChainNode::markChildren(MarkStack& markStack)
{
if (next)
markStack.append(&next);
markStack.append(&object);
markStack.append(&globalObject);
markStack.append(&globalThis);
}
void GetterSetter::markChildren(MarkStack& markStack)
{
AJCell::markChildren(markStack);
if (m_getter)
markStack.append(m_getter);
if (m_setter)
markStack.append(m_setter);
}
void SmallStrings::markChildren(MarkStack& markStack)
{
if (m_emptyString)
markStack.append(m_emptyString);
for (unsigned i = 0; i < numCharactersToStore; ++i) {
if (m_singleCharacterStrings[i])
markStack.append(m_singleCharacterStrings[i]);
}
}
void JSMessageChannel::markChildren(MarkStack& markStack)
{
Base::markChildren(markStack);
if (MessagePort* port = m_impl->port1()) {
DOMObject* wrapper = getCachedDOMObjectWrapper(*Heap::heap(this)->globalData(), port);
if (wrapper)
markStack.append(wrapper);
}
if (MessagePort* port = m_impl->port2()) {
DOMObject* wrapper = getCachedDOMObjectWrapper(*Heap::heap(this)->globalData(), port);
if (wrapper)
markStack.append(wrapper);
}
}
void DebuggerActivation::markChildren(MarkStack& markStack)
{
AJObject::markChildren(markStack);
if (m_activation)
markStack.append(m_activation);
}
void markDOMNodeWrapper(MarkStack& markStack, Document* document, Node* node)
{
if (document) {
JSWrapperCacheMap& wrapperCacheMap = document->wrapperCacheMap();
for (JSWrapperCacheMap::iterator iter = wrapperCacheMap.begin(); iter != wrapperCacheMap.end(); ++iter) {
if (DeprecatedPtr<JSNode>* wrapperSlot = iter->second->uncheckedGetSlot(node))
markStack.append(wrapperSlot);
}
return;
}
for (JSGlobalDataWorldIterator worldIter(JSDOMWindow::commonJSGlobalData()); worldIter; ++worldIter) {
if (DeprecatedPtr<DOMObject>* wrapperSlot = worldIter->m_wrappers.uncheckedGetSlot(node))
markStack.append(wrapperSlot);
}
}
void Arguments::markChildren(MarkStack& markStack)
{
JSObject::markChildren(markStack);
if (d->registerArray)
markStack.appendValues(reinterpret_cast<JSValue*>(d->registerArray.get()), d->numParameters);
if (d->extraArguments) {
unsigned numExtraArguments = d->numArguments - d->numParameters;
markStack.appendValues(reinterpret_cast<JSValue*>(d->extraArguments), numExtraArguments);
}
markStack.append(d->callee);
if (d->activation)
markStack.append(d->activation);
}
void Stringifier::markAggregate(MarkStack& markStack)
{
for (Stringifier* stringifier = this; stringifier; stringifier = stringifier->m_nextStringifierToMark) {
size_t size = m_holderStack.size();
for (size_t i = 0; i < size; ++i)
markStack.append(m_holderStack[i].object());
}
}
void Arguments::markChildren(MarkStack& markStack)
{
JSObject::markChildren(markStack);
if (d->registerArray)
markStack.deprecatedAppendValues(d->registerArray.get(), d->numParameters);
if (d->extraArguments) {
unsigned numExtraArguments = d->numArguments - d->numParameters;
markStack.deprecatedAppendValues(d->extraArguments, numExtraArguments);
}
markStack.append(&d->callee);
if (d->activation)
markStack.append(&d->activation);
}
void JSSVGElementInstance::markChildren(MarkStack& markStack)
{
Base::markChildren(markStack);
// Mark the wrapper for our corresponding element, so it can mark its event handlers.
JSNode* correspondingWrapper = getCachedDOMNodeWrapper(impl()->correspondingElement()->document(), impl()->correspondingElement());
if (correspondingWrapper)
markStack.append(correspondingWrapper);
}
void markDOMObjectWrapper(MarkStack& markStack, JSGlobalData& globalData, void* object)
{
// FIXME: This could be changed to only mark wrappers that are "observable"
// as markDOMNodesForDocument does, allowing us to collect more wrappers,
// but doing this correctly would be challenging.
if (!object)
return;
for (JSGlobalDataWorldIterator worldIter(&globalData); worldIter; ++worldIter) {
if (DeprecatedPtr<DOMObject>* wrapperSlot = worldIter->m_wrappers.uncheckedGetSlot(object))
markStack.append(wrapperSlot);
}
}
void markDOMNodesForDocument(MarkStack& markStack, Document* document)
{
JSWrapperCacheMap& wrapperCacheMap = document->wrapperCacheMap();
for (JSWrapperCacheMap::iterator wrappersIter = wrapperCacheMap.begin(); wrappersIter != wrapperCacheMap.end(); ++wrappersIter) {
DOMWrapperWorld* world = wrappersIter->first;
JSWrapperCache* nodeDict = wrappersIter->second;
JSWrapperCache::iterator nodeEnd = nodeDict->uncheckedEnd();
for (JSWrapperCache::iterator nodeIt = nodeDict->uncheckedBegin(); nodeIt != nodeEnd; ++nodeIt) {
DeprecatedPtr<JSNode>& jsNode = nodeIt->second;
if (isObservableThroughDOM(jsNode.get(), world))
markStack.append(&jsNode);
}
}
}
void JSActivation::markChildren(MarkStack& markStack)
{
Base::markChildren(markStack);
markStack.append(&m_functionExecutable);
// No need to mark our registers if they're still in the RegisterFile.
WriteBarrier<Unknown>* registerArray = m_registerArray.get();
if (!registerArray)
return;
size_t numParametersMinusThis = m_functionExecutable->parameterCount();
size_t count = numParametersMinusThis;
markStack.appendValues(registerArray, count);
size_t numVars = m_functionExecutable->capturedVariableCount();
// Skip the call frame, which sits between the parameters and vars.
markStack.appendValues(registerArray + count + RegisterFile::CallFrameHeaderSize, numVars, MayContainNullValues);
}
static inline void markIfNeeded(MarkStack& markStack, JSValue v)
{
if (v)
markStack.append(v);
}
void JSDOMWindowShell::markChildren(MarkStack& markStack)
{
Base::markChildren(markStack);
if (m_window)
markStack.append(&m_window);
}
void JSNodeFilterCondition::markAggregate(MarkStack& markStack)
{
markStack.append(m_filter);
}
void JSStaticScopeObject::markChildren(MarkStack& markStack)
{
JSVariableObject::markChildren(markStack);
markStack.append(d()->registerStore.jsValue());
}
// Marking
void JSNotAnObject::markChildren(MarkStack& markStack)
{
TiObject::markChildren(markStack);
markStack.append(m_exception);
}
void GlobalEvalFunction::markChildren(MarkStack& markStack)
{
PrototypeFunction::markChildren(markStack);
markStack.append(m_cachedGlobalObject);
}
void NativeErrorConstructor::markChildren(MarkStack& markStack)
{
InternalFunction::markChildren(markStack);
if (m_errorStructure)
markStack.append(&m_errorStructure);
}
