LCOV - code coverage report
Current view: top level - src/runtime - runtime-collections.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 140 184 76.1 %
Date: 2017-04-26 Functions: 21 54 38.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/runtime/runtime-utils.h"
       6             : 
       7             : #include "src/arguments.h"
       8             : #include "src/conversions-inl.h"
       9             : #include "src/factory.h"
      10             : 
      11             : namespace v8 {
      12             : namespace internal {
      13             : 
      14             : 
      15      132170 : RUNTIME_FUNCTION(Runtime_StringGetRawHashField) {
      16       66085 :   HandleScope scope(isolate);
      17             :   DCHECK_EQ(1, args.length());
      18      132170 :   CONVERT_ARG_HANDLE_CHECKED(String, string, 0);
      19      132170 :   return *isolate->factory()->NewNumberFromUint(string->hash_field());
      20             : }
      21             : 
      22             : 
      23      777894 : RUNTIME_FUNCTION(Runtime_TheHole) {
      24             :   SealHandleScope shs(isolate);
      25             :   DCHECK_EQ(0, args.length());
      26      388947 :   return isolate->heap()->the_hole_value();
      27             : }
      28             : 
      29             : 
      30     2290268 : RUNTIME_FUNCTION(Runtime_JSCollectionGetTable) {
      31             :   SealHandleScope shs(isolate);
      32             :   DCHECK_EQ(1, args.length());
      33     2290268 :   CONVERT_ARG_CHECKED(JSObject, object, 0);
      34     2199938 :   CHECK(object->IsJSSet() || object->IsJSMap());
      35     1145134 :   return static_cast<JSCollection*>(object)->table();
      36             : }
      37             : 
      38             : 
      39       95440 : RUNTIME_FUNCTION(Runtime_GenericHash) {
      40       47720 :   HandleScope scope(isolate);
      41             :   DCHECK_EQ(1, args.length());
      42       47720 :   CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
      43       47720 :   Smi* hash = Object::GetOrCreateHash(isolate, object);
      44       47720 :   return hash;
      45             : }
      46             : 
      47             : 
      48      157050 : RUNTIME_FUNCTION(Runtime_SetInitialize) {
      49       78525 :   HandleScope scope(isolate);
      50             :   DCHECK_EQ(1, args.length());
      51      157050 :   CONVERT_ARG_HANDLE_CHECKED(JSSet, holder, 0);
      52       78525 :   JSSet::Initialize(holder, isolate);
      53       78525 :   return *holder;
      54             : }
      55             : 
      56             : 
      57       14054 : RUNTIME_FUNCTION(Runtime_SetGrow) {
      58        7027 :   HandleScope scope(isolate);
      59             :   DCHECK_EQ(1, args.length());
      60       14054 :   CONVERT_ARG_HANDLE_CHECKED(JSSet, holder, 0);
      61        7027 :   Handle<OrderedHashSet> table(OrderedHashSet::cast(holder->table()));
      62        7027 :   table = OrderedHashSet::EnsureGrowable(table);
      63        7027 :   holder->set_table(*table);
      64        7027 :   return isolate->heap()->undefined_value();
      65             : }
      66             : 
      67             : 
      68         952 : RUNTIME_FUNCTION(Runtime_SetShrink) {
      69         476 :   HandleScope scope(isolate);
      70             :   DCHECK_EQ(1, args.length());
      71         952 :   CONVERT_ARG_HANDLE_CHECKED(JSSet, holder, 0);
      72         476 :   Handle<OrderedHashSet> table(OrderedHashSet::cast(holder->table()));
      73         476 :   table = OrderedHashSet::Shrink(table);
      74         476 :   holder->set_table(*table);
      75         476 :   return isolate->heap()->undefined_value();
      76             : }
      77             : 
      78             : 
      79          78 : RUNTIME_FUNCTION(Runtime_SetClear) {
      80          39 :   HandleScope scope(isolate);
      81             :   DCHECK_EQ(1, args.length());
      82          78 :   CONVERT_ARG_HANDLE_CHECKED(JSSet, holder, 0);
      83          39 :   JSSet::Clear(holder);
      84          39 :   return isolate->heap()->undefined_value();
      85             : }
      86             : 
      87             : 
      88       13206 : RUNTIME_FUNCTION(Runtime_SetIteratorInitialize) {
      89        6603 :   HandleScope scope(isolate);
      90             :   DCHECK_EQ(3, args.length());
      91       13206 :   CONVERT_ARG_HANDLE_CHECKED(JSSetIterator, holder, 0);
      92       13206 :   CONVERT_ARG_HANDLE_CHECKED(JSSet, set, 1);
      93       13206 :   CONVERT_SMI_ARG_CHECKED(kind, 2)
      94        6603 :   CHECK(kind == JSSetIterator::kKindValues ||
      95             :         kind == JSSetIterator::kKindEntries);
      96        6603 :   Handle<OrderedHashSet> table(OrderedHashSet::cast(set->table()));
      97        6603 :   holder->set_table(*table);
      98        6603 :   holder->set_index(Smi::kZero);
      99       13206 :   holder->set_kind(Smi::FromInt(kind));
     100        6603 :   return isolate->heap()->undefined_value();
     101             : }
     102             : 
     103             : 
     104           0 : RUNTIME_FUNCTION(Runtime_SetIteratorClone) {
     105           0 :   HandleScope scope(isolate);
     106             :   DCHECK_EQ(1, args.length());
     107           0 :   CONVERT_ARG_HANDLE_CHECKED(JSSetIterator, holder, 0);
     108             : 
     109           0 :   Handle<JSSetIterator> result = isolate->factory()->NewJSSetIterator();
     110           0 :   result->set_table(holder->table());
     111           0 :   result->set_index(Smi::FromInt(Smi::cast(holder->index())->value()));
     112           0 :   result->set_kind(Smi::FromInt(Smi::cast(holder->kind())->value()));
     113             : 
     114           0 :   return *result;
     115             : }
     116             : 
     117             : 
     118       15370 : RUNTIME_FUNCTION(Runtime_SetIteratorNext) {
     119             :   SealHandleScope shs(isolate);
     120             :   DCHECK_EQ(2, args.length());
     121       15370 :   CONVERT_ARG_CHECKED(JSSetIterator, holder, 0);
     122       15370 :   CONVERT_ARG_CHECKED(JSArray, value_array, 1);
     123        7685 :   return holder->Next(value_array);
     124             : }
     125             : 
     126             : 
     127             : // The array returned contains the following information:
     128             : // 0: HasMore flag
     129             : // 1: Iteration index
     130             : // 2: Iteration kind
     131           0 : RUNTIME_FUNCTION(Runtime_SetIteratorDetails) {
     132           0 :   HandleScope scope(isolate);
     133             :   DCHECK_EQ(1, args.length());
     134           0 :   CONVERT_ARG_HANDLE_CHECKED(JSSetIterator, holder, 0);
     135           0 :   Handle<FixedArray> details = isolate->factory()->NewFixedArray(4);
     136           0 :   details->set(0, isolate->heap()->ToBoolean(holder->HasMore()));
     137           0 :   details->set(1, holder->index());
     138           0 :   details->set(2, holder->kind());
     139           0 :   return *isolate->factory()->NewJSArrayWithElements(details);
     140             : }
     141             : 
     142             : 
     143      160020 : RUNTIME_FUNCTION(Runtime_MapInitialize) {
     144       80010 :   HandleScope scope(isolate);
     145             :   DCHECK_EQ(1, args.length());
     146      160020 :   CONVERT_ARG_HANDLE_CHECKED(JSMap, holder, 0);
     147       80010 :   JSMap::Initialize(holder, isolate);
     148       80010 :   return *holder;
     149             : }
     150             : 
     151             : 
     152      403224 : RUNTIME_FUNCTION(Runtime_MapShrink) {
     153      201612 :   HandleScope scope(isolate);
     154             :   DCHECK_EQ(1, args.length());
     155      403224 :   CONVERT_ARG_HANDLE_CHECKED(JSMap, holder, 0);
     156      201612 :   Handle<OrderedHashMap> table(OrderedHashMap::cast(holder->table()));
     157      201612 :   table = OrderedHashMap::Shrink(table);
     158      201612 :   holder->set_table(*table);
     159      201612 :   return isolate->heap()->undefined_value();
     160             : }
     161             : 
     162             : 
     163         616 : RUNTIME_FUNCTION(Runtime_MapClear) {
     164         308 :   HandleScope scope(isolate);
     165             :   DCHECK_EQ(1, args.length());
     166         616 :   CONVERT_ARG_HANDLE_CHECKED(JSMap, holder, 0);
     167         308 :   JSMap::Clear(holder);
     168         308 :   return isolate->heap()->undefined_value();
     169             : }
     170             : 
     171             : 
     172       22632 : RUNTIME_FUNCTION(Runtime_MapGrow) {
     173       11316 :   HandleScope scope(isolate);
     174             :   DCHECK_EQ(1, args.length());
     175       22632 :   CONVERT_ARG_HANDLE_CHECKED(JSMap, holder, 0);
     176       11316 :   Handle<OrderedHashMap> table(OrderedHashMap::cast(holder->table()));
     177       11316 :   table = OrderedHashMap::EnsureGrowable(table);
     178       11316 :   holder->set_table(*table);
     179       11316 :   return isolate->heap()->undefined_value();
     180             : }
     181             : 
     182             : 
     183       12854 : RUNTIME_FUNCTION(Runtime_MapIteratorInitialize) {
     184        6427 :   HandleScope scope(isolate);
     185             :   DCHECK_EQ(3, args.length());
     186       12854 :   CONVERT_ARG_HANDLE_CHECKED(JSMapIterator, holder, 0);
     187       12854 :   CONVERT_ARG_HANDLE_CHECKED(JSMap, map, 1);
     188       12854 :   CONVERT_SMI_ARG_CHECKED(kind, 2)
     189        6427 :   CHECK(kind == JSMapIterator::kKindKeys ||
     190             :         kind == JSMapIterator::kKindValues ||
     191             :         kind == JSMapIterator::kKindEntries);
     192        6427 :   Handle<OrderedHashMap> table(OrderedHashMap::cast(map->table()));
     193        6427 :   holder->set_table(*table);
     194        6427 :   holder->set_index(Smi::kZero);
     195       12854 :   holder->set_kind(Smi::FromInt(kind));
     196        6427 :   return isolate->heap()->undefined_value();
     197             : }
     198             : 
     199             : 
     200           0 : RUNTIME_FUNCTION(Runtime_MapIteratorClone) {
     201           0 :   HandleScope scope(isolate);
     202             :   DCHECK_EQ(1, args.length());
     203           0 :   CONVERT_ARG_HANDLE_CHECKED(JSMapIterator, holder, 0);
     204             : 
     205           0 :   Handle<JSMapIterator> result = isolate->factory()->NewJSMapIterator();
     206           0 :   result->set_table(holder->table());
     207           0 :   result->set_index(Smi::FromInt(Smi::cast(holder->index())->value()));
     208           0 :   result->set_kind(Smi::FromInt(Smi::cast(holder->kind())->value()));
     209             : 
     210           0 :   return *result;
     211             : }
     212             : 
     213             : 
     214             : // The array returned contains the following information:
     215             : // 0: HasMore flag
     216             : // 1: Iteration index
     217             : // 2: Iteration kind
     218           0 : RUNTIME_FUNCTION(Runtime_MapIteratorDetails) {
     219           0 :   HandleScope scope(isolate);
     220             :   DCHECK_EQ(1, args.length());
     221           0 :   CONVERT_ARG_HANDLE_CHECKED(JSMapIterator, holder, 0);
     222           0 :   Handle<FixedArray> details = isolate->factory()->NewFixedArray(4);
     223           0 :   details->set(0, isolate->heap()->ToBoolean(holder->HasMore()));
     224           0 :   details->set(1, holder->index());
     225           0 :   details->set(2, holder->kind());
     226           0 :   return *isolate->factory()->NewJSArrayWithElements(details);
     227             : }
     228             : 
     229             : 
     230           0 : RUNTIME_FUNCTION(Runtime_GetWeakMapEntries) {
     231           0 :   HandleScope scope(isolate);
     232             :   DCHECK_EQ(2, args.length());
     233           0 :   CONVERT_ARG_HANDLE_CHECKED(JSWeakCollection, holder, 0);
     234           0 :   CONVERT_NUMBER_CHECKED(int, max_entries, Int32, args[1]);
     235           0 :   CHECK(max_entries >= 0);
     236           0 :   return *JSWeakCollection::GetEntries(holder, max_entries);
     237             : }
     238             : 
     239             : 
     240        8692 : RUNTIME_FUNCTION(Runtime_MapIteratorNext) {
     241             :   SealHandleScope shs(isolate);
     242             :   DCHECK_EQ(2, args.length());
     243        8692 :   CONVERT_ARG_CHECKED(JSMapIterator, holder, 0);
     244        8692 :   CONVERT_ARG_CHECKED(JSArray, value_array, 1);
     245        4346 :   return holder->Next(value_array);
     246             : }
     247             : 
     248             : 
     249      258564 : RUNTIME_FUNCTION(Runtime_WeakCollectionInitialize) {
     250      129282 :   HandleScope scope(isolate);
     251             :   DCHECK_EQ(1, args.length());
     252      258564 :   CONVERT_ARG_HANDLE_CHECKED(JSWeakCollection, weak_collection, 0);
     253      129282 :   JSWeakCollection::Initialize(weak_collection, isolate);
     254      129282 :   return *weak_collection;
     255             : }
     256             : 
     257             : 
     258        3556 : RUNTIME_FUNCTION(Runtime_WeakCollectionGet) {
     259        1778 :   HandleScope scope(isolate);
     260             :   DCHECK_EQ(3, args.length());
     261        3556 :   CONVERT_ARG_HANDLE_CHECKED(JSWeakCollection, weak_collection, 0);
     262        1778 :   CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
     263        3556 :   CONVERT_SMI_ARG_CHECKED(hash, 2)
     264        1778 :   CHECK(key->IsJSReceiver() || key->IsSymbol());
     265             :   Handle<ObjectHashTable> table(
     266        1778 :       ObjectHashTable::cast(weak_collection->table()));
     267        1778 :   CHECK(table->IsKey(isolate, *key));
     268        1778 :   Handle<Object> lookup(table->Lookup(key, hash), isolate);
     269          98 :   return lookup->IsTheHole(isolate) ? isolate->heap()->undefined_value()
     270        3654 :                                     : *lookup;
     271             : }
     272             : 
     273             : 
     274        1288 : RUNTIME_FUNCTION(Runtime_WeakCollectionHas) {
     275         644 :   HandleScope scope(isolate);
     276             :   DCHECK_EQ(3, args.length());
     277        1288 :   CONVERT_ARG_HANDLE_CHECKED(JSWeakCollection, weak_collection, 0);
     278         644 :   CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
     279        1288 :   CONVERT_SMI_ARG_CHECKED(hash, 2)
     280         644 :   CHECK(key->IsJSReceiver() || key->IsSymbol());
     281             :   Handle<ObjectHashTable> table(
     282         644 :       ObjectHashTable::cast(weak_collection->table()));
     283         644 :   CHECK(table->IsKey(isolate, *key));
     284         644 :   Handle<Object> lookup(table->Lookup(key, hash), isolate);
     285         644 :   return isolate->heap()->ToBoolean(!lookup->IsTheHole(isolate));
     286             : }
     287             : 
     288             : 
     289         224 : RUNTIME_FUNCTION(Runtime_WeakCollectionDelete) {
     290         112 :   HandleScope scope(isolate);
     291             :   DCHECK_EQ(3, args.length());
     292         224 :   CONVERT_ARG_HANDLE_CHECKED(JSWeakCollection, weak_collection, 0);
     293         112 :   CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
     294         224 :   CONVERT_SMI_ARG_CHECKED(hash, 2)
     295         112 :   CHECK(key->IsJSReceiver() || key->IsSymbol());
     296             :   Handle<ObjectHashTable> table(
     297         112 :       ObjectHashTable::cast(weak_collection->table()));
     298         112 :   CHECK(table->IsKey(isolate, *key));
     299         112 :   bool was_present = JSWeakCollection::Delete(weak_collection, key, hash);
     300         112 :   return isolate->heap()->ToBoolean(was_present);
     301             : }
     302             : 
     303             : 
     304        3994 : RUNTIME_FUNCTION(Runtime_WeakCollectionSet) {
     305        1997 :   HandleScope scope(isolate);
     306             :   DCHECK_EQ(4, args.length());
     307        3994 :   CONVERT_ARG_HANDLE_CHECKED(JSWeakCollection, weak_collection, 0);
     308        1997 :   CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
     309        1997 :   CHECK(key->IsJSReceiver() || key->IsSymbol());
     310        1997 :   CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
     311        3994 :   CONVERT_SMI_ARG_CHECKED(hash, 3)
     312             :   Handle<ObjectHashTable> table(
     313        1997 :       ObjectHashTable::cast(weak_collection->table()));
     314        1997 :   CHECK(table->IsKey(isolate, *key));
     315        1997 :   JSWeakCollection::Set(weak_collection, key, value, hash);
     316        1997 :   return *weak_collection;
     317             : }
     318             : 
     319             : 
     320           0 : RUNTIME_FUNCTION(Runtime_GetWeakSetValues) {
     321           0 :   HandleScope scope(isolate);
     322             :   DCHECK_EQ(2, args.length());
     323           0 :   CONVERT_ARG_HANDLE_CHECKED(JSWeakCollection, holder, 0);
     324           0 :   CONVERT_NUMBER_CHECKED(int, max_values, Int32, args[1]);
     325           0 :   CHECK(max_values >= 0);
     326           0 :   return *JSWeakCollection::GetEntries(holder, max_values);
     327             : }
     328             : }  // namespace internal
     329             : }  // namespace v8

Generated by: LCOV version 1.10