Line data Source code
1 : // Copyright 2016 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/builtins/builtins-utils.h"
6 : #include "src/builtins/builtins.h"
7 : #include "src/code-factory.h"
8 : #include "src/code-stub-assembler.h"
9 : #include "src/counters.h"
10 : #include "src/keys.h"
11 : #include "src/lookup.h"
12 : #include "src/objects-inl.h"
13 : #include "src/property-descriptor.h"
14 :
15 : namespace v8 {
16 : namespace internal {
17 :
18 : // -----------------------------------------------------------------------------
19 : // ES6 section 19.1 Object Objects
20 :
21 : // ES6 19.1.2.1 Object.assign
22 795 : BUILTIN(ObjectAssign) {
23 : HandleScope scope(isolate);
24 : Handle<Object> target = args.atOrUndefined(isolate, 1);
25 :
26 : // 1. Let to be ? ToObject(target).
27 530 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, target,
28 : Object::ToObject(isolate, target));
29 : Handle<JSReceiver> to = Handle<JSReceiver>::cast(target);
30 : // 2. If only one argument was passed, return to.
31 229 : if (args.length() == 2) return *to;
32 : // 3. Let sources be the List of argument values starting with the
33 : // second argument.
34 : // 4. For each element nextSource of sources, in ascending index order,
35 673 : for (int i = 2; i < args.length(); ++i) {
36 258 : Handle<Object> next_source = args.at(i);
37 258 : MAYBE_RETURN(JSReceiver::SetOrCopyDataProperties(isolate, to, next_source),
38 : isolate->heap()->exception());
39 : }
40 : // 5. Return to.
41 193 : return *to;
42 : }
43 :
44 : // ES6 section 19.1.3.4 Object.prototype.propertyIsEnumerable ( V )
45 17025 : BUILTIN(ObjectPrototypePropertyIsEnumerable) {
46 : HandleScope scope(isolate);
47 : Handle<JSReceiver> object;
48 : Handle<Name> name;
49 11350 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
50 : isolate, name, Object::ToName(isolate, args.atOrUndefined(isolate, 1)));
51 11340 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
52 : isolate, object, JSReceiver::ToObject(isolate, args.receiver()));
53 : Maybe<PropertyAttributes> maybe =
54 5481 : JSReceiver::GetOwnPropertyAttributes(object, name);
55 5481 : if (!maybe.IsJust()) return isolate->heap()->exception();
56 5285 : if (maybe.FromJust() == ABSENT) return isolate->heap()->false_value();
57 10094 : return isolate->heap()->ToBoolean((maybe.FromJust() & DONT_ENUM) == 0);
58 : }
59 :
60 : // ES6 section 19.1.2.3 Object.defineProperties
61 36201 : BUILTIN(ObjectDefineProperties) {
62 : HandleScope scope(isolate);
63 : DCHECK_EQ(3, args.length());
64 12067 : Handle<Object> target = args.at(1);
65 12067 : Handle<Object> properties = args.at(2);
66 :
67 36027 : RETURN_RESULT_OR_FAILURE(
68 : isolate, JSReceiver::DefineProperties(isolate, target, properties));
69 : }
70 :
71 : // ES6 section 19.1.2.4 Object.defineProperty
72 573702 : BUILTIN(ObjectDefineProperty) {
73 : HandleScope scope(isolate);
74 : DCHECK_EQ(4, args.length());
75 191234 : Handle<Object> target = args.at(1);
76 191234 : Handle<Object> key = args.at(2);
77 191234 : Handle<Object> attributes = args.at(3);
78 :
79 382468 : return JSReceiver::DefineProperty(isolate, target, key, attributes);
80 : }
81 :
82 : namespace {
83 :
84 : template <AccessorComponent which_accessor>
85 161398 : Object* ObjectDefineAccessor(Isolate* isolate, Handle<Object> object,
86 : Handle<Object> name, Handle<Object> accessor) {
87 : // 1. Let O be ? ToObject(this value).
88 : Handle<JSReceiver> receiver;
89 322796 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
90 : isolate, receiver,
91 : FLAG_harmony_strict_legacy_accessor_builtins
92 : ? Object::ToObject(isolate, object)
93 : : Object::ConvertReceiver(isolate, object));
94 : // 2. If IsCallable(getter) is false, throw a TypeError exception.
95 161388 : if (!accessor->IsCallable()) {
96 : MessageTemplate::Template message =
97 : which_accessor == ACCESSOR_GETTER
98 : ? MessageTemplate::kObjectGetterExpectingFunction
99 : : MessageTemplate::kObjectSetterExpectingFunction;
100 112 : THROW_NEW_ERROR_RETURN_FAILURE(isolate, NewTypeError(message));
101 : }
102 : // 3. Let desc be PropertyDescriptor{[[Get]]: getter, [[Enumerable]]: true,
103 : // [[Configurable]]: true}.
104 : PropertyDescriptor desc;
105 : if (which_accessor == ACCESSOR_GETTER) {
106 : desc.set_get(accessor);
107 : } else {
108 : DCHECK(which_accessor == ACCESSOR_SETTER);
109 : desc.set_set(accessor);
110 : }
111 : desc.set_enumerable(true);
112 : desc.set_configurable(true);
113 : // 4. Let key be ? ToPropertyKey(P).
114 322664 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
115 : Object::ToPropertyKey(isolate, name));
116 : // 5. Perform ? DefinePropertyOrThrow(O, key, desc).
117 : // To preserve legacy behavior, we ignore errors silently rather than
118 : // throwing an exception.
119 : Maybe<bool> success = JSReceiver::DefineOwnProperty(
120 : isolate, receiver, name, &desc,
121 : FLAG_harmony_strict_legacy_accessor_builtins ? Object::THROW_ON_ERROR
122 161332 : : Object::DONT_THROW);
123 161332 : MAYBE_RETURN(success, isolate->heap()->exception());
124 161138 : if (!success.FromJust()) {
125 12 : isolate->CountUsage(v8::Isolate::kDefineGetterOrSetterWouldThrow);
126 : }
127 : // 6. Return undefined.
128 161138 : return isolate->heap()->undefined_value();
129 : }
130 :
131 659 : Object* ObjectLookupAccessor(Isolate* isolate, Handle<Object> object,
132 : Handle<Object> key, AccessorComponent component) {
133 1318 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
134 : isolate, object,
135 : FLAG_harmony_strict_legacy_accessor_builtins
136 : ? Object::ToObject(isolate, object)
137 : : Object::ConvertReceiver(isolate, object));
138 1318 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, key,
139 : Object::ToPropertyKey(isolate, key));
140 659 : bool success = false;
141 : LookupIterator it = LookupIterator::PropertyOrElement(
142 : isolate, object, key, &success,
143 659 : LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
144 : DCHECK(success);
145 :
146 659 : for (; it.IsFound(); it.Next()) {
147 587 : switch (it.state()) {
148 : case LookupIterator::INTERCEPTOR:
149 : case LookupIterator::NOT_FOUND:
150 : case LookupIterator::TRANSITION:
151 0 : UNREACHABLE();
152 :
153 : case LookupIterator::ACCESS_CHECK:
154 5 : if (it.HasAccess()) continue;
155 5 : isolate->ReportFailedAccessCheck(it.GetHolder<JSObject>());
156 5 : RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
157 0 : return isolate->heap()->undefined_value();
158 :
159 : case LookupIterator::JSPROXY: {
160 : PropertyDescriptor desc;
161 : Maybe<bool> found = JSProxy::GetOwnPropertyDescriptor(
162 288 : isolate, it.GetHolder<JSProxy>(), it.GetName(), &desc);
163 288 : MAYBE_RETURN(found, isolate->heap()->exception());
164 288 : if (found.FromJust()) {
165 243 : if (component == ACCESSOR_GETTER && desc.has_get()) {
166 : return *desc.get();
167 : }
168 189 : if (component == ACCESSOR_SETTER && desc.has_set()) {
169 : return *desc.set();
170 : }
171 54 : return isolate->heap()->undefined_value();
172 : }
173 : Handle<Object> prototype;
174 252 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
175 : isolate, prototype, JSProxy::GetPrototype(it.GetHolder<JSProxy>()));
176 126 : if (prototype->IsNull(isolate)) {
177 18 : return isolate->heap()->undefined_value();
178 : }
179 108 : return ObjectLookupAccessor(isolate, prototype, key, component);
180 : }
181 :
182 : case LookupIterator::INTEGER_INDEXED_EXOTIC:
183 : case LookupIterator::DATA:
184 72 : return isolate->heap()->undefined_value();
185 :
186 : case LookupIterator::ACCESSOR: {
187 222 : Handle<Object> maybe_pair = it.GetAccessors();
188 222 : if (maybe_pair->IsAccessorPair()) {
189 : return *AccessorPair::GetComponent(
190 444 : Handle<AccessorPair>::cast(maybe_pair), component);
191 : }
192 : }
193 : }
194 : }
195 :
196 72 : return isolate->heap()->undefined_value();
197 : }
198 :
199 : } // namespace
200 :
201 : // ES6 B.2.2.2 a.k.a.
202 : // https://tc39.github.io/ecma262/#sec-object.prototype.__defineGetter__
203 449292 : BUILTIN(ObjectDefineGetter) {
204 : HandleScope scope(isolate);
205 149764 : Handle<Object> object = args.at(0); // Receiver.
206 149764 : Handle<Object> name = args.at(1);
207 149764 : Handle<Object> getter = args.at(2);
208 299528 : return ObjectDefineAccessor<ACCESSOR_GETTER>(isolate, object, name, getter);
209 : }
210 :
211 : // ES6 B.2.2.3 a.k.a.
212 : // https://tc39.github.io/ecma262/#sec-object.prototype.__defineSetter__
213 34902 : BUILTIN(ObjectDefineSetter) {
214 : HandleScope scope(isolate);
215 11634 : Handle<Object> object = args.at(0); // Receiver.
216 11634 : Handle<Object> name = args.at(1);
217 11634 : Handle<Object> setter = args.at(2);
218 23268 : return ObjectDefineAccessor<ACCESSOR_SETTER>(isolate, object, name, setter);
219 : }
220 :
221 : // ES6 B.2.2.4 a.k.a.
222 : // https://tc39.github.io/ecma262/#sec-object.prototype.__lookupGetter__
223 864 : BUILTIN(ObjectLookupGetter) {
224 : HandleScope scope(isolate);
225 288 : Handle<Object> object = args.at(0);
226 288 : Handle<Object> name = args.at(1);
227 576 : return ObjectLookupAccessor(isolate, object, name, ACCESSOR_GETTER);
228 : }
229 :
230 : // ES6 B.2.2.5 a.k.a.
231 : // https://tc39.github.io/ecma262/#sec-object.prototype.__lookupSetter__
232 789 : BUILTIN(ObjectLookupSetter) {
233 : HandleScope scope(isolate);
234 263 : Handle<Object> object = args.at(0);
235 263 : Handle<Object> name = args.at(1);
236 526 : return ObjectLookupAccessor(isolate, object, name, ACCESSOR_SETTER);
237 : }
238 :
239 : // ES6 section 19.1.2.5 Object.freeze ( O )
240 320721 : BUILTIN(ObjectFreeze) {
241 : HandleScope scope(isolate);
242 : Handle<Object> object = args.atOrUndefined(isolate, 1);
243 106907 : if (object->IsJSReceiver()) {
244 106831 : MAYBE_RETURN(JSReceiver::SetIntegrityLevel(Handle<JSReceiver>::cast(object),
245 : FROZEN, Object::THROW_ON_ERROR),
246 : isolate->heap()->exception());
247 : }
248 106873 : return *object;
249 : }
250 :
251 : // ES section 19.1.2.9 Object.getPrototypeOf ( O )
252 1297425 : BUILTIN(ObjectGetPrototypeOf) {
253 : HandleScope scope(isolate);
254 432475 : Handle<Object> object = args.atOrUndefined(isolate, 1);
255 :
256 : Handle<JSReceiver> receiver;
257 864950 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
258 : Object::ToObject(isolate, object));
259 :
260 1297356 : RETURN_RESULT_OR_FAILURE(isolate,
261 : JSReceiver::GetPrototype(isolate, receiver));
262 : }
263 :
264 : // ES6 section 19.1.2.21 Object.setPrototypeOf ( O, proto )
265 175953 : BUILTIN(ObjectSetPrototypeOf) {
266 : HandleScope scope(isolate);
267 :
268 : // 1. Let O be ? RequireObjectCoercible(O).
269 : Handle<Object> object = args.atOrUndefined(isolate, 1);
270 58651 : if (object->IsNullOrUndefined(isolate)) {
271 54 : THROW_NEW_ERROR_RETURN_FAILURE(
272 : isolate, NewTypeError(MessageTemplate::kCalledOnNullOrUndefined,
273 : isolate->factory()->NewStringFromAsciiChecked(
274 : "Object.setPrototypeOf")));
275 : }
276 :
277 : // 2. If Type(proto) is neither Object nor Null, throw a TypeError exception.
278 : Handle<Object> proto = args.atOrUndefined(isolate, 2);
279 117129 : if (!proto->IsNull(isolate) && !proto->IsJSReceiver()) {
280 956 : THROW_NEW_ERROR_RETURN_FAILURE(
281 : isolate, NewTypeError(MessageTemplate::kProtoObjectOrNull, proto));
282 : }
283 :
284 : // 3. If Type(O) is not Object, return O.
285 58191 : if (!object->IsJSReceiver()) return *object;
286 : Handle<JSReceiver> receiver = Handle<JSReceiver>::cast(object);
287 :
288 : // 4. Let status be ? O.[[SetPrototypeOf]](proto).
289 : // 5. If status is false, throw a TypeError exception.
290 58119 : MAYBE_RETURN(
291 : JSReceiver::SetPrototype(receiver, proto, true, Object::THROW_ON_ERROR),
292 : isolate->heap()->exception());
293 :
294 : // 6. Return O.
295 57938 : return *receiver;
296 : }
297 :
298 : // ES6 section B.2.2.1.1 get Object.prototype.__proto__
299 392274 : BUILTIN(ObjectPrototypeGetProto) {
300 : HandleScope scope(isolate);
301 : // 1. Let O be ? ToObject(this value).
302 : Handle<JSReceiver> receiver;
303 261516 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
304 : isolate, receiver, Object::ToObject(isolate, args.receiver()));
305 :
306 : // 2. Return ? O.[[GetPrototypeOf]]().
307 392214 : RETURN_RESULT_OR_FAILURE(isolate,
308 : JSReceiver::GetPrototype(isolate, receiver));
309 : }
310 :
311 : // ES6 section B.2.2.1.2 set Object.prototype.__proto__
312 521523 : BUILTIN(ObjectPrototypeSetProto) {
313 : HandleScope scope(isolate);
314 : // 1. Let O be ? RequireObjectCoercible(this value).
315 : Handle<Object> object = args.receiver();
316 173841 : if (object->IsNullOrUndefined(isolate)) {
317 60 : THROW_NEW_ERROR_RETURN_FAILURE(
318 : isolate, NewTypeError(MessageTemplate::kCalledOnNullOrUndefined,
319 : isolate->factory()->NewStringFromAsciiChecked(
320 : "set Object.prototype.__proto__")));
321 : }
322 :
323 : // 2. If Type(proto) is neither Object nor Null, return undefined.
324 : Handle<Object> proto = args.at(1);
325 347327 : if (!proto->IsNull(isolate) && !proto->IsJSReceiver()) {
326 28414 : return isolate->heap()->undefined_value();
327 : }
328 :
329 : // 3. If Type(O) is not Object, return undefined.
330 145407 : if (!object->IsJSReceiver()) return isolate->heap()->undefined_value();
331 145357 : Handle<JSReceiver> receiver = Handle<JSReceiver>::cast(object);
332 :
333 : // 4. Let status be ? O.[[SetPrototypeOf]](proto).
334 : // 5. If status is false, throw a TypeError exception.
335 145357 : MAYBE_RETURN(
336 : JSReceiver::SetPrototype(receiver, proto, true, Object::THROW_ON_ERROR),
337 : isolate->heap()->exception());
338 :
339 : // Return undefined.
340 145254 : return isolate->heap()->undefined_value();
341 : }
342 :
343 : namespace {
344 :
345 162679 : Object* GetOwnPropertyKeys(Isolate* isolate, BuiltinArguments args,
346 : PropertyFilter filter) {
347 : HandleScope scope(isolate);
348 162679 : Handle<Object> object = args.atOrUndefined(isolate, 1);
349 : Handle<JSReceiver> receiver;
350 325358 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
351 : Object::ToObject(isolate, object));
352 : Handle<FixedArray> keys;
353 325318 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
354 : isolate, keys,
355 : KeyAccumulator::GetKeys(receiver, KeyCollectionMode::kOwnOnly, filter,
356 : GetKeysConversion::kConvertToString));
357 : return *isolate->factory()->NewJSArrayWithElements(keys);
358 : }
359 :
360 : } // namespace
361 :
362 : // ES6 section 19.1.2.7 Object.getOwnPropertyNames ( O )
363 187288 : BUILTIN(ObjectGetOwnPropertyNames) {
364 93644 : return GetOwnPropertyKeys(isolate, args, SKIP_SYMBOLS);
365 : }
366 :
367 : // ES6 section 19.1.2.8 Object.getOwnPropertySymbols ( O )
368 138070 : BUILTIN(ObjectGetOwnPropertySymbols) {
369 69035 : return GetOwnPropertyKeys(isolate, args, SKIP_STRINGS);
370 : }
371 :
372 : // ES6 section 19.1.2.11 Object.isExtensible ( O )
373 1386 : BUILTIN(ObjectIsExtensible) {
374 : HandleScope scope(isolate);
375 : Handle<Object> object = args.atOrUndefined(isolate, 1);
376 : Maybe<bool> result =
377 : object->IsJSReceiver()
378 : ? JSReceiver::IsExtensible(Handle<JSReceiver>::cast(object))
379 462 : : Just(false);
380 462 : MAYBE_RETURN(result, isolate->heap()->exception());
381 462 : return isolate->heap()->ToBoolean(result.FromJust());
382 : }
383 :
384 : // ES6 section 19.1.2.12 Object.isFrozen ( O )
385 27198 : BUILTIN(ObjectIsFrozen) {
386 : HandleScope scope(isolate);
387 : Handle<Object> object = args.atOrUndefined(isolate, 1);
388 : Maybe<bool> result = object->IsJSReceiver()
389 : ? JSReceiver::TestIntegrityLevel(
390 : Handle<JSReceiver>::cast(object), FROZEN)
391 9066 : : Just(true);
392 9066 : MAYBE_RETURN(result, isolate->heap()->exception());
393 9066 : return isolate->heap()->ToBoolean(result.FromJust());
394 : }
395 :
396 : // ES6 section 19.1.2.13 Object.isSealed ( O )
397 7050 : BUILTIN(ObjectIsSealed) {
398 : HandleScope scope(isolate);
399 : Handle<Object> object = args.atOrUndefined(isolate, 1);
400 : Maybe<bool> result = object->IsJSReceiver()
401 : ? JSReceiver::TestIntegrityLevel(
402 : Handle<JSReceiver>::cast(object), SEALED)
403 2350 : : Just(true);
404 2350 : MAYBE_RETURN(result, isolate->heap()->exception());
405 2350 : return isolate->heap()->ToBoolean(result.FromJust());
406 : }
407 :
408 2028 : BUILTIN(ObjectValues) {
409 : HandleScope scope(isolate);
410 676 : Handle<Object> object = args.atOrUndefined(isolate, 1);
411 : Handle<JSReceiver> receiver;
412 1352 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
413 : Object::ToObject(isolate, object));
414 : Handle<FixedArray> values;
415 1298 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
416 : isolate, values, JSReceiver::GetOwnValues(receiver, ENUMERABLE_STRINGS));
417 : return *isolate->factory()->NewJSArrayWithElements(values);
418 : }
419 :
420 1296 : BUILTIN(ObjectEntries) {
421 : HandleScope scope(isolate);
422 432 : Handle<Object> object = args.atOrUndefined(isolate, 1);
423 : Handle<JSReceiver> receiver;
424 864 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
425 : Object::ToObject(isolate, object));
426 : Handle<FixedArray> entries;
427 810 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
428 : isolate, entries,
429 : JSReceiver::GetOwnEntries(receiver, ENUMERABLE_STRINGS));
430 : return *isolate->factory()->NewJSArrayWithElements(entries);
431 : }
432 :
433 270 : BUILTIN(ObjectGetOwnPropertyDescriptors) {
434 : HandleScope scope(isolate);
435 90 : Handle<Object> object = args.atOrUndefined(isolate, 1);
436 :
437 : Handle<JSReceiver> receiver;
438 180 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
439 : Object::ToObject(isolate, object));
440 :
441 : Handle<FixedArray> keys;
442 126 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
443 : isolate, keys, KeyAccumulator::GetKeys(
444 : receiver, KeyCollectionMode::kOwnOnly, ALL_PROPERTIES,
445 : GetKeysConversion::kConvertToString));
446 :
447 : Handle<JSObject> descriptors =
448 63 : isolate->factory()->NewJSObject(isolate->object_function());
449 :
450 414 : for (int i = 0; i < keys->length(); ++i) {
451 144 : Handle<Name> key = Handle<Name>::cast(FixedArray::get(*keys, i, isolate));
452 : PropertyDescriptor descriptor;
453 : Maybe<bool> did_get_descriptor = JSReceiver::GetOwnPropertyDescriptor(
454 144 : isolate, receiver, key, &descriptor);
455 144 : MAYBE_RETURN(did_get_descriptor, isolate->heap()->exception());
456 :
457 162 : if (!did_get_descriptor.FromJust()) continue;
458 126 : Handle<Object> from_descriptor = descriptor.ToObject(isolate);
459 :
460 : LookupIterator it = LookupIterator::PropertyOrElement(
461 126 : isolate, descriptors, key, descriptors, LookupIterator::OWN);
462 : Maybe<bool> success = JSReceiver::CreateDataProperty(&it, from_descriptor,
463 126 : Object::DONT_THROW);
464 126 : CHECK(success.FromJust());
465 : }
466 :
467 63 : return *descriptors;
468 : }
469 :
470 : // ES6 section 19.1.2.15 Object.preventExtensions ( O )
471 10053 : BUILTIN(ObjectPreventExtensions) {
472 : HandleScope scope(isolate);
473 : Handle<Object> object = args.atOrUndefined(isolate, 1);
474 3351 : if (object->IsJSReceiver()) {
475 3351 : MAYBE_RETURN(JSReceiver::PreventExtensions(Handle<JSReceiver>::cast(object),
476 : Object::THROW_ON_ERROR),
477 : isolate->heap()->exception());
478 : }
479 3341 : return *object;
480 : }
481 :
482 : // ES6 section 19.1.2.17 Object.seal ( O )
483 2163 : BUILTIN(ObjectSeal) {
484 : HandleScope scope(isolate);
485 : Handle<Object> object = args.atOrUndefined(isolate, 1);
486 721 : if (object->IsJSReceiver()) {
487 679 : MAYBE_RETURN(JSReceiver::SetIntegrityLevel(Handle<JSReceiver>::cast(object),
488 : SEALED, Object::THROW_ON_ERROR),
489 : isolate->heap()->exception());
490 : }
491 716 : return *object;
492 : }
493 :
494 : } // namespace internal
495 : } // namespace v8
|
