LCOV - code coverage report
Current view: top level - src - assert-scope.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 8 43 18.6 %
Date: 2017-04-26 Functions: 10 72 13.9 %

          Line data    Source code
       1             : // Copyright 2014 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include "src/assert-scope.h"
       6             : 
       7             : #include "src/base/lazy-instance.h"
       8             : #include "src/base/platform/platform.h"
       9             : #include "src/isolate.h"
      10             : #include "src/utils.h"
      11             : 
      12             : namespace v8 {
      13             : namespace internal {
      14             : 
      15             : namespace {
      16             : 
      17             : struct PerThreadAssertKeyConstructTrait final {
      18             :   static void Construct(base::Thread::LocalStorageKey* key) {
      19           0 :     *key = base::Thread::CreateThreadLocalKey();
      20             :   }
      21             : };
      22             : 
      23             : 
      24             : typedef base::LazyStaticInstance<base::Thread::LocalStorageKey,
      25             :                                  PerThreadAssertKeyConstructTrait>::type
      26             :     PerThreadAssertKey;
      27             : 
      28             : 
      29             : PerThreadAssertKey kPerThreadAssertKey;
      30             : 
      31             : }  // namespace
      32             : 
      33             : 
      34             : class PerThreadAssertData final {
      35             :  public:
      36           0 :   PerThreadAssertData() : nesting_level_(0) {
      37           0 :     for (int i = 0; i < LAST_PER_THREAD_ASSERT_TYPE; i++) {
      38           0 :       assert_states_[i] = true;
      39             :     }
      40             :   }
      41             : 
      42             :   ~PerThreadAssertData() {
      43             :     for (int i = 0; i < LAST_PER_THREAD_ASSERT_TYPE; ++i) {
      44             :       DCHECK(assert_states_[i]);
      45             :     }
      46             :   }
      47             : 
      48           0 :   bool Get(PerThreadAssertType type) const { return assert_states_[type]; }
      49           0 :   void Set(PerThreadAssertType type, bool x) { assert_states_[type] = x; }
      50             : 
      51           0 :   void IncrementLevel() { ++nesting_level_; }
      52           0 :   bool DecrementLevel() { return --nesting_level_ == 0; }
      53             : 
      54           0 :   static PerThreadAssertData* GetCurrent() {
      55             :     return reinterpret_cast<PerThreadAssertData*>(
      56           0 :         base::Thread::GetThreadLocal(kPerThreadAssertKey.Get()));
      57             :   }
      58           0 :   static void SetCurrent(PerThreadAssertData* data) {
      59           0 :     base::Thread::SetThreadLocal(kPerThreadAssertKey.Get(), data);
      60           0 :   }
      61             : 
      62             :  private:
      63             :   bool assert_states_[LAST_PER_THREAD_ASSERT_TYPE];
      64             :   int nesting_level_;
      65             : 
      66             :   DISALLOW_COPY_AND_ASSIGN(PerThreadAssertData);
      67             : };
      68             : 
      69             : 
      70             : template <PerThreadAssertType kType, bool kAllow>
      71           0 : PerThreadAssertScope<kType, kAllow>::PerThreadAssertScope()
      72           0 :     : data_(PerThreadAssertData::GetCurrent()) {
      73           0 :   if (data_ == NULL) {
      74           0 :     data_ = new PerThreadAssertData();
      75           0 :     PerThreadAssertData::SetCurrent(data_);
      76             :   }
      77           0 :   data_->IncrementLevel();
      78           0 :   old_state_ = data_->Get(kType);
      79             :   data_->Set(kType, kAllow);
      80           0 : }
      81             : 
      82             : 
      83             : template <PerThreadAssertType kType, bool kAllow>
      84           0 : PerThreadAssertScope<kType, kAllow>::~PerThreadAssertScope() {
      85           0 :   if (data_ == nullptr) return;
      86           0 :   Release();
      87           0 : }
      88             : 
      89             : template <PerThreadAssertType kType, bool kAllow>
      90           0 : void PerThreadAssertScope<kType, kAllow>::Release() {
      91             :   DCHECK_NOT_NULL(data_);
      92           0 :   data_->Set(kType, old_state_);
      93           0 :   if (data_->DecrementLevel()) {
      94           0 :     PerThreadAssertData::SetCurrent(NULL);
      95           0 :     delete data_;
      96             :   }
      97           0 :   data_ = nullptr;
      98           0 : }
      99             : 
     100             : // static
     101             : template <PerThreadAssertType kType, bool kAllow>
     102           0 : bool PerThreadAssertScope<kType, kAllow>::IsAllowed() {
     103           0 :   PerThreadAssertData* data = PerThreadAssertData::GetCurrent();
     104           0 :   return data == NULL || data->Get(kType);
     105             : }
     106             : 
     107             : 
     108             : template <PerIsolateAssertType kType, bool kAllow>
     109             : class PerIsolateAssertScope<kType, kAllow>::DataBit
     110             :     : public BitField<bool, kType, 1> {};
     111             : 
     112             : 
     113             : template <PerIsolateAssertType kType, bool kAllow>
     114    29656366 : PerIsolateAssertScope<kType, kAllow>::PerIsolateAssertScope(Isolate* isolate)
     115    29656366 :     : isolate_(isolate), old_data_(isolate->per_isolate_assert_data()) {
     116             :   DCHECK_NOT_NULL(isolate);
     117             :   STATIC_ASSERT(kType < 32);
     118             :   isolate_->set_per_isolate_assert_data(DataBit::update(old_data_, kAllow));
     119    14828183 : }
     120             : 
     121             : 
     122             : template <PerIsolateAssertType kType, bool kAllow>
     123    14828212 : PerIsolateAssertScope<kType, kAllow>::~PerIsolateAssertScope() {
     124    14828212 :   isolate_->set_per_isolate_assert_data(old_data_);
     125    14828212 : }
     126             : 
     127             : 
     128             : // static
     129             : template <PerIsolateAssertType kType, bool kAllow>
     130   124652062 : bool PerIsolateAssertScope<kType, kAllow>::IsAllowed(Isolate* isolate) {
     131   124652062 :   return DataBit::decode(isolate->per_isolate_assert_data());
     132             : }
     133             : 
     134             : 
     135             : // -----------------------------------------------------------------------------
     136             : // Instantiations.
     137             : 
     138             : template class PerThreadAssertScope<HEAP_ALLOCATION_ASSERT, false>;
     139             : template class PerThreadAssertScope<HEAP_ALLOCATION_ASSERT, true>;
     140             : template class PerThreadAssertScope<HANDLE_ALLOCATION_ASSERT, false>;
     141             : template class PerThreadAssertScope<HANDLE_ALLOCATION_ASSERT, true>;
     142             : template class PerThreadAssertScope<HANDLE_DEREFERENCE_ASSERT, false>;
     143             : template class PerThreadAssertScope<HANDLE_DEREFERENCE_ASSERT, true>;
     144             : template class PerThreadAssertScope<DEFERRED_HANDLE_DEREFERENCE_ASSERT, false>;
     145             : template class PerThreadAssertScope<DEFERRED_HANDLE_DEREFERENCE_ASSERT, true>;
     146             : template class PerThreadAssertScope<CODE_DEPENDENCY_CHANGE_ASSERT, false>;
     147             : template class PerThreadAssertScope<CODE_DEPENDENCY_CHANGE_ASSERT, true>;
     148             : 
     149             : template class PerIsolateAssertScope<JAVASCRIPT_EXECUTION_ASSERT, false>;
     150             : template class PerIsolateAssertScope<JAVASCRIPT_EXECUTION_ASSERT, true>;
     151             : template class PerIsolateAssertScope<JAVASCRIPT_EXECUTION_THROWS, false>;
     152             : template class PerIsolateAssertScope<JAVASCRIPT_EXECUTION_THROWS, true>;
     153             : template class PerIsolateAssertScope<DEOPTIMIZATION_ASSERT, false>;
     154             : template class PerIsolateAssertScope<DEOPTIMIZATION_ASSERT, true>;
     155             : template class PerIsolateAssertScope<COMPILATION_ASSERT, false>;
     156             : template class PerIsolateAssertScope<COMPILATION_ASSERT, true>;
     157             : template class PerIsolateAssertScope<NO_EXCEPTION_ASSERT, false>;
     158             : template class PerIsolateAssertScope<NO_EXCEPTION_ASSERT, true>;
     159             : 
     160             : }  // namespace internal
     161             : }  // namespace v8

Generated by: LCOV version 1.10