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
|
