From 6882a04fb36642862b11efe514251d32070c3d65 Mon Sep 17 00:00:00 2001 From: Konstantin Tokarev Date: Thu, 25 Aug 2016 19:20:41 +0300 Subject: Imported QtWebKit TP3 (git b57bc6801f1876c3220d5a4bfea33d620d477443) Change-Id: I3b1d8a2808782c9f34d50240000e20cb38d3680f Reviewed-by: Konstantin Tokarev --- Source/JavaScriptCore/bytecode/Watchpoint.cpp | 102 ++++++++++++++++++++------ 1 file changed, 78 insertions(+), 24 deletions(-) (limited to 'Source/JavaScriptCore/bytecode/Watchpoint.cpp') diff --git a/Source/JavaScriptCore/bytecode/Watchpoint.cpp b/Source/JavaScriptCore/bytecode/Watchpoint.cpp index 75dfe8a76..761c06744 100644 --- a/Source/JavaScriptCore/bytecode/Watchpoint.cpp +++ b/Source/JavaScriptCore/bytecode/Watchpoint.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2012 Apple Inc. All rights reserved. + * Copyright (C) 2012-2015 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -26,52 +26,103 @@ #include "config.h" #include "Watchpoint.h" -#include "LinkBuffer.h" +#include #include namespace JSC { +void StringFireDetail::dump(PrintStream& out) const +{ + out.print(m_string); +} + Watchpoint::~Watchpoint() { - if (isOnList()) + if (isOnList()) { + // This will happen if we get destroyed before the set fires. That's totally a valid + // possibility. For example: + // + // CodeBlock has a Watchpoint on transition from structure S1. The transition never + // happens, but the CodeBlock gets destroyed because of GC. remove(); + } +} + +void Watchpoint::fire(const FireDetail& detail) +{ + RELEASE_ASSERT(!isOnList()); + fireInternal(detail); } -WatchpointSet::WatchpointSet(InitialWatchpointSetMode mode) - : m_isWatched(mode == InitializedWatching) - , m_isInvalidated(false) +WatchpointSet::WatchpointSet(WatchpointState state) + : m_state(state) + , m_setIsNotEmpty(false) { } WatchpointSet::~WatchpointSet() { - // Fire all watchpoints. This is necessary because it is possible, say with - // structure watchpoints, for the watchpoint set owner to die while the - // watchpoint owners are still live. - fireAllWatchpoints(); + // Remove all watchpoints, so that they don't try to remove themselves. Note that we + // don't fire watchpoints on deletion. We assume that any code that is interested in + // watchpoints already also separately has a mechanism to make sure that the code is + // either keeping the watchpoint set's owner alive, or does some weak reference thing. + while (!m_set.isEmpty()) + m_set.begin()->remove(); } void WatchpointSet::add(Watchpoint* watchpoint) { + ASSERT(!isCompilationThread()); + ASSERT(state() != IsInvalidated); if (!watchpoint) return; m_set.push(watchpoint); - m_isWatched = true; + m_setIsNotEmpty = true; + m_state = IsWatched; } -void WatchpointSet::notifyWriteSlow() +void WatchpointSet::fireAllSlow(const FireDetail& detail) { - ASSERT(m_isWatched); + ASSERT(state() == IsWatched); - fireAllWatchpoints(); - m_isWatched = false; - m_isInvalidated = true; + WTF::storeStoreFence(); + m_state = IsInvalidated; // Do this first. Needed for adaptive watchpoints. + fireAllWatchpoints(detail); + WTF::storeStoreFence(); } -void WatchpointSet::fireAllWatchpoints() +void WatchpointSet::fireAllSlow(const char* reason) { - while (!m_set.isEmpty()) - m_set.begin()->fire(); + fireAllSlow(StringFireDetail(reason)); +} + +void WatchpointSet::fireAllWatchpoints(const FireDetail& detail) +{ + // In case there are any adaptive watchpoints, we need to make sure that they see that this + // watchpoint has been already invalidated. + RELEASE_ASSERT(hasBeenInvalidated()); + + while (!m_set.isEmpty()) { + Watchpoint* watchpoint = m_set.begin(); + ASSERT(watchpoint->isOnList()); + + // Removing the Watchpoint before firing it makes it possible to implement watchpoints + // that add themselves to a different set when they fire. This kind of "adaptive" + // watchpoint can be used to track some semantic property that is more fine-graiend than + // what the set can convey. For example, we might care if a singleton object ever has a + // property called "foo". We can watch for this by checking if its Structure has "foo" and + // then watching its transitions. But then the watchpoint fires if any property is added. + // So, before the watchpoint decides to invalidate any code, it can check if it is + // possible to add itself to the transition watchpoint set of the singleton object's new + // Structure. + watchpoint->remove(); + ASSERT(m_set.begin() != watchpoint); + ASSERT(!watchpoint->isOnList()); + + watchpoint->fire(detail); + // After we fire the watchpoint, the watchpoint pointer may be a dangling pointer. That's + // fine, because we have no use for the pointer anymore. + } } void InlineWatchpointSet::add(Watchpoint* watchpoint) @@ -79,14 +130,17 @@ void InlineWatchpointSet::add(Watchpoint* watchpoint) inflate()->add(watchpoint); } +void InlineWatchpointSet::fireAll(const char* reason) +{ + fireAll(StringFireDetail(reason)); +} + WatchpointSet* InlineWatchpointSet::inflateSlow() { ASSERT(isThin()); - WatchpointSet* fat = adoptRef(new WatchpointSet(InitializedBlind)).leakRef(); - if (m_data & IsInvalidatedFlag) - fat->m_isInvalidated = true; - if (m_data & IsWatchedFlag) - fat->m_isWatched = true; + ASSERT(!isCompilationThread()); + WatchpointSet* fat = adoptRef(new WatchpointSet(decodeState(m_data))).leakRef(); + WTF::storeStoreFence(); m_data = bitwise_cast(fat); return fat; } -- cgit v1.2.1