LCOV - code coverage report
Current view: top level - src - handles.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 77 77 100.0 %
Date: 2019-04-17 Functions: 14 14 100.0 %

          Line data    Source code
       1             : // Copyright 2012 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/handles.h"
       6             : 
       7             : #include "src/address-map.h"
       8             : #include "src/api.h"
       9             : #include "src/base/logging.h"
      10             : #include "src/identity-map.h"
      11             : #include "src/maybe-handles.h"
      12             : #include "src/objects-inl.h"
      13             : #include "src/roots-inl.h"
      14             : 
      15             : #ifdef DEBUG
      16             : // For GetIsolateFromWritableHeapObject.
      17             : #include "src/heap/heap-write-barrier-inl.h"
      18             : #endif
      19             : 
      20             : namespace v8 {
      21             : namespace internal {
      22             : 
      23             : // Handles should be trivially copyable so that they can be efficiently passed
      24             : // by value. If they are not trivially copyable, they cannot be passed in
      25             : // registers.
      26             : ASSERT_TRIVIALLY_COPYABLE(HandleBase);
      27             : ASSERT_TRIVIALLY_COPYABLE(Handle<Object>);
      28             : ASSERT_TRIVIALLY_COPYABLE(MaybeHandle<Object>);
      29             : 
      30             : #ifdef DEBUG
      31             : bool HandleBase::IsDereferenceAllowed(DereferenceCheckMode mode) const {
      32             :   DCHECK_NOT_NULL(location_);
      33             :   Object object(*location_);
      34             :   if (object->IsSmi()) return true;
      35             :   HeapObject heap_object = HeapObject::cast(object);
      36             :   Isolate* isolate;
      37             :   if (!GetIsolateFromWritableObject(heap_object, &isolate)) return true;
      38             :   RootIndex root_index;
      39             :   if (isolate->roots_table().IsRootHandleLocation(location_, &root_index) &&
      40             :       RootsTable::IsImmortalImmovable(root_index)) {
      41             :     return true;
      42             :   }
      43             :   if (!AllowHandleDereference::IsAllowed()) return false;
      44             :   if (mode == INCLUDE_DEFERRED_CHECK &&
      45             :       !AllowDeferredHandleDereference::IsAllowed()) {
      46             :     // Accessing cells, maps and internalized strings is safe.
      47             :     if (heap_object->IsCell()) return true;
      48             :     if (heap_object->IsMap()) return true;
      49             :     if (heap_object->IsInternalizedString()) return true;
      50             :     return !isolate->IsDeferredHandle(location_);
      51             :   }
      52             :   return true;
      53             : }
      54             : #endif
      55             : 
      56             : 
      57        6058 : int HandleScope::NumberOfHandles(Isolate* isolate) {
      58             :   HandleScopeImplementer* impl = isolate->handle_scope_implementer();
      59        6058 :   int n = static_cast<int>(impl->blocks()->size());
      60        6058 :   if (n == 0) return 0;
      61       12080 :   return ((n - 1) * kHandleBlockSize) +
      62             :          static_cast<int>(
      63       18120 :              (isolate->handle_scope_data()->next - impl->blocks()->back()));
      64             : }
      65             : 
      66     3200907 : Address* HandleScope::Extend(Isolate* isolate) {
      67             :   HandleScopeData* current = isolate->handle_scope_data();
      68             : 
      69     3200907 :   Address* result = current->next;
      70             : 
      71             :   DCHECK(result == current->limit);
      72             :   // Make sure there's at least one scope on the stack and that the
      73             :   // top of the scope stack isn't a barrier.
      74     6401820 :   if (!Utils::ApiCheck(current->level != current->sealed_level,
      75             :                        "v8::HandleScope::CreateHandle()",
      76             :                        "Cannot create a handle without a HandleScope")) {
      77             :     return nullptr;
      78             :   }
      79             :   HandleScopeImplementer* impl = isolate->handle_scope_implementer();
      80             :   // If there's more room in the last block, we use that. This is used
      81             :   // for fast creation of scopes after scope barriers.
      82     3200913 :   if (!impl->blocks()->empty()) {
      83     1190827 :     Address* limit = &impl->blocks()->back()[kHandleBlockSize];
      84     1190827 :     if (current->limit != limit) {
      85      553663 :       current->limit = limit;
      86             :       DCHECK_LT(limit - current->next, kHandleBlockSize);
      87             :     }
      88             :   }
      89             : 
      90             :   // If we still haven't found a slot for the handle, we extend the
      91             :   // current handle scope by allocating a new handle block.
      92     3200913 :   if (result == current->limit) {
      93             :     // If there's a spare block, use it for growing the current scope.
      94     2647253 :     result = impl->GetSpareOrNewBlock();
      95             :     // Add the extension to the global list of blocks, but count the
      96             :     // extension as part of the current scope.
      97     2647253 :     impl->blocks()->push_back(result);
      98     2647243 :     current->limit = &result[kHandleBlockSize];
      99             :   }
     100             : 
     101     3200903 :   return result;
     102             : }
     103             : 
     104             : 
     105     2931178 : void HandleScope::DeleteExtensions(Isolate* isolate) {
     106             :   HandleScopeData* current = isolate->handle_scope_data();
     107     2931178 :   isolate->handle_scope_implementer()->DeleteExtensions(current->limit);
     108     2931191 : }
     109             : 
     110             : 
     111             : #ifdef ENABLE_HANDLE_ZAPPING
     112   774228402 : void HandleScope::ZapRange(Address* start, Address* end) {
     113             :   DCHECK_LE(end - start, kHandleBlockSize);
     114 10090339059 :   for (Address* p = start; p != end; p++) {
     115  4656271144 :     *p = static_cast<Address>(kHandleZapValue);
     116             :   }
     117   774228402 : }
     118             : #endif
     119             : 
     120             : 
     121       62538 : Address HandleScope::current_level_address(Isolate* isolate) {
     122       62538 :   return reinterpret_cast<Address>(&isolate->handle_scope_data()->level);
     123             : }
     124             : 
     125             : 
     126       62538 : Address HandleScope::current_next_address(Isolate* isolate) {
     127       62538 :   return reinterpret_cast<Address>(&isolate->handle_scope_data()->next);
     128             : }
     129             : 
     130             : 
     131       62538 : Address HandleScope::current_limit_address(Isolate* isolate) {
     132       62538 :   return reinterpret_cast<Address>(&isolate->handle_scope_data()->limit);
     133             : }
     134             : 
     135      667876 : CanonicalHandleScope::CanonicalHandleScope(Isolate* isolate)
     136      667876 :     : isolate_(isolate), zone_(isolate->allocator(), ZONE_NAME) {
     137      667876 :   HandleScopeData* handle_scope_data = isolate_->handle_scope_data();
     138      667876 :   prev_canonical_scope_ = handle_scope_data->canonical_scope;
     139      667876 :   handle_scope_data->canonical_scope = this;
     140      667876 :   root_index_map_ = new RootIndexMap(isolate);
     141             :   identity_map_ = new IdentityMap<Address*, ZoneAllocationPolicy>(
     142     1335755 :       isolate->heap(), ZoneAllocationPolicy(&zone_));
     143      667879 :   canonical_level_ = handle_scope_data->level;
     144      667879 : }
     145             : 
     146             : 
     147     1335760 : CanonicalHandleScope::~CanonicalHandleScope() {
     148      667880 :   delete root_index_map_;
     149      667880 :   delete identity_map_;
     150      667880 :   isolate_->handle_scope_data()->canonical_scope = prev_canonical_scope_;
     151      667880 : }
     152             : 
     153   250617974 : Address* CanonicalHandleScope::Lookup(Address object) {
     154             :   DCHECK_LE(canonical_level_, isolate_->handle_scope_data()->level);
     155   250617974 :   if (isolate_->handle_scope_data()->level != canonical_level_) {
     156             :     // We are in an inner handle scope. Do not canonicalize since we will leave
     157             :     // this handle scope while still being in the canonical scope.
     158     2617167 :     return HandleScope::CreateHandle(isolate_, object);
     159             :   }
     160   248000807 :   if (Internals::HasHeapObjectTag(object)) {
     161             :     RootIndex root_index;
     162   242657425 :     if (root_index_map_->Lookup(object, &root_index)) {
     163    81972357 :       return isolate_->root_handle(root_index).location();
     164             :     }
     165             :   }
     166   166035866 :   Address** entry = identity_map_->Get(Object(object));
     167   166034419 :   if (*entry == nullptr) {
     168             :     // Allocate new handle location.
     169   129757322 :     *entry = HandleScope::CreateHandle(isolate_, object);
     170             :   }
     171   166034421 :   return *entry;
     172             : }
     173             : 
     174             : 
     175        6890 : DeferredHandleScope::DeferredHandleScope(Isolate* isolate)
     176        6890 :     : impl_(isolate->handle_scope_implementer()) {
     177        6890 :   impl_->BeginDeferredScope();
     178        6890 :   HandleScopeData* data = impl_->isolate()->handle_scope_data();
     179        6890 :   Address* new_next = impl_->GetSpareOrNewBlock();
     180        6890 :   Address* new_limit = &new_next[kHandleBlockSize];
     181             :   // Check that at least one HandleScope with at least one Handle in it exists,
     182             :   // see the class description.
     183             :   DCHECK(!impl_->blocks()->empty());
     184             :   // Check that we are not in a SealedHandleScope.
     185             :   DCHECK(data->limit == &impl_->blocks()->back()[kHandleBlockSize]);
     186       13780 :   impl_->blocks()->push_back(new_next);
     187             : 
     188             : #ifdef DEBUG
     189             :   prev_level_ = data->level;
     190             : #endif
     191        6890 :   data->level++;
     192        6890 :   prev_limit_ = data->limit;
     193        6890 :   prev_next_ = data->next;
     194        6890 :   data->next = new_next;
     195        6890 :   data->limit = new_limit;
     196        6890 : }
     197             : 
     198             : 
     199       13780 : DeferredHandleScope::~DeferredHandleScope() {
     200        6890 :   impl_->isolate()->handle_scope_data()->level--;
     201             :   DCHECK(handles_detached_);
     202             :   DCHECK(impl_->isolate()->handle_scope_data()->level == prev_level_);
     203        6890 : }
     204             : 
     205             : 
     206        6890 : DeferredHandles* DeferredHandleScope::Detach() {
     207        6890 :   DeferredHandles* deferred = impl_->Detach(prev_limit_);
     208        6890 :   HandleScopeData* data = impl_->isolate()->handle_scope_data();
     209        6890 :   data->next = prev_next_;
     210        6890 :   data->limit = prev_limit_;
     211             : #ifdef DEBUG
     212             :   handles_detached_ = true;
     213             : #endif
     214        6890 :   return deferred;
     215             : }
     216             : 
     217             : }  // namespace internal
     218      122004 : }  // namespace v8

Generated by: LCOV version 1.10