diff options
Diffstat (limited to 'chromium/v8/src/assert-scope.h')
| -rw-r--r-- | chromium/v8/src/assert-scope.h | 169 |
1 files changed, 122 insertions, 47 deletions
diff --git a/chromium/v8/src/assert-scope.h b/chromium/v8/src/assert-scope.h index 269b280d027..14e1194ba5c 100644 --- a/chromium/v8/src/assert-scope.h +++ b/chromium/v8/src/assert-scope.h @@ -1,35 +1,13 @@ // Copyright 2013 the V8 project authors. All rights reserved. -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following -// disclaimer in the documentation and/or other materials provided -// with the distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived -// from this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. #ifndef V8_ASSERT_SCOPE_H_ #define V8_ASSERT_SCOPE_H_ -#include "allocation.h" -#include "platform.h" +#include "src/allocation.h" +#include "src/platform.h" +#include "src/utils.h" namespace v8 { namespace internal { @@ -46,7 +24,14 @@ enum PerThreadAssertType { }; -#ifdef DEBUG +enum PerIsolateAssertType { + JAVASCRIPT_EXECUTION_ASSERT, + JAVASCRIPT_EXECUTION_THROWS, + ALLOCATION_FAILURE_ASSERT, + DEOPTIMIZATION_ASSERT +}; + + class PerThreadAssertData { public: PerThreadAssertData() : nesting_level_(0) { @@ -72,12 +57,9 @@ class PerThreadAssertData { DISALLOW_COPY_AND_ASSIGN(PerThreadAssertData); }; -#endif // DEBUG class PerThreadAssertScopeBase { -#ifdef DEBUG - protected: PerThreadAssertScopeBase() { data_ = GetAssertData(); @@ -110,18 +92,12 @@ class PerThreadAssertScopeBase { static void SetThreadLocalData(PerThreadAssertData* data) { Thread::SetThreadLocal(thread_local_key, data); } -#endif // DEBUG }; - template <PerThreadAssertType type, bool allow> class PerThreadAssertScope : public PerThreadAssertScopeBase { public: -#ifndef DEBUG - PerThreadAssertScope() { } - static void SetIsAllowed(bool is_allowed) { } -#else PerThreadAssertScope() { old_state_ = data_->get(type); data_->set(type, allow); @@ -136,49 +112,148 @@ class PerThreadAssertScope : public PerThreadAssertScopeBase { private: bool old_state_; + + DISALLOW_COPY_AND_ASSIGN(PerThreadAssertScope); +}; + + +class PerIsolateAssertBase { + protected: + static uint32_t GetData(Isolate* isolate); + static void SetData(Isolate* isolate, uint32_t data); +}; + + +template <PerIsolateAssertType type, bool allow> +class PerIsolateAssertScope : public PerIsolateAssertBase { + public: + explicit PerIsolateAssertScope(Isolate* isolate) : isolate_(isolate) { + STATIC_ASSERT(type < 32); + old_data_ = GetData(isolate_); + SetData(isolate_, DataBit::update(old_data_, allow)); + } + + ~PerIsolateAssertScope() { + SetData(isolate_, old_data_); + } + + static bool IsAllowed(Isolate* isolate) { + return DataBit::decode(GetData(isolate)); + } + + private: + typedef BitField<bool, type, 1> DataBit; + + uint32_t old_data_; + Isolate* isolate_; + + DISALLOW_COPY_AND_ASSIGN(PerIsolateAssertScope); +}; + + +template <PerThreadAssertType type, bool allow> +#ifdef DEBUG +class PerThreadAssertScopeDebugOnly : public + PerThreadAssertScope<type, allow> { +#else +class PerThreadAssertScopeDebugOnly { + public: + PerThreadAssertScopeDebugOnly() { } +#endif +}; + + +template <PerIsolateAssertType type, bool allow> +#ifdef DEBUG +class PerIsolateAssertScopeDebugOnly : public + PerIsolateAssertScope<type, allow> { + public: + explicit PerIsolateAssertScopeDebugOnly(Isolate* isolate) + : PerIsolateAssertScope<type, allow>(isolate) { } +#else +class PerIsolateAssertScopeDebugOnly { + public: + explicit PerIsolateAssertScopeDebugOnly(Isolate* isolate) { } #endif }; +// Per-thread assert scopes. + // Scope to document where we do not expect handles to be created. -typedef PerThreadAssertScope<HANDLE_ALLOCATION_ASSERT, false> +typedef PerThreadAssertScopeDebugOnly<HANDLE_ALLOCATION_ASSERT, false> DisallowHandleAllocation; // Scope to introduce an exception to DisallowHandleAllocation. -typedef PerThreadAssertScope<HANDLE_ALLOCATION_ASSERT, true> +typedef PerThreadAssertScopeDebugOnly<HANDLE_ALLOCATION_ASSERT, true> AllowHandleAllocation; // Scope to document where we do not expect any allocation and GC. -typedef PerThreadAssertScope<HEAP_ALLOCATION_ASSERT, false> +typedef PerThreadAssertScopeDebugOnly<HEAP_ALLOCATION_ASSERT, false> DisallowHeapAllocation; // Scope to introduce an exception to DisallowHeapAllocation. -typedef PerThreadAssertScope<HEAP_ALLOCATION_ASSERT, true> +typedef PerThreadAssertScopeDebugOnly<HEAP_ALLOCATION_ASSERT, true> AllowHeapAllocation; // Scope to document where we do not expect any handle dereferences. -typedef PerThreadAssertScope<HANDLE_DEREFERENCE_ASSERT, false> +typedef PerThreadAssertScopeDebugOnly<HANDLE_DEREFERENCE_ASSERT, false> DisallowHandleDereference; // Scope to introduce an exception to DisallowHandleDereference. -typedef PerThreadAssertScope<HANDLE_DEREFERENCE_ASSERT, true> +typedef PerThreadAssertScopeDebugOnly<HANDLE_DEREFERENCE_ASSERT, true> AllowHandleDereference; // Scope to document where we do not expect deferred handles to be dereferenced. -typedef PerThreadAssertScope<DEFERRED_HANDLE_DEREFERENCE_ASSERT, false> +typedef PerThreadAssertScopeDebugOnly<DEFERRED_HANDLE_DEREFERENCE_ASSERT, false> DisallowDeferredHandleDereference; // Scope to introduce an exception to DisallowDeferredHandleDereference. -typedef PerThreadAssertScope<DEFERRED_HANDLE_DEREFERENCE_ASSERT, true> +typedef PerThreadAssertScopeDebugOnly<DEFERRED_HANDLE_DEREFERENCE_ASSERT, true> AllowDeferredHandleDereference; // Scope to document where we do not expect deferred handles to be dereferenced. -typedef PerThreadAssertScope<CODE_DEPENDENCY_CHANGE_ASSERT, false> +typedef PerThreadAssertScopeDebugOnly<CODE_DEPENDENCY_CHANGE_ASSERT, false> DisallowCodeDependencyChange; // Scope to introduce an exception to DisallowDeferredHandleDereference. -typedef PerThreadAssertScope<CODE_DEPENDENCY_CHANGE_ASSERT, true> +typedef PerThreadAssertScopeDebugOnly<CODE_DEPENDENCY_CHANGE_ASSERT, true> AllowCodeDependencyChange; + +// Per-isolate assert scopes. + +// Scope to document where we do not expect javascript execution. +typedef PerIsolateAssertScope<JAVASCRIPT_EXECUTION_ASSERT, false> + DisallowJavascriptExecution; + +// Scope to introduce an exception to DisallowJavascriptExecution. +typedef PerIsolateAssertScope<JAVASCRIPT_EXECUTION_ASSERT, true> + AllowJavascriptExecution; + +// Scope in which javascript execution leads to exception being thrown. +typedef PerIsolateAssertScope<JAVASCRIPT_EXECUTION_THROWS, false> + ThrowOnJavascriptExecution; + +// Scope to introduce an exception to ThrowOnJavascriptExecution. +typedef PerIsolateAssertScope<JAVASCRIPT_EXECUTION_THROWS, true> + NoThrowOnJavascriptExecution; + +// Scope to document where we do not expect an allocation failure. +typedef PerIsolateAssertScopeDebugOnly<ALLOCATION_FAILURE_ASSERT, false> + DisallowAllocationFailure; + +// Scope to introduce an exception to DisallowAllocationFailure. +typedef PerIsolateAssertScopeDebugOnly<ALLOCATION_FAILURE_ASSERT, true> + AllowAllocationFailure; + +// Scope to document where we do not expect deoptimization. +typedef PerIsolateAssertScopeDebugOnly<DEOPTIMIZATION_ASSERT, false> + DisallowDeoptimization; + +// Scope to introduce an exception to DisallowDeoptimization. +typedef PerIsolateAssertScopeDebugOnly<DEOPTIMIZATION_ASSERT, true> + AllowDeoptimization; + } } // namespace v8::internal #endif // V8_ASSERT_SCOPE_H_ |