Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(628)

Side by Side Diff: src/runtime.cc

Issue 225283005: Return MaybeHandle from SetProperty. (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge
Patch Set: addressed comments Created 6 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « src/runtime.h ('k') | src/scopeinfo.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2012 the V8 project authors. All rights reserved. 1 // Copyright 2012 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without 2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are 3 // modification, are permitted provided that the following conditions are
4 // met: 4 // met:
5 // 5 //
6 // * Redistributions of source code must retain the above copyright 6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer. 7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above 8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following 9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided 10 // disclaimer in the documentation and/or other materials provided
(...skipping 195 matching lines...) Expand 10 before | Expand all | Expand 10 after
206 ASSERT(index == number_of_string_keys); 206 ASSERT(index == number_of_string_keys);
207 } 207 }
208 *is_result_from_cache = true; 208 *is_result_from_cache = true;
209 return isolate->factory()->ObjectLiteralMapFromCache(context, keys); 209 return isolate->factory()->ObjectLiteralMapFromCache(context, keys);
210 } 210 }
211 *is_result_from_cache = false; 211 *is_result_from_cache = false;
212 return Map::Create(handle(context->object_function()), number_of_properties); 212 return Map::Create(handle(context->object_function()), number_of_properties);
213 } 213 }
214 214
215 215
216 static Handle<Object> CreateLiteralBoilerplate( 216 MUST_USE_RESULT static MaybeHandle<Object> CreateLiteralBoilerplate(
217 Isolate* isolate, 217 Isolate* isolate,
218 Handle<FixedArray> literals, 218 Handle<FixedArray> literals,
219 Handle<FixedArray> constant_properties); 219 Handle<FixedArray> constant_properties);
220 220
221 221
222 static Handle<Object> CreateObjectLiteralBoilerplate( 222 MUST_USE_RESULT static MaybeHandle<Object> CreateObjectLiteralBoilerplate(
223 Isolate* isolate, 223 Isolate* isolate,
224 Handle<FixedArray> literals, 224 Handle<FixedArray> literals,
225 Handle<FixedArray> constant_properties, 225 Handle<FixedArray> constant_properties,
226 bool should_have_fast_elements, 226 bool should_have_fast_elements,
227 bool has_function_literal) { 227 bool has_function_literal) {
228 // Get the native context from the literals array. This is the 228 // Get the native context from the literals array. This is the
229 // context in which the function was created and we use the object 229 // context in which the function was created and we use the object
230 // function from this context to create the object literal. We do 230 // function from this context to create the object literal. We do
231 // not use the object function from the current native context 231 // not use the object function from the current native context
232 // because this might be the object function from another context 232 // because this might be the object function from another context
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after
267 } 267 }
268 268
269 // TODO(verwaest): Support tracking representations in the boilerplate. 269 // TODO(verwaest): Support tracking representations in the boilerplate.
270 for (int index = 0; index < length; index +=2) { 270 for (int index = 0; index < length; index +=2) {
271 Handle<Object> key(constant_properties->get(index+0), isolate); 271 Handle<Object> key(constant_properties->get(index+0), isolate);
272 Handle<Object> value(constant_properties->get(index+1), isolate); 272 Handle<Object> value(constant_properties->get(index+1), isolate);
273 if (value->IsFixedArray()) { 273 if (value->IsFixedArray()) {
274 // The value contains the constant_properties of a 274 // The value contains the constant_properties of a
275 // simple object or array literal. 275 // simple object or array literal.
276 Handle<FixedArray> array = Handle<FixedArray>::cast(value); 276 Handle<FixedArray> array = Handle<FixedArray>::cast(value);
277 value = CreateLiteralBoilerplate(isolate, literals, array); 277 ASSIGN_RETURN_ON_EXCEPTION(
278 if (value.is_null()) return value; 278 isolate, value,
279 CreateLiteralBoilerplate(isolate, literals, array),
280 Object);
279 } 281 }
280 Handle<Object> result; 282 MaybeHandle<Object> maybe_result;
281 uint32_t element_index = 0; 283 uint32_t element_index = 0;
282 StoreMode mode = value->IsJSObject() ? FORCE_FIELD : ALLOW_AS_CONSTANT; 284 StoreMode mode = value->IsJSObject() ? FORCE_FIELD : ALLOW_AS_CONSTANT;
283 if (key->IsInternalizedString()) { 285 if (key->IsInternalizedString()) {
284 if (Handle<String>::cast(key)->AsArrayIndex(&element_index)) { 286 if (Handle<String>::cast(key)->AsArrayIndex(&element_index)) {
285 // Array index as string (uint32). 287 // Array index as string (uint32).
286 result = JSObject::SetOwnElement( 288 maybe_result = JSObject::SetOwnElement(
287 boilerplate, element_index, value, SLOPPY); 289 boilerplate, element_index, value, SLOPPY);
288 } else { 290 } else {
289 Handle<String> name(String::cast(*key)); 291 Handle<String> name(String::cast(*key));
290 ASSERT(!name->AsArrayIndex(&element_index)); 292 ASSERT(!name->AsArrayIndex(&element_index));
291 result = JSObject::SetLocalPropertyIgnoreAttributes( 293 maybe_result = JSObject::SetLocalPropertyIgnoreAttributes(
292 boilerplate, name, value, NONE, 294 boilerplate, name, value, NONE,
293 Object::OPTIMAL_REPRESENTATION, mode); 295 Object::OPTIMAL_REPRESENTATION, mode);
294 } 296 }
295 } else if (key->ToArrayIndex(&element_index)) { 297 } else if (key->ToArrayIndex(&element_index)) {
296 // Array index (uint32). 298 // Array index (uint32).
297 result = JSObject::SetOwnElement( 299 maybe_result = JSObject::SetOwnElement(
298 boilerplate, element_index, value, SLOPPY); 300 boilerplate, element_index, value, SLOPPY);
299 } else { 301 } else {
300 // Non-uint32 number. 302 // Non-uint32 number.
301 ASSERT(key->IsNumber()); 303 ASSERT(key->IsNumber());
302 double num = key->Number(); 304 double num = key->Number();
303 char arr[100]; 305 char arr[100];
304 Vector<char> buffer(arr, ARRAY_SIZE(arr)); 306 Vector<char> buffer(arr, ARRAY_SIZE(arr));
305 const char* str = DoubleToCString(num, buffer); 307 const char* str = DoubleToCString(num, buffer);
306 Handle<String> name = 308 Handle<String> name =
307 isolate->factory()->NewStringFromAscii(CStrVector(str)); 309 isolate->factory()->NewStringFromAscii(CStrVector(str));
308 result = JSObject::SetLocalPropertyIgnoreAttributes( 310 maybe_result = JSObject::SetLocalPropertyIgnoreAttributes(
309 boilerplate, name, value, NONE, 311 boilerplate, name, value, NONE,
310 Object::OPTIMAL_REPRESENTATION, mode); 312 Object::OPTIMAL_REPRESENTATION, mode);
311 } 313 }
312 // If setting the property on the boilerplate throws an 314 // If setting the property on the boilerplate throws an
313 // exception, the exception is converted to an empty handle in 315 // exception, the exception is converted to an empty handle in
314 // the handle based operations. In that case, we need to 316 // the handle based operations. In that case, we need to
315 // convert back to an exception. 317 // convert back to an exception.
316 if (result.is_null()) return result; 318 RETURN_ON_EXCEPTION(isolate, maybe_result, Object);
317 } 319 }
318 320
319 // Transform to fast properties if necessary. For object literals with 321 // Transform to fast properties if necessary. For object literals with
320 // containing function literals we defer this operation until after all 322 // containing function literals we defer this operation until after all
321 // computed properties have been assigned so that we can generate 323 // computed properties have been assigned so that we can generate
322 // constant function properties. 324 // constant function properties.
323 if (should_transform && !has_function_literal) { 325 if (should_transform && !has_function_literal) {
324 JSObject::TransformToFastProperties( 326 JSObject::TransformToFastProperties(
325 boilerplate, boilerplate->map()->unused_property_fields()); 327 boilerplate, boilerplate->map()->unused_property_fields());
326 } 328 }
(...skipping 13 matching lines...) Expand all
340 JSObject::TransitionElementsKind(Handle<JSObject>::cast(object), to_kind); 342 JSObject::TransitionElementsKind(Handle<JSObject>::cast(object), to_kind);
341 return *object; 343 return *object;
342 } 344 }
343 return isolate->ThrowIllegalOperation(); 345 return isolate->ThrowIllegalOperation();
344 } 346 }
345 347
346 348
347 static const int kSmiLiteralMinimumLength = 1024; 349 static const int kSmiLiteralMinimumLength = 1024;
348 350
349 351
350 Handle<Object> Runtime::CreateArrayLiteralBoilerplate( 352 MaybeHandle<Object> Runtime::CreateArrayLiteralBoilerplate(
351 Isolate* isolate, 353 Isolate* isolate,
352 Handle<FixedArray> literals, 354 Handle<FixedArray> literals,
353 Handle<FixedArray> elements) { 355 Handle<FixedArray> elements) {
354 // Create the JSArray. 356 // Create the JSArray.
355 Handle<JSFunction> constructor( 357 Handle<JSFunction> constructor(
356 JSFunction::NativeContextFromLiterals(*literals)->array_function()); 358 JSFunction::NativeContextFromLiterals(*literals)->array_function());
357 359
358 PretenureFlag pretenure_flag = 360 PretenureFlag pretenure_flag =
359 isolate->heap()->InNewSpace(*literals) ? NOT_TENURED : TENURED; 361 isolate->heap()->InNewSpace(*literals) ? NOT_TENURED : TENURED;
360 362
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
399 Handle<FixedArray>::cast(constant_elements_values); 401 Handle<FixedArray>::cast(constant_elements_values);
400 Handle<FixedArray> fixed_array_values_copy = 402 Handle<FixedArray> fixed_array_values_copy =
401 isolate->factory()->CopyFixedArray(fixed_array_values); 403 isolate->factory()->CopyFixedArray(fixed_array_values);
402 copied_elements_values = fixed_array_values_copy; 404 copied_elements_values = fixed_array_values_copy;
403 for (int i = 0; i < fixed_array_values->length(); i++) { 405 for (int i = 0; i < fixed_array_values->length(); i++) {
404 Object* current = fixed_array_values->get(i); 406 Object* current = fixed_array_values->get(i);
405 if (current->IsFixedArray()) { 407 if (current->IsFixedArray()) {
406 // The value contains the constant_properties of a 408 // The value contains the constant_properties of a
407 // simple object or array literal. 409 // simple object or array literal.
408 Handle<FixedArray> fa(FixedArray::cast(fixed_array_values->get(i))); 410 Handle<FixedArray> fa(FixedArray::cast(fixed_array_values->get(i)));
409 Handle<Object> result = 411 Handle<Object> result;
410 CreateLiteralBoilerplate(isolate, literals, fa); 412 ASSIGN_RETURN_ON_EXCEPTION(
411 if (result.is_null()) return result; 413 isolate, result,
414 CreateLiteralBoilerplate(isolate, literals, fa),
415 Object);
412 fixed_array_values_copy->set(i, *result); 416 fixed_array_values_copy->set(i, *result);
413 } 417 }
414 } 418 }
415 } 419 }
416 } 420 }
417 object->set_elements(*copied_elements_values); 421 object->set_elements(*copied_elements_values);
418 object->set_length(Smi::FromInt(copied_elements_values->length())); 422 object->set_length(Smi::FromInt(copied_elements_values->length()));
419 423
420 // Ensure that the boilerplate object has FAST_*_ELEMENTS, unless the flag is 424 // Ensure that the boilerplate object has FAST_*_ELEMENTS, unless the flag is
421 // on or the object is larger than the threshold. 425 // on or the object is larger than the threshold.
422 if (!FLAG_smi_only_arrays && 426 if (!FLAG_smi_only_arrays &&
423 constant_elements_values->length() < kSmiLiteralMinimumLength) { 427 constant_elements_values->length() < kSmiLiteralMinimumLength) {
424 ElementsKind elements_kind = object->GetElementsKind(); 428 ElementsKind elements_kind = object->GetElementsKind();
425 if (!IsFastObjectElementsKind(elements_kind)) { 429 if (!IsFastObjectElementsKind(elements_kind)) {
426 if (IsFastHoleyElementsKind(elements_kind)) { 430 if (IsFastHoleyElementsKind(elements_kind)) {
427 CHECK(!TransitionElements(object, FAST_HOLEY_ELEMENTS, 431 CHECK(!TransitionElements(object, FAST_HOLEY_ELEMENTS,
428 isolate)->IsFailure()); 432 isolate)->IsFailure());
429 } else { 433 } else {
430 CHECK(!TransitionElements(object, FAST_ELEMENTS, isolate)->IsFailure()); 434 CHECK(!TransitionElements(object, FAST_ELEMENTS, isolate)->IsFailure());
431 } 435 }
432 } 436 }
433 } 437 }
434 438
435 object->ValidateElements(); 439 object->ValidateElements();
436 return object; 440 return object;
437 } 441 }
438 442
439 443
440 static Handle<Object> CreateLiteralBoilerplate( 444 MUST_USE_RESULT static MaybeHandle<Object> CreateLiteralBoilerplate(
441 Isolate* isolate, 445 Isolate* isolate,
442 Handle<FixedArray> literals, 446 Handle<FixedArray> literals,
443 Handle<FixedArray> array) { 447 Handle<FixedArray> array) {
444 Handle<FixedArray> elements = CompileTimeValue::GetElements(array); 448 Handle<FixedArray> elements = CompileTimeValue::GetElements(array);
445 const bool kHasNoFunctionLiteral = false; 449 const bool kHasNoFunctionLiteral = false;
446 switch (CompileTimeValue::GetLiteralType(array)) { 450 switch (CompileTimeValue::GetLiteralType(array)) {
447 case CompileTimeValue::OBJECT_LITERAL_FAST_ELEMENTS: 451 case CompileTimeValue::OBJECT_LITERAL_FAST_ELEMENTS:
448 return CreateObjectLiteralBoilerplate(isolate, 452 return CreateObjectLiteralBoilerplate(isolate,
449 literals, 453 literals,
450 elements, 454 elements,
451 true, 455 true,
452 kHasNoFunctionLiteral); 456 kHasNoFunctionLiteral);
453 case CompileTimeValue::OBJECT_LITERAL_SLOW_ELEMENTS: 457 case CompileTimeValue::OBJECT_LITERAL_SLOW_ELEMENTS:
454 return CreateObjectLiteralBoilerplate(isolate, 458 return CreateObjectLiteralBoilerplate(isolate,
455 literals, 459 literals,
456 elements, 460 elements,
457 false, 461 false,
458 kHasNoFunctionLiteral); 462 kHasNoFunctionLiteral);
459 case CompileTimeValue::ARRAY_LITERAL: 463 case CompileTimeValue::ARRAY_LITERAL:
460 return Runtime::CreateArrayLiteralBoilerplate( 464 return Runtime::CreateArrayLiteralBoilerplate(
461 isolate, literals, elements); 465 isolate, literals, elements);
462 default: 466 default:
463 UNREACHABLE(); 467 UNREACHABLE();
464 return Handle<Object>::null(); 468 return MaybeHandle<Object>();
465 } 469 }
466 } 470 }
467 471
468 472
469 RUNTIME_FUNCTION(MaybeObject*, RuntimeHidden_CreateObjectLiteral) { 473 RUNTIME_FUNCTION(MaybeObject*, RuntimeHidden_CreateObjectLiteral) {
470 HandleScope scope(isolate); 474 HandleScope scope(isolate);
471 ASSERT(args.length() == 4); 475 ASSERT(args.length() == 4);
472 CONVERT_ARG_HANDLE_CHECKED(FixedArray, literals, 0); 476 CONVERT_ARG_HANDLE_CHECKED(FixedArray, literals, 0);
473 CONVERT_SMI_ARG_CHECKED(literals_index, 1); 477 CONVERT_SMI_ARG_CHECKED(literals_index, 1);
474 CONVERT_ARG_HANDLE_CHECKED(FixedArray, constant_properties, 2); 478 CONVERT_ARG_HANDLE_CHECKED(FixedArray, constant_properties, 2);
475 CONVERT_SMI_ARG_CHECKED(flags, 3); 479 CONVERT_SMI_ARG_CHECKED(flags, 3);
476 bool should_have_fast_elements = (flags & ObjectLiteral::kFastElements) != 0; 480 bool should_have_fast_elements = (flags & ObjectLiteral::kFastElements) != 0;
477 bool has_function_literal = (flags & ObjectLiteral::kHasFunction) != 0; 481 bool has_function_literal = (flags & ObjectLiteral::kHasFunction) != 0;
478 482
479 // Check if boilerplate exists. If not, create it first. 483 // Check if boilerplate exists. If not, create it first.
480 Handle<Object> literal_site(literals->get(literals_index), isolate); 484 Handle<Object> literal_site(literals->get(literals_index), isolate);
481 Handle<AllocationSite> site; 485 Handle<AllocationSite> site;
482 Handle<JSObject> boilerplate; 486 Handle<JSObject> boilerplate;
483 if (*literal_site == isolate->heap()->undefined_value()) { 487 if (*literal_site == isolate->heap()->undefined_value()) {
484 Handle<Object> raw_boilerplate = CreateObjectLiteralBoilerplate( 488 Handle<Object> raw_boilerplate;
485 isolate, 489 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
486 literals, 490 isolate, raw_boilerplate,
487 constant_properties, 491 CreateObjectLiteralBoilerplate(
488 should_have_fast_elements, 492 isolate,
489 has_function_literal); 493 literals,
490 RETURN_IF_EMPTY_HANDLE(isolate, raw_boilerplate); 494 constant_properties,
495 should_have_fast_elements,
496 has_function_literal));
491 boilerplate = Handle<JSObject>::cast(raw_boilerplate); 497 boilerplate = Handle<JSObject>::cast(raw_boilerplate);
492 498
493 AllocationSiteCreationContext creation_context(isolate); 499 AllocationSiteCreationContext creation_context(isolate);
494 site = creation_context.EnterNewScope(); 500 site = creation_context.EnterNewScope();
495 RETURN_IF_EMPTY_HANDLE(isolate, 501 RETURN_IF_EMPTY_HANDLE(isolate,
496 JSObject::DeepWalk(boilerplate, &creation_context)); 502 JSObject::DeepWalk(boilerplate, &creation_context));
497 creation_context.ExitScope(site, boilerplate); 503 creation_context.ExitScope(site, boilerplate);
498 504
499 // Update the functions literal and return the boilerplate. 505 // Update the functions literal and return the boilerplate.
500 literals->set(literals_index, *site); 506 literals->set(literals_index, *site);
501 } else { 507 } else {
502 site = Handle<AllocationSite>::cast(literal_site); 508 site = Handle<AllocationSite>::cast(literal_site);
503 boilerplate = Handle<JSObject>(JSObject::cast(site->transition_info()), 509 boilerplate = Handle<JSObject>(JSObject::cast(site->transition_info()),
504 isolate); 510 isolate);
505 } 511 }
506 512
507 AllocationSiteUsageContext usage_context(isolate, site, true); 513 AllocationSiteUsageContext usage_context(isolate, site, true);
508 usage_context.EnterNewScope(); 514 usage_context.EnterNewScope();
509 Handle<Object> copy = JSObject::DeepCopy(boilerplate, &usage_context); 515 Handle<Object> copy = JSObject::DeepCopy(boilerplate, &usage_context);
510 usage_context.ExitScope(site, boilerplate); 516 usage_context.ExitScope(site, boilerplate);
511 RETURN_IF_EMPTY_HANDLE(isolate, copy); 517 RETURN_IF_EMPTY_HANDLE(isolate, copy);
512 return *copy; 518 return *copy;
513 } 519 }
514 520
515 521
516 static Handle<AllocationSite> GetLiteralAllocationSite( 522 MUST_USE_RESULT static MaybeHandle<AllocationSite> GetLiteralAllocationSite(
517 Isolate* isolate, 523 Isolate* isolate,
518 Handle<FixedArray> literals, 524 Handle<FixedArray> literals,
519 int literals_index, 525 int literals_index,
520 Handle<FixedArray> elements) { 526 Handle<FixedArray> elements) {
521 // Check if boilerplate exists. If not, create it first. 527 // Check if boilerplate exists. If not, create it first.
522 Handle<Object> literal_site(literals->get(literals_index), isolate); 528 Handle<Object> literal_site(literals->get(literals_index), isolate);
523 Handle<AllocationSite> site; 529 Handle<AllocationSite> site;
524 if (*literal_site == isolate->heap()->undefined_value()) { 530 if (*literal_site == isolate->heap()->undefined_value()) {
525 ASSERT(*elements != isolate->heap()->empty_fixed_array()); 531 ASSERT(*elements != isolate->heap()->empty_fixed_array());
526 Handle<Object> boilerplate = 532 Handle<Object> boilerplate;
527 Runtime::CreateArrayLiteralBoilerplate(isolate, literals, elements); 533 ASSIGN_RETURN_ON_EXCEPTION(
528 if (boilerplate.is_null()) return Handle<AllocationSite>::null(); 534 isolate, boilerplate,
535 Runtime::CreateArrayLiteralBoilerplate(isolate, literals, elements),
536 AllocationSite);
529 537
530 AllocationSiteCreationContext creation_context(isolate); 538 AllocationSiteCreationContext creation_context(isolate);
531 site = creation_context.EnterNewScope(); 539 site = creation_context.EnterNewScope();
532 if (JSObject::DeepWalk(Handle<JSObject>::cast(boilerplate), 540 if (JSObject::DeepWalk(Handle<JSObject>::cast(boilerplate),
533 &creation_context).is_null()) { 541 &creation_context).is_null()) {
534 return Handle<AllocationSite>::null(); 542 return Handle<AllocationSite>::null();
535 } 543 }
536 creation_context.ExitScope(site, Handle<JSObject>::cast(boilerplate)); 544 creation_context.ExitScope(site, Handle<JSObject>::cast(boilerplate));
537 545
538 literals->set(literals_index, *site); 546 literals->set(literals_index, *site);
539 } else { 547 } else {
540 site = Handle<AllocationSite>::cast(literal_site); 548 site = Handle<AllocationSite>::cast(literal_site);
541 } 549 }
542 550
543 return site; 551 return site;
544 } 552 }
545 553
546 554
547 static MaybeObject* CreateArrayLiteralImpl(Isolate* isolate, 555 static MaybeObject* CreateArrayLiteralImpl(Isolate* isolate,
548 Handle<FixedArray> literals, 556 Handle<FixedArray> literals,
549 int literals_index, 557 int literals_index,
550 Handle<FixedArray> elements, 558 Handle<FixedArray> elements,
551 int flags) { 559 int flags) {
552 Handle<AllocationSite> site = GetLiteralAllocationSite(isolate, literals, 560 Handle<AllocationSite> site;
553 literals_index, elements); 561 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
554 RETURN_IF_EMPTY_HANDLE(isolate, site); 562 isolate, site,
563 GetLiteralAllocationSite(isolate, literals, literals_index, elements));
555 564
556 bool enable_mementos = (flags & ArrayLiteral::kDisableMementos) == 0; 565 bool enable_mementos = (flags & ArrayLiteral::kDisableMementos) == 0;
557 Handle<JSObject> boilerplate(JSObject::cast(site->transition_info())); 566 Handle<JSObject> boilerplate(JSObject::cast(site->transition_info()));
558 AllocationSiteUsageContext usage_context(isolate, site, enable_mementos); 567 AllocationSiteUsageContext usage_context(isolate, site, enable_mementos);
559 usage_context.EnterNewScope(); 568 usage_context.EnterNewScope();
560 JSObject::DeepCopyHints hints = (flags & ArrayLiteral::kShallowElements) == 0 569 JSObject::DeepCopyHints hints = (flags & ArrayLiteral::kShallowElements) == 0
561 ? JSObject::kNoHints 570 ? JSObject::kNoHints
562 : JSObject::kObjectIsShallowArray; 571 : JSObject::kObjectIsShallowArray;
563 Handle<JSObject> copy = JSObject::DeepCopy(boilerplate, &usage_context, 572 Handle<JSObject> copy = JSObject::DeepCopy(boilerplate, &usage_context,
564 hints); 573 hints);
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after
625 CONVERT_ARG_HANDLE_CHECKED(String, name, 0); 634 CONVERT_ARG_HANDLE_CHECKED(String, name, 0);
626 Handle<JSObject> registry = isolate->GetSymbolRegistry(); 635 Handle<JSObject> registry = isolate->GetSymbolRegistry();
627 Handle<String> part = isolate->factory()->private_intern_string(); 636 Handle<String> part = isolate->factory()->private_intern_string();
628 Handle<JSObject> privates = 637 Handle<JSObject> privates =
629 Handle<JSObject>::cast(Object::GetPropertyOrElement(registry, part)); 638 Handle<JSObject>::cast(Object::GetPropertyOrElement(registry, part));
630 Handle<Object> symbol = Object::GetPropertyOrElement(privates, name); 639 Handle<Object> symbol = Object::GetPropertyOrElement(privates, name);
631 if (!symbol->IsSymbol()) { 640 if (!symbol->IsSymbol()) {
632 ASSERT(symbol->IsUndefined()); 641 ASSERT(symbol->IsUndefined());
633 symbol = isolate->factory()->NewPrivateSymbol(); 642 symbol = isolate->factory()->NewPrivateSymbol();
634 Handle<Symbol>::cast(symbol)->set_name(*name); 643 Handle<Symbol>::cast(symbol)->set_name(*name);
635 JSObject::SetProperty(privates, name, symbol, NONE, STRICT); 644 JSObject::SetProperty(privates, name, symbol, NONE, STRICT).Assert();
636 } 645 }
637 return *symbol; 646 return *symbol;
638 } 647 }
639 648
640 649
641 RUNTIME_FUNCTION(MaybeObject*, Runtime_NewSymbolWrapper) { 650 RUNTIME_FUNCTION(MaybeObject*, Runtime_NewSymbolWrapper) {
642 ASSERT(args.length() == 1); 651 ASSERT(args.length() == 1);
643 CONVERT_ARG_CHECKED(Symbol, symbol, 0); 652 CONVERT_ARG_CHECKED(Symbol, symbol, 0);
644 return symbol->ToObject(isolate); 653 return symbol->ToObject(isolate);
645 } 654 }
(...skipping 1554 matching lines...) Expand 10 before | Expand all | Expand 10 after
2200 } 2209 }
2201 // If the existing property is not configurable, keep its attributes. 2210 // If the existing property is not configurable, keep its attributes.
2202 attr = lookup.GetAttributes(); 2211 attr = lookup.GetAttributes();
2203 } 2212 }
2204 // Define or redefine own property. 2213 // Define or redefine own property.
2205 RETURN_IF_EMPTY_HANDLE(isolate, 2214 RETURN_IF_EMPTY_HANDLE(isolate,
2206 JSObject::SetLocalPropertyIgnoreAttributes( 2215 JSObject::SetLocalPropertyIgnoreAttributes(
2207 global, name, value, static_cast<PropertyAttributes>(attr))); 2216 global, name, value, static_cast<PropertyAttributes>(attr)));
2208 } else { 2217 } else {
2209 // Do a [[Put]] on the existing (own) property. 2218 // Do a [[Put]] on the existing (own) property.
2210 RETURN_IF_EMPTY_HANDLE(isolate, 2219 RETURN_FAILURE_ON_EXCEPTION(
2220 isolate,
2211 JSObject::SetProperty( 2221 JSObject::SetProperty(
2212 global, name, value, static_cast<PropertyAttributes>(attr), 2222 global, name, value, static_cast<PropertyAttributes>(attr),
2213 strict_mode)); 2223 strict_mode));
2214 } 2224 }
2215 } 2225 }
2216 2226
2217 ASSERT(!isolate->has_pending_exception()); 2227 ASSERT(!isolate->has_pending_exception());
2218 return isolate->heap()->undefined_value(); 2228 return isolate->heap()->undefined_value();
2219 } 2229 }
2220 2230
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after
2256 if (index >= 0) { 2266 if (index >= 0) {
2257 ASSERT(holder.is_identical_to(context)); 2267 ASSERT(holder.is_identical_to(context));
2258 if (((attributes & READ_ONLY) == 0) || 2268 if (((attributes & READ_ONLY) == 0) ||
2259 context->get(index)->IsTheHole()) { 2269 context->get(index)->IsTheHole()) {
2260 context->set(index, *initial_value); 2270 context->set(index, *initial_value);
2261 } 2271 }
2262 } else { 2272 } else {
2263 // Slow case: The property is in the context extension object of a 2273 // Slow case: The property is in the context extension object of a
2264 // function context or the global object of a native context. 2274 // function context or the global object of a native context.
2265 Handle<JSObject> object = Handle<JSObject>::cast(holder); 2275 Handle<JSObject> object = Handle<JSObject>::cast(holder);
2266 RETURN_IF_EMPTY_HANDLE( 2276 RETURN_FAILURE_ON_EXCEPTION(
2267 isolate, 2277 isolate,
2268 JSReceiver::SetProperty(object, name, initial_value, mode, SLOPPY)); 2278 JSReceiver::SetProperty(object, name, initial_value, mode, SLOPPY));
2269 } 2279 }
2270 } 2280 }
2271 2281
2272 } else { 2282 } else {
2273 // The property is not in the function context. It needs to be 2283 // The property is not in the function context. It needs to be
2274 // "declared" in the function context's extension context or as a 2284 // "declared" in the function context's extension context or as a
2275 // property of the the global object. 2285 // property of the the global object.
2276 Handle<JSObject> object; 2286 Handle<JSObject> object;
(...skipping 26 matching lines...) Expand all
2303 object->Lookup(*name, &lookup); 2313 object->Lookup(*name, &lookup);
2304 if (lookup.IsPropertyCallbacks()) { 2314 if (lookup.IsPropertyCallbacks()) {
2305 return ThrowRedeclarationError(isolate, name); 2315 return ThrowRedeclarationError(isolate, name);
2306 } 2316 }
2307 } 2317 }
2308 if (object->IsJSGlobalObject()) { 2318 if (object->IsJSGlobalObject()) {
2309 // Define own property on the global object. 2319 // Define own property on the global object.
2310 RETURN_IF_EMPTY_HANDLE(isolate, 2320 RETURN_IF_EMPTY_HANDLE(isolate,
2311 JSObject::SetLocalPropertyIgnoreAttributes(object, name, value, mode)); 2321 JSObject::SetLocalPropertyIgnoreAttributes(object, name, value, mode));
2312 } else { 2322 } else {
2313 RETURN_IF_EMPTY_HANDLE(isolate, 2323 RETURN_FAILURE_ON_EXCEPTION(isolate,
2314 JSReceiver::SetProperty(object, name, value, mode, SLOPPY)); 2324 JSReceiver::SetProperty(object, name, value, mode, SLOPPY));
2315 } 2325 }
2316 } 2326 }
2317 2327
2318 return isolate->heap()->undefined_value(); 2328 return isolate->heap()->undefined_value();
2319 } 2329 }
2320 2330
2321 2331
2322 RUNTIME_FUNCTION(MaybeObject*, Runtime_InitializeVarGlobal) { 2332 RUNTIME_FUNCTION(MaybeObject*, Runtime_InitializeVarGlobal) {
2323 HandleScope scope(isolate); 2333 HandleScope scope(isolate);
(...skipping 24 matching lines...) Expand all
2348 LookupResult lookup(isolate); 2358 LookupResult lookup(isolate);
2349 isolate->context()->global_object()->LocalLookup(*name, &lookup, true); 2359 isolate->context()->global_object()->LocalLookup(*name, &lookup, true);
2350 if (lookup.IsInterceptor()) { 2360 if (lookup.IsInterceptor()) {
2351 Handle<JSObject> holder(lookup.holder()); 2361 Handle<JSObject> holder(lookup.holder());
2352 PropertyAttributes intercepted = 2362 PropertyAttributes intercepted =
2353 JSReceiver::GetPropertyAttribute(holder, name); 2363 JSReceiver::GetPropertyAttribute(holder, name);
2354 if (intercepted != ABSENT && (intercepted & READ_ONLY) == 0) { 2364 if (intercepted != ABSENT && (intercepted & READ_ONLY) == 0) {
2355 // Found an interceptor that's not read only. 2365 // Found an interceptor that's not read only.
2356 if (assign) { 2366 if (assign) {
2357 CONVERT_ARG_HANDLE_CHECKED(Object, value, 2); 2367 CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
2358 Handle<Object> result = JSObject::SetPropertyForResult( 2368 Handle<Object> result;
2359 holder, &lookup, name, value, attributes, strict_mode); 2369 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
2360 RETURN_IF_EMPTY_HANDLE(isolate, result); 2370 isolate, result,
2371 JSObject::SetPropertyForResult(
2372 holder, &lookup, name, value, attributes, strict_mode));
2361 return *result; 2373 return *result;
2362 } else { 2374 } else {
2363 return isolate->heap()->undefined_value(); 2375 return isolate->heap()->undefined_value();
2364 } 2376 }
2365 } 2377 }
2366 } 2378 }
2367 2379
2368 if (assign) { 2380 if (assign) {
2369 CONVERT_ARG_HANDLE_CHECKED(Object, value, 2); 2381 CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
2370 Handle<GlobalObject> global(isolate->context()->global_object()); 2382 Handle<GlobalObject> global(isolate->context()->global_object());
2371 Handle<Object> result = JSReceiver::SetProperty( 2383 Handle<Object> result;
2372 global, name, value, attributes, strict_mode); 2384 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
2373 RETURN_IF_EMPTY_HANDLE(isolate, result); 2385 isolate, result,
2386 JSReceiver::SetProperty(global, name, value, attributes, strict_mode));
2374 return *result; 2387 return *result;
2375 } 2388 }
2376 return isolate->heap()->undefined_value(); 2389 return isolate->heap()->undefined_value();
2377 } 2390 }
2378 2391
2379 2392
2380 RUNTIME_FUNCTION(MaybeObject*, RuntimeHidden_InitializeConstGlobal) { 2393 RUNTIME_FUNCTION(MaybeObject*, RuntimeHidden_InitializeConstGlobal) {
2381 SealHandleScope shs(isolate); 2394 SealHandleScope shs(isolate);
2382 // All constants are declared with an initial value. The name 2395 // All constants are declared with an initial value. The name
2383 // of the constant is the first argument and the initial value 2396 // of the constant is the first argument and the initial value
(...skipping 30 matching lines...) Expand all
2414 if (!lookup.IsReadOnly()) { 2427 if (!lookup.IsReadOnly()) {
2415 // Restore global object from context (in case of GC) and continue 2428 // Restore global object from context (in case of GC) and continue
2416 // with setting the value. 2429 // with setting the value.
2417 HandleScope handle_scope(isolate); 2430 HandleScope handle_scope(isolate);
2418 Handle<GlobalObject> global(isolate->context()->global_object()); 2431 Handle<GlobalObject> global(isolate->context()->global_object());
2419 2432
2420 // BUG 1213575: Handle the case where we have to set a read-only 2433 // BUG 1213575: Handle the case where we have to set a read-only
2421 // property through an interceptor and only do it if it's 2434 // property through an interceptor and only do it if it's
2422 // uninitialized, e.g. the hole. Nirk... 2435 // uninitialized, e.g. the hole. Nirk...
2423 // Passing sloppy mode because the property is writable. 2436 // Passing sloppy mode because the property is writable.
2424 RETURN_IF_EMPTY_HANDLE( 2437 RETURN_FAILURE_ON_EXCEPTION(
2425 isolate, 2438 isolate,
2426 JSReceiver::SetProperty(global, name, value, attributes, SLOPPY)); 2439 JSReceiver::SetProperty(global, name, value, attributes, SLOPPY));
2427 return *value; 2440 return *value;
2428 } 2441 }
2429 2442
2430 // Set the value, but only if we're assigning the initial value to a 2443 // Set the value, but only if we're assigning the initial value to a
2431 // constant. For now, we determine this by checking if the 2444 // constant. For now, we determine this by checking if the
2432 // current value is the hole. 2445 // current value is the hole.
2433 // Strict mode handling not needed (const is disallowed in strict mode). 2446 // Strict mode handling not needed (const is disallowed in strict mode).
2434 if (lookup.IsField()) { 2447 if (lookup.IsField()) {
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after
2484 } 2497 }
2485 return *value; 2498 return *value;
2486 } 2499 }
2487 2500
2488 // The property could not be found, we introduce it as a property of the 2501 // The property could not be found, we introduce it as a property of the
2489 // global object. 2502 // global object.
2490 if (attributes == ABSENT) { 2503 if (attributes == ABSENT) {
2491 Handle<JSObject> global = Handle<JSObject>( 2504 Handle<JSObject> global = Handle<JSObject>(
2492 isolate->context()->global_object()); 2505 isolate->context()->global_object());
2493 // Strict mode not needed (const disallowed in strict mode). 2506 // Strict mode not needed (const disallowed in strict mode).
2494 RETURN_IF_EMPTY_HANDLE( 2507 RETURN_FAILURE_ON_EXCEPTION(
2495 isolate, 2508 isolate,
2496 JSReceiver::SetProperty(global, name, value, NONE, SLOPPY)); 2509 JSReceiver::SetProperty(global, name, value, NONE, SLOPPY));
2497 return *value; 2510 return *value;
2498 } 2511 }
2499 2512
2500 // The property was present in some function's context extension object, 2513 // The property was present in some function's context extension object,
2501 // as a property on the subject of a with, or as a property of the global 2514 // as a property on the subject of a with, or as a property of the global
2502 // object. 2515 // object.
2503 // 2516 //
2504 // In most situations, eval-introduced consts should still be present in 2517 // In most situations, eval-introduced consts should still be present in
(...skipping 30 matching lines...) Expand all
2535 } else { 2548 } else {
2536 // We should not reach here. Any real, named property should be 2549 // We should not reach here. Any real, named property should be
2537 // either a field or a dictionary slot. 2550 // either a field or a dictionary slot.
2538 UNREACHABLE(); 2551 UNREACHABLE();
2539 } 2552 }
2540 } else { 2553 } else {
2541 // The property was found on some other object. Set it if it is not a 2554 // The property was found on some other object. Set it if it is not a
2542 // read-only property. 2555 // read-only property.
2543 if ((attributes & READ_ONLY) == 0) { 2556 if ((attributes & READ_ONLY) == 0) {
2544 // Strict mode not needed (const disallowed in strict mode). 2557 // Strict mode not needed (const disallowed in strict mode).
2545 RETURN_IF_EMPTY_HANDLE( 2558 RETURN_FAILURE_ON_EXCEPTION(
2546 isolate, 2559 isolate,
2547 JSReceiver::SetProperty(object, name, value, attributes, SLOPPY)); 2560 JSReceiver::SetProperty(object, name, value, attributes, SLOPPY));
2548 } 2561 }
2549 } 2562 }
2550 2563
2551 return *value; 2564 return *value;
2552 } 2565 }
2553 2566
2554 2567
2555 RUNTIME_FUNCTION(MaybeObject*, 2568 RUNTIME_FUNCTION(MaybeObject*,
(...skipping 141 matching lines...) Expand 10 before | Expand all | Expand 10 after
2697 Builtins::Name builtin_name) { 2710 Builtins::Name builtin_name) {
2698 Handle<String> key = isolate->factory()->InternalizeUtf8String(name); 2711 Handle<String> key = isolate->factory()->InternalizeUtf8String(name);
2699 Handle<Code> code(isolate->builtins()->builtin(builtin_name)); 2712 Handle<Code> code(isolate->builtins()->builtin(builtin_name));
2700 Handle<JSFunction> optimized = 2713 Handle<JSFunction> optimized =
2701 isolate->factory()->NewFunction(key, 2714 isolate->factory()->NewFunction(key,
2702 JS_OBJECT_TYPE, 2715 JS_OBJECT_TYPE,
2703 JSObject::kHeaderSize, 2716 JSObject::kHeaderSize,
2704 code, 2717 code,
2705 false); 2718 false);
2706 optimized->shared()->DontAdaptArguments(); 2719 optimized->shared()->DontAdaptArguments();
2707 JSReceiver::SetProperty(holder, key, optimized, NONE, STRICT); 2720 JSReceiver::SetProperty(holder, key, optimized, NONE, STRICT).Assert();
2708 return optimized; 2721 return optimized;
2709 } 2722 }
2710 2723
2711 2724
2712 RUNTIME_FUNCTION(MaybeObject*, Runtime_SpecialArrayFunctions) { 2725 RUNTIME_FUNCTION(MaybeObject*, Runtime_SpecialArrayFunctions) {
2713 HandleScope scope(isolate); 2726 HandleScope scope(isolate);
2714 ASSERT(args.length() == 1); 2727 ASSERT(args.length() == 1);
2715 CONVERT_ARG_HANDLE_CHECKED(JSObject, holder, 0); 2728 CONVERT_ARG_HANDLE_CHECKED(JSObject, holder, 0);
2716 2729
2717 InstallBuiltin(isolate, holder, "pop", Builtins::kArrayPop); 2730 InstallBuiltin(isolate, holder, "pop", Builtins::kArrayPop);
(...skipping 2440 matching lines...) Expand 10 before | Expand all | Expand 10 after
5158 // in Object.defineProperty(). Firefox disagrees here, and actually changes 5171 // in Object.defineProperty(). Firefox disagrees here, and actually changes
5159 // the value. 5172 // the value.
5160 if (callback->IsAccessorInfo()) { 5173 if (callback->IsAccessorInfo()) {
5161 return isolate->heap()->undefined_value(); 5174 return isolate->heap()->undefined_value();
5162 } 5175 }
5163 // Avoid redefining foreign callback as data property, just use the stored 5176 // Avoid redefining foreign callback as data property, just use the stored
5164 // setter to update the value instead. 5177 // setter to update the value instead.
5165 // TODO(mstarzinger): So far this only works if property attributes don't 5178 // TODO(mstarzinger): So far this only works if property attributes don't
5166 // change, this should be fixed once we cleanup the underlying code. 5179 // change, this should be fixed once we cleanup the underlying code.
5167 if (callback->IsForeign() && lookup.GetAttributes() == attr) { 5180 if (callback->IsForeign() && lookup.GetAttributes() == attr) {
5168 Handle<Object> result_object = 5181 Handle<Object> result_object;
5182 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
5183 isolate, result_object,
5169 JSObject::SetPropertyWithCallback(js_object, 5184 JSObject::SetPropertyWithCallback(js_object,
5170 callback, 5185 callback,
5171 name, 5186 name,
5172 obj_value, 5187 obj_value,
5173 handle(lookup.holder()), 5188 handle(lookup.holder()),
5174 STRICT); 5189 STRICT));
5175 RETURN_IF_EMPTY_HANDLE(isolate, result_object);
5176 return *result_object; 5190 return *result_object;
5177 } 5191 }
5178 } 5192 }
5179 5193
5180 // Take special care when attributes are different and there is already 5194 // Take special care when attributes are different and there is already
5181 // a property. For simplicity we normalize the property which enables us 5195 // a property. For simplicity we normalize the property which enables us
5182 // to not worry about changing the instance_descriptor and creating a new 5196 // to not worry about changing the instance_descriptor and creating a new
5183 // map. The current version of SetObjectProperty does not handle attributes 5197 // map. The current version of SetObjectProperty does not handle attributes
5184 // correctly in the case where a property is a field and is reset with 5198 // correctly in the case where a property is a field and is reset with
5185 // new attributes. 5199 // new attributes.
5186 if (lookup.IsFound() && 5200 if (lookup.IsFound() &&
5187 (attr != lookup.GetAttributes() || lookup.IsPropertyCallbacks())) { 5201 (attr != lookup.GetAttributes() || lookup.IsPropertyCallbacks())) {
5188 // New attributes - normalize to avoid writing to instance descriptor 5202 // New attributes - normalize to avoid writing to instance descriptor
5189 if (js_object->IsJSGlobalProxy()) { 5203 if (js_object->IsJSGlobalProxy()) {
5190 // Since the result is a property, the prototype will exist so 5204 // Since the result is a property, the prototype will exist so
5191 // we don't have to check for null. 5205 // we don't have to check for null.
5192 js_object = Handle<JSObject>(JSObject::cast(js_object->GetPrototype())); 5206 js_object = Handle<JSObject>(JSObject::cast(js_object->GetPrototype()));
5193 } 5207 }
5194 JSObject::NormalizeProperties(js_object, CLEAR_INOBJECT_PROPERTIES, 0); 5208 JSObject::NormalizeProperties(js_object, CLEAR_INOBJECT_PROPERTIES, 0);
5195 // Use IgnoreAttributes version since a readonly property may be 5209 // Use IgnoreAttributes version since a readonly property may be
5196 // overridden and SetProperty does not allow this. 5210 // overridden and SetProperty does not allow this.
5197 Handle<Object> result = JSObject::SetLocalPropertyIgnoreAttributes( 5211 Handle<Object> result;
5198 js_object, name, obj_value, attr); 5212 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
5199 RETURN_IF_EMPTY_HANDLE(isolate, result); 5213 isolate, result,
5214 JSObject::SetLocalPropertyIgnoreAttributes(
5215 js_object, name, obj_value, attr));
5200 return *result; 5216 return *result;
5201 } 5217 }
5202 5218
5203 Handle<Object> result = Runtime::ForceSetObjectProperty(isolate, js_object, 5219 Handle<Object> result;
5204 name, 5220 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
5205 obj_value, 5221 isolate, result,
5206 attr); 5222 Runtime::ForceSetObjectProperty(js_object, name, obj_value, attr));
5207 RETURN_IF_EMPTY_HANDLE(isolate, result);
5208 return *result; 5223 return *result;
5209 } 5224 }
5210 5225
5211 5226
5212 // Return property without being observable by accessors or interceptors. 5227 // Return property without being observable by accessors or interceptors.
5213 RUNTIME_FUNCTION(MaybeObject*, Runtime_GetDataProperty) { 5228 RUNTIME_FUNCTION(MaybeObject*, Runtime_GetDataProperty) {
5214 SealHandleScope shs(isolate); 5229 SealHandleScope shs(isolate);
5215 ASSERT(args.length() == 2); 5230 ASSERT(args.length() == 2);
5216 CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0); 5231 CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
5217 CONVERT_ARG_HANDLE_CHECKED(Name, key, 1); 5232 CONVERT_ARG_HANDLE_CHECKED(Name, key, 1);
(...skipping 14 matching lines...) Expand all
5232 case INTERCEPTOR: 5247 case INTERCEPTOR:
5233 break; 5248 break;
5234 case NONEXISTENT: 5249 case NONEXISTENT:
5235 UNREACHABLE(); 5250 UNREACHABLE();
5236 } 5251 }
5237 } 5252 }
5238 return isolate->heap()->undefined_value(); 5253 return isolate->heap()->undefined_value();
5239 } 5254 }
5240 5255
5241 5256
5242 Handle<Object> Runtime::SetObjectProperty(Isolate* isolate, 5257 MaybeHandle<Object> Runtime::SetObjectProperty(Isolate* isolate,
5243 Handle<Object> object, 5258 Handle<Object> object,
5244 Handle<Object> key, 5259 Handle<Object> key,
5245 Handle<Object> value, 5260 Handle<Object> value,
5246 PropertyAttributes attr, 5261 PropertyAttributes attr,
5247 StrictMode strict_mode) { 5262 StrictMode strict_mode) {
5248 SetPropertyMode set_mode = attr == NONE ? SET_PROPERTY : DEFINE_PROPERTY; 5263 SetPropertyMode set_mode = attr == NONE ? SET_PROPERTY : DEFINE_PROPERTY;
5249 5264
5250 if (object->IsUndefined() || object->IsNull()) { 5265 if (object->IsUndefined() || object->IsNull()) {
5251 Handle<Object> args[2] = { key, object }; 5266 Handle<Object> args[2] = { key, object };
5252 Handle<Object> error = 5267 Handle<Object> error =
5253 isolate->factory()->NewTypeError("non_object_property_store", 5268 isolate->factory()->NewTypeError("non_object_property_store",
5254 HandleVector(args, 2)); 5269 HandleVector(args, 2));
5255 isolate->Throw(*error); 5270 isolate->Throw(*error);
5256 return Handle<Object>(); 5271 return Handle<Object>();
5257 } 5272 }
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after
5336 if (name->AsArrayIndex(&index)) { 5351 if (name->AsArrayIndex(&index)) {
5337 return JSObject::SetElement(js_object, index, value, attr, strict_mode, 5352 return JSObject::SetElement(js_object, index, value, attr, strict_mode,
5338 true, 5353 true,
5339 set_mode); 5354 set_mode);
5340 } else { 5355 } else {
5341 return JSReceiver::SetProperty(js_object, name, value, attr, strict_mode); 5356 return JSReceiver::SetProperty(js_object, name, value, attr, strict_mode);
5342 } 5357 }
5343 } 5358 }
5344 5359
5345 5360
5346 Handle<Object> Runtime::ForceSetObjectProperty(Isolate* isolate, 5361 MaybeHandle<Object> Runtime::ForceSetObjectProperty(Handle<JSObject> js_object,
5347 Handle<JSObject> js_object, 5362 Handle<Object> key,
5348 Handle<Object> key, 5363 Handle<Object> value,
5349 Handle<Object> value, 5364 PropertyAttributes attr) {
5350 PropertyAttributes attr) { 5365 Isolate* isolate = js_object->GetIsolate();
5351 // Check if the given key is an array index. 5366 // Check if the given key is an array index.
5352 uint32_t index; 5367 uint32_t index;
5353 if (key->ToArrayIndex(&index)) { 5368 if (key->ToArrayIndex(&index)) {
5354 // In Firefox/SpiderMonkey, Safari and Opera you can access the characters 5369 // In Firefox/SpiderMonkey, Safari and Opera you can access the characters
5355 // of a string using [] notation. We need to support this too in 5370 // of a string using [] notation. We need to support this too in
5356 // JavaScript. 5371 // JavaScript.
5357 // In the case of a String object we just need to redirect the assignment to 5372 // In the case of a String object we just need to redirect the assignment to
5358 // the underlying string if the index is in range. Since the underlying 5373 // the underlying string if the index is in range. Since the underlying
5359 // string does nothing with the assignment then we can ignore such 5374 // string does nothing with the assignment then we can ignore such
5360 // assignments. 5375 // assignments.
(...skipping 104 matching lines...) Expand 10 before | Expand all | Expand 10 after
5465 // Compute attributes. 5480 // Compute attributes.
5466 PropertyAttributes attributes = 5481 PropertyAttributes attributes =
5467 static_cast<PropertyAttributes>(unchecked_attributes); 5482 static_cast<PropertyAttributes>(unchecked_attributes);
5468 5483
5469 StrictMode strict_mode = SLOPPY; 5484 StrictMode strict_mode = SLOPPY;
5470 if (args.length() == 5) { 5485 if (args.length() == 5) {
5471 CONVERT_STRICT_MODE_ARG_CHECKED(strict_mode_arg, 4); 5486 CONVERT_STRICT_MODE_ARG_CHECKED(strict_mode_arg, 4);
5472 strict_mode = strict_mode_arg; 5487 strict_mode = strict_mode_arg;
5473 } 5488 }
5474 5489
5475 Handle<Object> result = Runtime::SetObjectProperty(isolate, object, key, 5490 Handle<Object> result;
5476 value, 5491 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
5477 attributes, 5492 isolate, result,
5478 strict_mode); 5493 Runtime::SetObjectProperty(
5479 RETURN_IF_EMPTY_HANDLE(isolate, result); 5494 isolate, object, key, value, attributes, strict_mode));
5480 return *result; 5495 return *result;
5481 } 5496 }
5482 5497
5483 5498
5484 RUNTIME_FUNCTION(MaybeObject*, Runtime_TransitionElementsKind) { 5499 RUNTIME_FUNCTION(MaybeObject*, Runtime_TransitionElementsKind) {
5485 HandleScope scope(isolate); 5500 HandleScope scope(isolate);
5486 RUNTIME_ASSERT(args.length() == 2); 5501 RUNTIME_ASSERT(args.length() == 2);
5487 CONVERT_ARG_HANDLE_CHECKED(JSArray, array, 0); 5502 CONVERT_ARG_HANDLE_CHECKED(JSArray, array, 0);
5488 CONVERT_ARG_HANDLE_CHECKED(Map, map, 1); 5503 CONVERT_ARG_HANDLE_CHECKED(Map, map, 1);
5489 JSObject::TransitionElementsKind(array, map->elements_kind()); 5504 JSObject::TransitionElementsKind(array, map->elements_kind());
(...skipping 138 matching lines...) Expand 10 before | Expand all | Expand 10 after
5628 CONVERT_ARG_HANDLE_CHECKED(Object, value, 2); 5643 CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
5629 // Compute attributes. 5644 // Compute attributes.
5630 PropertyAttributes attributes = NONE; 5645 PropertyAttributes attributes = NONE;
5631 if (args.length() == 4) { 5646 if (args.length() == 4) {
5632 CONVERT_SMI_ARG_CHECKED(unchecked_value, 3); 5647 CONVERT_SMI_ARG_CHECKED(unchecked_value, 3);
5633 // Only attribute bits should be set. 5648 // Only attribute bits should be set.
5634 RUNTIME_ASSERT( 5649 RUNTIME_ASSERT(
5635 (unchecked_value & ~(READ_ONLY | DONT_ENUM | DONT_DELETE)) == 0); 5650 (unchecked_value & ~(READ_ONLY | DONT_ENUM | DONT_DELETE)) == 0);
5636 attributes = static_cast<PropertyAttributes>(unchecked_value); 5651 attributes = static_cast<PropertyAttributes>(unchecked_value);
5637 } 5652 }
5638 Handle<Object> result = JSObject::SetLocalPropertyIgnoreAttributes( 5653 Handle<Object> result;
5639 object, name, value, attributes); 5654 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
5640 RETURN_IF_EMPTY_HANDLE(isolate, result); 5655 isolate, result,
5656 JSObject::SetLocalPropertyIgnoreAttributes(
5657 object, name, value, attributes));
5641 return *result; 5658 return *result;
5642 } 5659 }
5643 5660
5644 5661
5645 RUNTIME_FUNCTION(MaybeObject*, Runtime_DeleteProperty) { 5662 RUNTIME_FUNCTION(MaybeObject*, Runtime_DeleteProperty) {
5646 HandleScope scope(isolate); 5663 HandleScope scope(isolate);
5647 ASSERT(args.length() == 3); 5664 ASSERT(args.length() == 3);
5648 CONVERT_ARG_HANDLE_CHECKED(JSReceiver, object, 0); 5665 CONVERT_ARG_HANDLE_CHECKED(JSReceiver, object, 0);
5649 CONVERT_ARG_HANDLE_CHECKED(Name, key, 1); 5666 CONVERT_ARG_HANDLE_CHECKED(Name, key, 1);
5650 CONVERT_STRICT_MODE_ARG_CHECKED(strict_mode, 2); 5667 CONVERT_STRICT_MODE_ARG_CHECKED(strict_mode, 2);
(...skipping 2579 matching lines...) Expand 10 before | Expand all | Expand 10 after
8230 } 8247 }
8231 new_bindings->set_map_no_write_barrier( 8248 new_bindings->set_map_no_write_barrier(
8232 isolate->heap()->fixed_cow_array_map()); 8249 isolate->heap()->fixed_cow_array_map());
8233 bound_function->set_function_bindings(*new_bindings); 8250 bound_function->set_function_bindings(*new_bindings);
8234 8251
8235 // Update length. 8252 // Update length.
8236 Handle<String> length_string = isolate->factory()->length_string(); 8253 Handle<String> length_string = isolate->factory()->length_string();
8237 Handle<Object> new_length(args.at<Object>(3)); 8254 Handle<Object> new_length(args.at<Object>(3));
8238 PropertyAttributes attr = 8255 PropertyAttributes attr =
8239 static_cast<PropertyAttributes>(DONT_DELETE | DONT_ENUM | READ_ONLY); 8256 static_cast<PropertyAttributes>(DONT_DELETE | DONT_ENUM | READ_ONLY);
8240 ForceSetProperty(bound_function, length_string, new_length, attr); 8257 Runtime::ForceSetObjectProperty(
8258 bound_function, length_string, new_length, attr).Assert();
8241 return *bound_function; 8259 return *bound_function;
8242 } 8260 }
8243 8261
8244 8262
8245 RUNTIME_FUNCTION(MaybeObject*, Runtime_BoundFunctionGetBindings) { 8263 RUNTIME_FUNCTION(MaybeObject*, Runtime_BoundFunctionGetBindings) {
8246 HandleScope handles(isolate); 8264 HandleScope handles(isolate);
8247 ASSERT(args.length() == 1); 8265 ASSERT(args.length() == 1);
8248 CONVERT_ARG_HANDLE_CHECKED(JSReceiver, callable, 0); 8266 CONVERT_ARG_HANDLE_CHECKED(JSReceiver, callable, 0);
8249 if (callable->IsJSFunction()) { 8267 if (callable->IsJSFunction()) {
8250 Handle<JSFunction> function = Handle<JSFunction>::cast(callable); 8268 Handle<JSFunction> function = Handle<JSFunction>::cast(callable);
(...skipping 914 matching lines...) Expand 10 before | Expand all | Expand 10 after
9165 Handle<AccessorInfo> info = 9183 Handle<AccessorInfo> info =
9166 Accessors::MakeModuleExport(name, index, attr); 9184 Accessors::MakeModuleExport(name, index, attr);
9167 Handle<Object> result = JSObject::SetAccessor(module, info); 9185 Handle<Object> result = JSObject::SetAccessor(module, info);
9168 ASSERT(!(result.is_null() || result->IsUndefined())); 9186 ASSERT(!(result.is_null() || result->IsUndefined()));
9169 USE(result); 9187 USE(result);
9170 break; 9188 break;
9171 } 9189 }
9172 case MODULE: { 9190 case MODULE: {
9173 Object* referenced_context = Context::cast(host_context)->get(index); 9191 Object* referenced_context = Context::cast(host_context)->get(index);
9174 Handle<JSModule> value(Context::cast(referenced_context)->module()); 9192 Handle<JSModule> value(Context::cast(referenced_context)->module());
9175 JSReceiver::SetProperty(module, name, value, FROZEN, STRICT); 9193 JSReceiver::SetProperty(module, name, value, FROZEN, STRICT).Assert();
9176 break; 9194 break;
9177 } 9195 }
9178 case INTERNAL: 9196 case INTERNAL:
9179 case TEMPORARY: 9197 case TEMPORARY:
9180 case DYNAMIC: 9198 case DYNAMIC:
9181 case DYNAMIC_GLOBAL: 9199 case DYNAMIC_GLOBAL:
9182 case DYNAMIC_LOCAL: 9200 case DYNAMIC_LOCAL:
9183 UNREACHABLE(); 9201 UNREACHABLE();
9184 } 9202 }
9185 } 9203 }
(...skipping 266 matching lines...) Expand 10 before | Expand all | Expand 10 after
9452 return isolate->Throw(*error); 9470 return isolate->Throw(*error);
9453 } 9471 }
9454 // In sloppy mode, the property is added to the global object. 9472 // In sloppy mode, the property is added to the global object.
9455 attributes = NONE; 9473 attributes = NONE;
9456 object = Handle<JSReceiver>(isolate->context()->global_object()); 9474 object = Handle<JSReceiver>(isolate->context()->global_object());
9457 } 9475 }
9458 9476
9459 // Set the property if it's not read only or doesn't yet exist. 9477 // Set the property if it's not read only or doesn't yet exist.
9460 if ((attributes & READ_ONLY) == 0 || 9478 if ((attributes & READ_ONLY) == 0 ||
9461 (JSReceiver::GetLocalPropertyAttribute(object, name) == ABSENT)) { 9479 (JSReceiver::GetLocalPropertyAttribute(object, name) == ABSENT)) {
9462 RETURN_IF_EMPTY_HANDLE( 9480 RETURN_FAILURE_ON_EXCEPTION(
9463 isolate, 9481 isolate,
9464 JSReceiver::SetProperty(object, name, value, NONE, strict_mode)); 9482 JSReceiver::SetProperty(object, name, value, NONE, strict_mode));
9465 } else if (strict_mode == STRICT && (attributes & READ_ONLY) != 0) { 9483 } else if (strict_mode == STRICT && (attributes & READ_ONLY) != 0) {
9466 // Setting read only property in strict mode. 9484 // Setting read only property in strict mode.
9467 Handle<Object> error = 9485 Handle<Object> error =
9468 isolate->factory()->NewTypeError( 9486 isolate->factory()->NewTypeError(
9469 "strict_cannot_assign", HandleVector(&name, 1)); 9487 "strict_cannot_assign", HandleVector(&name, 1));
9470 return isolate->Throw(*error); 9488 return isolate->Throw(*error);
9471 } 9489 }
9472 return *value; 9490 return *value;
(...skipping 1964 matching lines...) Expand 10 before | Expand all | Expand 10 after
11437 static bool ParameterIsShadowedByContextLocal(Handle<ScopeInfo> info, 11455 static bool ParameterIsShadowedByContextLocal(Handle<ScopeInfo> info,
11438 int index) { 11456 int index) {
11439 VariableMode mode; 11457 VariableMode mode;
11440 InitializationFlag flag; 11458 InitializationFlag flag;
11441 return info->ContextSlotIndex(info->ParameterName(index), &mode, &flag) != -1; 11459 return info->ContextSlotIndex(info->ParameterName(index), &mode, &flag) != -1;
11442 } 11460 }
11443 11461
11444 11462
11445 // Create a plain JSObject which materializes the local scope for the specified 11463 // Create a plain JSObject which materializes the local scope for the specified
11446 // frame. 11464 // frame.
11447 static Handle<JSObject> MaterializeStackLocalsWithFrameInspector( 11465 MUST_USE_RESULT
11466 static MaybeHandle<JSObject> MaterializeStackLocalsWithFrameInspector(
11448 Isolate* isolate, 11467 Isolate* isolate,
11449 Handle<JSObject> target, 11468 Handle<JSObject> target,
11450 Handle<JSFunction> function, 11469 Handle<JSFunction> function,
11451 FrameInspector* frame_inspector) { 11470 FrameInspector* frame_inspector) {
11452 Handle<SharedFunctionInfo> shared(function->shared()); 11471 Handle<SharedFunctionInfo> shared(function->shared());
11453 Handle<ScopeInfo> scope_info(shared->scope_info()); 11472 Handle<ScopeInfo> scope_info(shared->scope_info());
11454 11473
11455 // First fill all parameters. 11474 // First fill all parameters.
11456 for (int i = 0; i < scope_info->ParameterCount(); ++i) { 11475 for (int i = 0; i < scope_info->ParameterCount(); ++i) {
11457 // Do not materialize the parameter if it is shadowed by a context local. 11476 // Do not materialize the parameter if it is shadowed by a context local.
11458 if (ParameterIsShadowedByContextLocal(scope_info, i)) continue; 11477 if (ParameterIsShadowedByContextLocal(scope_info, i)) continue;
11459 11478
11460 HandleScope scope(isolate); 11479 HandleScope scope(isolate);
11461 Handle<Object> value(i < frame_inspector->GetParametersCount() 11480 Handle<Object> value(i < frame_inspector->GetParametersCount()
11462 ? frame_inspector->GetParameter(i) 11481 ? frame_inspector->GetParameter(i)
11463 : isolate->heap()->undefined_value(), 11482 : isolate->heap()->undefined_value(),
11464 isolate); 11483 isolate);
11465 ASSERT(!value->IsTheHole()); 11484 ASSERT(!value->IsTheHole());
11466 Handle<String> name(scope_info->ParameterName(i)); 11485 Handle<String> name(scope_info->ParameterName(i));
11467 11486
11468 RETURN_IF_EMPTY_HANDLE_VALUE( 11487 RETURN_ON_EXCEPTION(
11469 isolate, 11488 isolate,
11470 Runtime::SetObjectProperty(isolate, target, name, value, NONE, SLOPPY), 11489 Runtime::SetObjectProperty(isolate, target, name, value, NONE, SLOPPY),
11471 Handle<JSObject>()); 11490 JSObject);
11472 } 11491 }
11473 11492
11474 // Second fill all stack locals. 11493 // Second fill all stack locals.
11475 for (int i = 0; i < scope_info->StackLocalCount(); ++i) { 11494 for (int i = 0; i < scope_info->StackLocalCount(); ++i) {
11476 Handle<String> name(scope_info->StackLocalName(i)); 11495 Handle<String> name(scope_info->StackLocalName(i));
11477 Handle<Object> value(frame_inspector->GetExpression(i), isolate); 11496 Handle<Object> value(frame_inspector->GetExpression(i), isolate);
11478 if (value->IsTheHole()) continue; 11497 if (value->IsTheHole()) continue;
11479 11498
11480 RETURN_IF_EMPTY_HANDLE_VALUE( 11499 RETURN_ON_EXCEPTION(
11481 isolate, 11500 isolate,
11482 Runtime::SetObjectProperty(isolate, target, name, value, NONE, SLOPPY), 11501 Runtime::SetObjectProperty(isolate, target, name, value, NONE, SLOPPY),
11483 Handle<JSObject>()); 11502 JSObject);
11484 } 11503 }
11485 11504
11486 return target; 11505 return target;
11487 } 11506 }
11488 11507
11489 11508
11490 static void UpdateStackLocalsFromMaterializedObject(Isolate* isolate, 11509 static void UpdateStackLocalsFromMaterializedObject(Isolate* isolate,
11491 Handle<JSObject> target, 11510 Handle<JSObject> target,
11492 Handle<JSFunction> function, 11511 Handle<JSFunction> function,
11493 JavaScriptFrame* frame, 11512 JavaScriptFrame* frame,
(...skipping 24 matching lines...) Expand all
11518 for (int i = 0; i < scope_info->StackLocalCount(); ++i) { 11537 for (int i = 0; i < scope_info->StackLocalCount(); ++i) {
11519 if (frame->GetExpression(i)->IsTheHole()) continue; 11538 if (frame->GetExpression(i)->IsTheHole()) continue;
11520 HandleScope scope(isolate); 11539 HandleScope scope(isolate);
11521 Handle<Object> value = Object::GetPropertyOrElement( 11540 Handle<Object> value = Object::GetPropertyOrElement(
11522 target, Handle<String>(scope_info->StackLocalName(i))); 11541 target, Handle<String>(scope_info->StackLocalName(i)));
11523 frame->SetExpression(i, *value); 11542 frame->SetExpression(i, *value);
11524 } 11543 }
11525 } 11544 }
11526 11545
11527 11546
11528 static Handle<JSObject> MaterializeLocalContext(Isolate* isolate, 11547 MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeLocalContext(
11529 Handle<JSObject> target, 11548 Isolate* isolate,
11530 Handle<JSFunction> function, 11549 Handle<JSObject> target,
11531 JavaScriptFrame* frame) { 11550 Handle<JSFunction> function,
11551 JavaScriptFrame* frame) {
11532 HandleScope scope(isolate); 11552 HandleScope scope(isolate);
11533 Handle<SharedFunctionInfo> shared(function->shared()); 11553 Handle<SharedFunctionInfo> shared(function->shared());
11534 Handle<ScopeInfo> scope_info(shared->scope_info()); 11554 Handle<ScopeInfo> scope_info(shared->scope_info());
11535 11555
11536 if (!scope_info->HasContext()) return target; 11556 if (!scope_info->HasContext()) return target;
11537 11557
11538 // Third fill all context locals. 11558 // Third fill all context locals.
11539 Handle<Context> frame_context(Context::cast(frame->context())); 11559 Handle<Context> frame_context(Context::cast(frame->context()));
11540 Handle<Context> function_context(frame_context->declaration_context()); 11560 Handle<Context> function_context(frame_context->declaration_context());
11541 if (!ScopeInfo::CopyContextLocalsToScopeObject( 11561 if (!ScopeInfo::CopyContextLocalsToScopeObject(
11542 scope_info, function_context, target)) { 11562 scope_info, function_context, target)) {
11543 return Handle<JSObject>(); 11563 return MaybeHandle<JSObject>();
11544 } 11564 }
11545 11565
11546 // Finally copy any properties from the function context extension. 11566 // Finally copy any properties from the function context extension.
11547 // These will be variables introduced by eval. 11567 // These will be variables introduced by eval.
11548 if (function_context->closure() == *function) { 11568 if (function_context->closure() == *function) {
11549 if (function_context->has_extension() && 11569 if (function_context->has_extension() &&
11550 !function_context->IsNativeContext()) { 11570 !function_context->IsNativeContext()) {
11551 Handle<JSObject> ext(JSObject::cast(function_context->extension())); 11571 Handle<JSObject> ext(JSObject::cast(function_context->extension()));
11552 bool threw = false; 11572 bool threw = false;
11553 Handle<FixedArray> keys = 11573 Handle<FixedArray> keys =
11554 GetKeysInFixedArrayFor(ext, INCLUDE_PROTOS, &threw); 11574 GetKeysInFixedArrayFor(ext, INCLUDE_PROTOS, &threw);
11555 if (threw) return Handle<JSObject>(); 11575 if (threw) return Handle<JSObject>();
11556 11576
11557 for (int i = 0; i < keys->length(); i++) { 11577 for (int i = 0; i < keys->length(); i++) {
11558 // Names of variables introduced by eval are strings. 11578 // Names of variables introduced by eval are strings.
11559 ASSERT(keys->get(i)->IsString()); 11579 ASSERT(keys->get(i)->IsString());
11560 Handle<String> key(String::cast(keys->get(i))); 11580 Handle<String> key(String::cast(keys->get(i)));
11561 RETURN_IF_EMPTY_HANDLE_VALUE( 11581 RETURN_ON_EXCEPTION(
11562 isolate, 11582 isolate,
11563 Runtime::SetObjectProperty(isolate, 11583 Runtime::SetObjectProperty(isolate,
11564 target, 11584 target,
11565 key, 11585 key,
11566 Object::GetPropertyOrElement(ext, key), 11586 Object::GetPropertyOrElement(ext, key),
11567 NONE, 11587 NONE,
11568 SLOPPY), 11588 SLOPPY),
11569 Handle<JSObject>()); 11589 JSObject);
11570 } 11590 }
11571 } 11591 }
11572 } 11592 }
11573 11593
11574 return target; 11594 return target;
11575 } 11595 }
11576 11596
11577 11597
11578 static Handle<JSObject> MaterializeLocalScope( 11598 MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeLocalScope(
11579 Isolate* isolate, 11599 Isolate* isolate,
11580 JavaScriptFrame* frame, 11600 JavaScriptFrame* frame,
11581 int inlined_jsframe_index) { 11601 int inlined_jsframe_index) {
11582 FrameInspector frame_inspector(frame, inlined_jsframe_index, isolate); 11602 FrameInspector frame_inspector(frame, inlined_jsframe_index, isolate);
11583 Handle<JSFunction> function(JSFunction::cast(frame_inspector.GetFunction())); 11603 Handle<JSFunction> function(JSFunction::cast(frame_inspector.GetFunction()));
11584 11604
11585 Handle<JSObject> local_scope = 11605 Handle<JSObject> local_scope =
11586 isolate->factory()->NewJSObject(isolate->object_function()); 11606 isolate->factory()->NewJSObject(isolate->object_function());
11587 local_scope = MaterializeStackLocalsWithFrameInspector( 11607 ASSIGN_RETURN_ON_EXCEPTION(
11588 isolate, local_scope, function, &frame_inspector); 11608 isolate, local_scope,
11589 RETURN_IF_EMPTY_HANDLE_VALUE(isolate, local_scope, Handle<JSObject>()); 11609 MaterializeStackLocalsWithFrameInspector(
11610 isolate, local_scope, function, &frame_inspector),
11611 JSObject);
11590 11612
11591 return MaterializeLocalContext(isolate, local_scope, function, frame); 11613 return MaterializeLocalContext(isolate, local_scope, function, frame);
11592 } 11614 }
11593 11615
11594 11616
11595 // Set the context local variable value. 11617 // Set the context local variable value.
11596 static bool SetContextLocalValue(Isolate* isolate, 11618 static bool SetContextLocalValue(Isolate* isolate,
11597 Handle<ScopeInfo> scope_info, 11619 Handle<ScopeInfo> scope_info,
11598 Handle<Context> context, 11620 Handle<Context> context,
11599 Handle<String> variable_name, 11621 Handle<String> variable_name,
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after
11659 // Function context extension. These are variables introduced by eval. 11681 // Function context extension. These are variables introduced by eval.
11660 if (function_context->closure() == *function) { 11682 if (function_context->closure() == *function) {
11661 if (function_context->has_extension() && 11683 if (function_context->has_extension() &&
11662 !function_context->IsNativeContext()) { 11684 !function_context->IsNativeContext()) {
11663 Handle<JSObject> ext(JSObject::cast(function_context->extension())); 11685 Handle<JSObject> ext(JSObject::cast(function_context->extension()));
11664 11686
11665 if (JSReceiver::HasProperty(ext, variable_name)) { 11687 if (JSReceiver::HasProperty(ext, variable_name)) {
11666 // We don't expect this to do anything except replacing 11688 // We don't expect this to do anything except replacing
11667 // property value. 11689 // property value.
11668 Runtime::SetObjectProperty(isolate, ext, variable_name, new_value, 11690 Runtime::SetObjectProperty(isolate, ext, variable_name, new_value,
11669 NONE, SLOPPY); 11691 NONE, SLOPPY).Assert();
11670 return true; 11692 return true;
11671 } 11693 }
11672 } 11694 }
11673 } 11695 }
11674 } 11696 }
11675 11697
11676 return default_result; 11698 return default_result;
11677 } 11699 }
11678 11700
11679 11701
11680 // Create a plain JSObject which materializes the closure content for the 11702 // Create a plain JSObject which materializes the closure content for the
11681 // context. 11703 // context.
11682 static Handle<JSObject> MaterializeClosure(Isolate* isolate, 11704 MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeClosure(
11683 Handle<Context> context) { 11705 Isolate* isolate,
11706 Handle<Context> context) {
11684 ASSERT(context->IsFunctionContext()); 11707 ASSERT(context->IsFunctionContext());
11685 11708
11686 Handle<SharedFunctionInfo> shared(context->closure()->shared()); 11709 Handle<SharedFunctionInfo> shared(context->closure()->shared());
11687 Handle<ScopeInfo> scope_info(shared->scope_info()); 11710 Handle<ScopeInfo> scope_info(shared->scope_info());
11688 11711
11689 // Allocate and initialize a JSObject with all the content of this function 11712 // Allocate and initialize a JSObject with all the content of this function
11690 // closure. 11713 // closure.
11691 Handle<JSObject> closure_scope = 11714 Handle<JSObject> closure_scope =
11692 isolate->factory()->NewJSObject(isolate->object_function()); 11715 isolate->factory()->NewJSObject(isolate->object_function());
11693 11716
11694 // Fill all context locals to the context extension. 11717 // Fill all context locals to the context extension.
11695 if (!ScopeInfo::CopyContextLocalsToScopeObject( 11718 if (!ScopeInfo::CopyContextLocalsToScopeObject(
11696 scope_info, context, closure_scope)) { 11719 scope_info, context, closure_scope)) {
11697 return Handle<JSObject>(); 11720 return MaybeHandle<JSObject>();
11698 } 11721 }
11699 11722
11700 // Finally copy any properties from the function context extension. This will 11723 // Finally copy any properties from the function context extension. This will
11701 // be variables introduced by eval. 11724 // be variables introduced by eval.
11702 if (context->has_extension()) { 11725 if (context->has_extension()) {
11703 Handle<JSObject> ext(JSObject::cast(context->extension())); 11726 Handle<JSObject> ext(JSObject::cast(context->extension()));
11704 bool threw = false; 11727 bool threw = false;
11705 Handle<FixedArray> keys = 11728 Handle<FixedArray> keys =
11706 GetKeysInFixedArrayFor(ext, INCLUDE_PROTOS, &threw); 11729 GetKeysInFixedArrayFor(ext, INCLUDE_PROTOS, &threw);
11707 if (threw) return Handle<JSObject>(); 11730 if (threw) return Handle<JSObject>();
11708 11731
11709 for (int i = 0; i < keys->length(); i++) { 11732 for (int i = 0; i < keys->length(); i++) {
11710 // Names of variables introduced by eval are strings. 11733 // Names of variables introduced by eval are strings.
11711 ASSERT(keys->get(i)->IsString()); 11734 ASSERT(keys->get(i)->IsString());
11712 Handle<String> key(String::cast(keys->get(i))); 11735 Handle<String> key(String::cast(keys->get(i)));
11713 RETURN_IF_EMPTY_HANDLE_VALUE( 11736 RETURN_ON_EXCEPTION(
11714 isolate, 11737 isolate,
11715 Runtime::SetObjectProperty(isolate, closure_scope, key, 11738 Runtime::SetObjectProperty(isolate, closure_scope, key,
11716 Object::GetPropertyOrElement(ext, key), 11739 Object::GetPropertyOrElement(ext, key),
11717 NONE, SLOPPY), 11740 NONE, SLOPPY),
11718 Handle<JSObject>()); 11741 JSObject);
11719 } 11742 }
11720 } 11743 }
11721 11744
11722 return closure_scope; 11745 return closure_scope;
11723 } 11746 }
11724 11747
11725 11748
11726 // This method copies structure of MaterializeClosure method above. 11749 // This method copies structure of MaterializeClosure method above.
11727 static bool SetClosureVariableValue(Isolate* isolate, 11750 static bool SetClosureVariableValue(Isolate* isolate,
11728 Handle<Context> context, 11751 Handle<Context> context,
(...skipping 10 matching lines...) Expand all
11739 return true; 11762 return true;
11740 } 11763 }
11741 11764
11742 // Properties from the function context extension. This will 11765 // Properties from the function context extension. This will
11743 // be variables introduced by eval. 11766 // be variables introduced by eval.
11744 if (context->has_extension()) { 11767 if (context->has_extension()) {
11745 Handle<JSObject> ext(JSObject::cast(context->extension())); 11768 Handle<JSObject> ext(JSObject::cast(context->extension()));
11746 if (JSReceiver::HasProperty(ext, variable_name)) { 11769 if (JSReceiver::HasProperty(ext, variable_name)) {
11747 // We don't expect this to do anything except replacing property value. 11770 // We don't expect this to do anything except replacing property value.
11748 Runtime::SetObjectProperty(isolate, ext, variable_name, new_value, 11771 Runtime::SetObjectProperty(isolate, ext, variable_name, new_value,
11749 NONE, SLOPPY); 11772 NONE, SLOPPY).Assert();
11750 return true; 11773 return true;
11751 } 11774 }
11752 } 11775 }
11753 11776
11754 return false; 11777 return false;
11755 } 11778 }
11756 11779
11757 11780
11758 // Create a plain JSObject which materializes the scope for the specified 11781 // Create a plain JSObject which materializes the scope for the specified
11759 // catch context. 11782 // catch context.
11760 static Handle<JSObject> MaterializeCatchScope(Isolate* isolate, 11783 MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeCatchScope(
11761 Handle<Context> context) { 11784 Isolate* isolate,
11785 Handle<Context> context) {
11762 ASSERT(context->IsCatchContext()); 11786 ASSERT(context->IsCatchContext());
11763 Handle<String> name(String::cast(context->extension())); 11787 Handle<String> name(String::cast(context->extension()));
11764 Handle<Object> thrown_object(context->get(Context::THROWN_OBJECT_INDEX), 11788 Handle<Object> thrown_object(context->get(Context::THROWN_OBJECT_INDEX),
11765 isolate); 11789 isolate);
11766 Handle<JSObject> catch_scope = 11790 Handle<JSObject> catch_scope =
11767 isolate->factory()->NewJSObject(isolate->object_function()); 11791 isolate->factory()->NewJSObject(isolate->object_function());
11768 RETURN_IF_EMPTY_HANDLE_VALUE( 11792 RETURN_ON_EXCEPTION(
11769 isolate, 11793 isolate,
11770 Runtime::SetObjectProperty(isolate, catch_scope, name, thrown_object, 11794 Runtime::SetObjectProperty(isolate, catch_scope, name, thrown_object,
11771 NONE, SLOPPY), 11795 NONE, SLOPPY),
11772 Handle<JSObject>()); 11796 JSObject);
11773 return catch_scope; 11797 return catch_scope;
11774 } 11798 }
11775 11799
11776 11800
11777 static bool SetCatchVariableValue(Isolate* isolate, 11801 static bool SetCatchVariableValue(Isolate* isolate,
11778 Handle<Context> context, 11802 Handle<Context> context,
11779 Handle<String> variable_name, 11803 Handle<String> variable_name,
11780 Handle<Object> new_value) { 11804 Handle<Object> new_value) {
11781 ASSERT(context->IsCatchContext()); 11805 ASSERT(context->IsCatchContext());
11782 Handle<String> name(String::cast(context->extension())); 11806 Handle<String> name(String::cast(context->extension()));
11783 if (!name->Equals(*variable_name)) { 11807 if (!name->Equals(*variable_name)) {
11784 return false; 11808 return false;
11785 } 11809 }
11786 context->set(Context::THROWN_OBJECT_INDEX, *new_value); 11810 context->set(Context::THROWN_OBJECT_INDEX, *new_value);
11787 return true; 11811 return true;
11788 } 11812 }
11789 11813
11790 11814
11791 // Create a plain JSObject which materializes the block scope for the specified 11815 // Create a plain JSObject which materializes the block scope for the specified
11792 // block context. 11816 // block context.
11793 static Handle<JSObject> MaterializeBlockScope( 11817 MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeBlockScope(
11794 Isolate* isolate, 11818 Isolate* isolate,
11795 Handle<Context> context) { 11819 Handle<Context> context) {
11796 ASSERT(context->IsBlockContext()); 11820 ASSERT(context->IsBlockContext());
11797 Handle<ScopeInfo> scope_info(ScopeInfo::cast(context->extension())); 11821 Handle<ScopeInfo> scope_info(ScopeInfo::cast(context->extension()));
11798 11822
11799 // Allocate and initialize a JSObject with all the arguments, stack locals 11823 // Allocate and initialize a JSObject with all the arguments, stack locals
11800 // heap locals and extension properties of the debugged function. 11824 // heap locals and extension properties of the debugged function.
11801 Handle<JSObject> block_scope = 11825 Handle<JSObject> block_scope =
11802 isolate->factory()->NewJSObject(isolate->object_function()); 11826 isolate->factory()->NewJSObject(isolate->object_function());
11803 11827
11804 // Fill all context locals. 11828 // Fill all context locals.
11805 if (!ScopeInfo::CopyContextLocalsToScopeObject( 11829 if (!ScopeInfo::CopyContextLocalsToScopeObject(
11806 scope_info, context, block_scope)) { 11830 scope_info, context, block_scope)) {
11807 return Handle<JSObject>(); 11831 return MaybeHandle<JSObject>();
11808 } 11832 }
11809 11833
11810 return block_scope; 11834 return block_scope;
11811 } 11835 }
11812 11836
11813 11837
11814 // Create a plain JSObject which materializes the module scope for the specified 11838 // Create a plain JSObject which materializes the module scope for the specified
11815 // module context. 11839 // module context.
11816 static Handle<JSObject> MaterializeModuleScope( 11840 MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeModuleScope(
11817 Isolate* isolate, 11841 Isolate* isolate,
11818 Handle<Context> context) { 11842 Handle<Context> context) {
11819 ASSERT(context->IsModuleContext()); 11843 ASSERT(context->IsModuleContext());
11820 Handle<ScopeInfo> scope_info(ScopeInfo::cast(context->extension())); 11844 Handle<ScopeInfo> scope_info(ScopeInfo::cast(context->extension()));
11821 11845
11822 // Allocate and initialize a JSObject with all the members of the debugged 11846 // Allocate and initialize a JSObject with all the members of the debugged
11823 // module. 11847 // module.
11824 Handle<JSObject> module_scope = 11848 Handle<JSObject> module_scope =
11825 isolate->factory()->NewJSObject(isolate->object_function()); 11849 isolate->factory()->NewJSObject(isolate->object_function());
11826 11850
11827 // Fill all context locals. 11851 // Fill all context locals.
11828 if (!ScopeInfo::CopyContextLocalsToScopeObject( 11852 if (!ScopeInfo::CopyContextLocalsToScopeObject(
11829 scope_info, context, module_scope)) { 11853 scope_info, context, module_scope)) {
11830 return Handle<JSObject>(); 11854 return MaybeHandle<JSObject>();
11831 } 11855 }
11832 11856
11833 return module_scope; 11857 return module_scope;
11834 } 11858 }
11835 11859
11836 11860
11837 // Iterate over the actual scopes visible from a stack frame or from a closure. 11861 // Iterate over the actual scopes visible from a stack frame or from a closure.
11838 // The iteration proceeds from the innermost visible nested scope outwards. 11862 // The iteration proceeds from the innermost visible nested scope outwards.
11839 // All scopes are backed by an actual context except the local scope, 11863 // All scopes are backed by an actual context except the local scope,
11840 // which is inserted "artificially" in the context chain. 11864 // which is inserted "artificially" in the context chain.
(...skipping 189 matching lines...) Expand 10 before | Expand all | Expand 10 after
12030 return ScopeTypeBlock; 12054 return ScopeTypeBlock;
12031 } 12055 }
12032 if (context_->IsModuleContext()) { 12056 if (context_->IsModuleContext()) {
12033 return ScopeTypeModule; 12057 return ScopeTypeModule;
12034 } 12058 }
12035 ASSERT(context_->IsWithContext()); 12059 ASSERT(context_->IsWithContext());
12036 return ScopeTypeWith; 12060 return ScopeTypeWith;
12037 } 12061 }
12038 12062
12039 // Return the JavaScript object with the content of the current scope. 12063 // Return the JavaScript object with the content of the current scope.
12040 Handle<JSObject> ScopeObject() { 12064 MaybeHandle<JSObject> ScopeObject() {
12041 ASSERT(!failed_); 12065 ASSERT(!failed_);
12042 switch (Type()) { 12066 switch (Type()) {
12043 case ScopeIterator::ScopeTypeGlobal: 12067 case ScopeIterator::ScopeTypeGlobal:
12044 return Handle<JSObject>(CurrentContext()->global_object()); 12068 return Handle<JSObject>(CurrentContext()->global_object());
12045 case ScopeIterator::ScopeTypeLocal: 12069 case ScopeIterator::ScopeTypeLocal:
12046 // Materialize the content of the local scope into a JSObject. 12070 // Materialize the content of the local scope into a JSObject.
12047 ASSERT(nested_scope_chain_.length() == 1); 12071 ASSERT(nested_scope_chain_.length() == 1);
12048 return MaterializeLocalScope(isolate_, frame_, inlined_jsframe_index_); 12072 return MaterializeLocalScope(isolate_, frame_, inlined_jsframe_index_);
12049 case ScopeIterator::ScopeTypeWith: 12073 case ScopeIterator::ScopeTypeWith:
12050 // Return the with object. 12074 // Return the with object.
(...skipping 256 matching lines...) Expand 10 before | Expand all | Expand 10 after
12307 } 12331 }
12308 return *array; 12332 return *array;
12309 } 12333 }
12310 12334
12311 12335
12312 static const int kScopeDetailsTypeIndex = 0; 12336 static const int kScopeDetailsTypeIndex = 0;
12313 static const int kScopeDetailsObjectIndex = 1; 12337 static const int kScopeDetailsObjectIndex = 1;
12314 static const int kScopeDetailsSize = 2; 12338 static const int kScopeDetailsSize = 2;
12315 12339
12316 12340
12317 static Handle<JSObject> MaterializeScopeDetails(Isolate* isolate, 12341 MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeScopeDetails(
12342 Isolate* isolate,
12318 ScopeIterator* it) { 12343 ScopeIterator* it) {
12319 // Calculate the size of the result. 12344 // Calculate the size of the result.
12320 int details_size = kScopeDetailsSize; 12345 int details_size = kScopeDetailsSize;
12321 Handle<FixedArray> details = isolate->factory()->NewFixedArray(details_size); 12346 Handle<FixedArray> details = isolate->factory()->NewFixedArray(details_size);
12322 12347
12323 // Fill in scope details. 12348 // Fill in scope details.
12324 details->set(kScopeDetailsTypeIndex, Smi::FromInt(it->Type())); 12349 details->set(kScopeDetailsTypeIndex, Smi::FromInt(it->Type()));
12325 Handle<JSObject> scope_object = it->ScopeObject(); 12350 Handle<JSObject> scope_object;
12326 RETURN_IF_EMPTY_HANDLE_VALUE(isolate, scope_object, Handle<JSObject>()); 12351 ASSIGN_RETURN_ON_EXCEPTION(
12352 isolate, scope_object, it->ScopeObject(), JSObject);
12327 details->set(kScopeDetailsObjectIndex, *scope_object); 12353 details->set(kScopeDetailsObjectIndex, *scope_object);
12328 12354
12329 return isolate->factory()->NewJSArrayWithElements(details); 12355 return isolate->factory()->NewJSArrayWithElements(details);
12330 } 12356 }
12331 12357
12332 12358
12333 // Return an array with scope details 12359 // Return an array with scope details
12334 // args[0]: number: break id 12360 // args[0]: number: break id
12335 // args[1]: number: frame index 12361 // args[1]: number: frame index
12336 // args[2]: number: inlined frame index 12362 // args[2]: number: inlined frame index
(...skipping 23 matching lines...) Expand all
12360 12386
12361 // Find the requested scope. 12387 // Find the requested scope.
12362 int n = 0; 12388 int n = 0;
12363 ScopeIterator it(isolate, frame, inlined_jsframe_index); 12389 ScopeIterator it(isolate, frame, inlined_jsframe_index);
12364 for (; !it.Done() && n < index; it.Next()) { 12390 for (; !it.Done() && n < index; it.Next()) {
12365 n++; 12391 n++;
12366 } 12392 }
12367 if (it.Done()) { 12393 if (it.Done()) {
12368 return isolate->heap()->undefined_value(); 12394 return isolate->heap()->undefined_value();
12369 } 12395 }
12370 Handle<JSObject> details = MaterializeScopeDetails(isolate, &it); 12396 Handle<JSObject> details;
12371 RETURN_IF_EMPTY_HANDLE(isolate, details); 12397 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
12398 isolate, details, MaterializeScopeDetails(isolate, &it));
12372 return *details; 12399 return *details;
12373 } 12400 }
12374 12401
12375 12402
12376 // Return an array of scope details 12403 // Return an array of scope details
12377 // args[0]: number: break id 12404 // args[0]: number: break id
12378 // args[1]: number: frame index 12405 // args[1]: number: frame index
12379 // args[2]: number: inlined frame index 12406 // args[2]: number: inlined frame index
12380 // args[3]: boolean: ignore nested scopes 12407 // args[3]: boolean: ignore nested scopes
12381 // 12408 //
(...skipping 20 matching lines...) Expand all
12402 } 12429 }
12403 12430
12404 // Get the frame where the debugging is performed. 12431 // Get the frame where the debugging is performed.
12405 StackFrame::Id id = UnwrapFrameId(wrapped_id); 12432 StackFrame::Id id = UnwrapFrameId(wrapped_id);
12406 JavaScriptFrameIterator frame_it(isolate, id); 12433 JavaScriptFrameIterator frame_it(isolate, id);
12407 JavaScriptFrame* frame = frame_it.frame(); 12434 JavaScriptFrame* frame = frame_it.frame();
12408 12435
12409 List<Handle<JSObject> > result(4); 12436 List<Handle<JSObject> > result(4);
12410 ScopeIterator it(isolate, frame, inlined_jsframe_index, ignore_nested_scopes); 12437 ScopeIterator it(isolate, frame, inlined_jsframe_index, ignore_nested_scopes);
12411 for (; !it.Done(); it.Next()) { 12438 for (; !it.Done(); it.Next()) {
12412 Handle<JSObject> details = MaterializeScopeDetails(isolate, &it); 12439 Handle<JSObject> details;
12413 RETURN_IF_EMPTY_HANDLE(isolate, details); 12440 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
12441 isolate, details, MaterializeScopeDetails(isolate, &it));
12414 result.Add(details); 12442 result.Add(details);
12415 } 12443 }
12416 12444
12417 Handle<FixedArray> array = isolate->factory()->NewFixedArray(result.length()); 12445 Handle<FixedArray> array = isolate->factory()->NewFixedArray(result.length());
12418 for (int i = 0; i < result.length(); ++i) { 12446 for (int i = 0; i < result.length(); ++i) {
12419 array->set(i, *result[i]); 12447 array->set(i, *result[i]);
12420 } 12448 }
12421 return *isolate->factory()->NewJSArrayWithElements(array); 12449 return *isolate->factory()->NewJSArrayWithElements(array);
12422 } 12450 }
12423 12451
(...skipping 26 matching lines...) Expand all
12450 // Find the requested scope. 12478 // Find the requested scope.
12451 int n = 0; 12479 int n = 0;
12452 ScopeIterator it(isolate, fun); 12480 ScopeIterator it(isolate, fun);
12453 for (; !it.Done() && n < index; it.Next()) { 12481 for (; !it.Done() && n < index; it.Next()) {
12454 n++; 12482 n++;
12455 } 12483 }
12456 if (it.Done()) { 12484 if (it.Done()) {
12457 return isolate->heap()->undefined_value(); 12485 return isolate->heap()->undefined_value();
12458 } 12486 }
12459 12487
12460 Handle<JSObject> details = MaterializeScopeDetails(isolate, &it); 12488 Handle<JSObject> details;
12489 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
12490 isolate, details, MaterializeScopeDetails(isolate, &it));
12461 RETURN_IF_EMPTY_HANDLE(isolate, details); 12491 RETURN_IF_EMPTY_HANDLE(isolate, details);
12462 return *details; 12492 return *details;
12463 } 12493 }
12464 12494
12465 12495
12466 static bool SetScopeVariableValue(ScopeIterator* it, int index, 12496 static bool SetScopeVariableValue(ScopeIterator* it, int index,
12467 Handle<String> variable_name, 12497 Handle<String> variable_name,
12468 Handle<Object> new_value) { 12498 Handle<Object> new_value) {
12469 for (int n = 0; !it->Done() && n < index; it->Next()) { 12499 for (int n = 0; !it->Done() && n < index; it->Next()) {
12470 n++; 12500 n++;
(...skipping 359 matching lines...) Expand 10 before | Expand all | Expand 10 after
12830 RUNTIME_FUNCTION(MaybeObject*, Runtime_ClearStepping) { 12860 RUNTIME_FUNCTION(MaybeObject*, Runtime_ClearStepping) {
12831 HandleScope scope(isolate); 12861 HandleScope scope(isolate);
12832 ASSERT(args.length() == 0); 12862 ASSERT(args.length() == 0);
12833 isolate->debug()->ClearStepping(); 12863 isolate->debug()->ClearStepping();
12834 return isolate->heap()->undefined_value(); 12864 return isolate->heap()->undefined_value();
12835 } 12865 }
12836 12866
12837 12867
12838 // Helper function to find or create the arguments object for 12868 // Helper function to find or create the arguments object for
12839 // Runtime_DebugEvaluate. 12869 // Runtime_DebugEvaluate.
12840 static Handle<JSObject> MaterializeArgumentsObject( 12870 MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeArgumentsObject(
12841 Isolate* isolate, 12871 Isolate* isolate,
12842 Handle<JSObject> target, 12872 Handle<JSObject> target,
12843 Handle<JSFunction> function) { 12873 Handle<JSFunction> function) {
12844 // Do not materialize the arguments object for eval or top-level code. 12874 // Do not materialize the arguments object for eval or top-level code.
12845 // Skip if "arguments" is already taken. 12875 // Skip if "arguments" is already taken.
12846 if (!function->shared()->is_function() || 12876 if (!function->shared()->is_function() ||
12847 JSReceiver::HasLocalProperty(target, 12877 JSReceiver::HasLocalProperty(target,
12848 isolate->factory()->arguments_string())) { 12878 isolate->factory()->arguments_string())) {
12849 return target; 12879 return target;
12850 } 12880 }
12851 12881
12852 // FunctionGetArguments can't throw an exception. 12882 // FunctionGetArguments can't throw an exception.
12853 Handle<JSObject> arguments = Handle<JSObject>::cast( 12883 Handle<JSObject> arguments = Handle<JSObject>::cast(
12854 Accessors::FunctionGetArguments(function)); 12884 Accessors::FunctionGetArguments(function));
12855 Runtime::SetObjectProperty(isolate, target, 12885 Handle<String> arguments_str = isolate->factory()->arguments_string();
12856 isolate->factory()->arguments_string(), 12886 RETURN_ON_EXCEPTION(
12857 arguments, 12887 isolate,
12858 ::NONE, 12888 Runtime::SetObjectProperty(
12859 SLOPPY); 12889 isolate, target, arguments_str, arguments, ::NONE, SLOPPY),
12890 JSObject);
12860 return target; 12891 return target;
12861 } 12892 }
12862 12893
12863 12894
12864 // Compile and evaluate source for the given context. 12895 // Compile and evaluate source for the given context.
12865 static MaybeObject* DebugEvaluate(Isolate* isolate, 12896 static MaybeObject* DebugEvaluate(Isolate* isolate,
12866 Handle<Context> context, 12897 Handle<Context> context,
12867 Handle<Object> context_extension, 12898 Handle<Object> context_extension,
12868 Handle<Object> receiver, 12899 Handle<Object> receiver,
12869 Handle<String> source) { 12900 Handle<String> source) {
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after
12939 isolate->set_context(*(save->context())); 12970 isolate->set_context(*(save->context()));
12940 12971
12941 // Evaluate on the context of the frame. 12972 // Evaluate on the context of the frame.
12942 Handle<Context> context(Context::cast(frame->context())); 12973 Handle<Context> context(Context::cast(frame->context()));
12943 ASSERT(!context.is_null()); 12974 ASSERT(!context.is_null());
12944 12975
12945 // Materialize stack locals and the arguments object. 12976 // Materialize stack locals and the arguments object.
12946 Handle<JSObject> materialized = 12977 Handle<JSObject> materialized =
12947 isolate->factory()->NewJSObject(isolate->object_function()); 12978 isolate->factory()->NewJSObject(isolate->object_function());
12948 12979
12949 materialized = MaterializeStackLocalsWithFrameInspector( 12980 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
12950 isolate, materialized, function, &frame_inspector); 12981 isolate, materialized,
12951 RETURN_IF_EMPTY_HANDLE(isolate, materialized); 12982 MaterializeStackLocalsWithFrameInspector(
12983 isolate, materialized, function, &frame_inspector));
12952 12984
12953 materialized = MaterializeArgumentsObject(isolate, materialized, function); 12985 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
12954 RETURN_IF_EMPTY_HANDLE(isolate, materialized); 12986 isolate, materialized,
12987 MaterializeArgumentsObject(isolate, materialized, function));
12955 12988
12956 // Add the materialized object in a with-scope to shadow the stack locals. 12989 // Add the materialized object in a with-scope to shadow the stack locals.
12957 context = isolate->factory()->NewWithContext(function, context, materialized); 12990 context = isolate->factory()->NewWithContext(function, context, materialized);
12958 12991
12959 Handle<Object> receiver(frame->receiver(), isolate); 12992 Handle<Object> receiver(frame->receiver(), isolate);
12960 Object* evaluate_result_object; 12993 Object* evaluate_result_object;
12961 { MaybeObject* maybe_result = 12994 { MaybeObject* maybe_result =
12962 DebugEvaluate(isolate, context, context_extension, receiver, source); 12995 DebugEvaluate(isolate, context, context_extension, receiver, source);
12963 if (!maybe_result->ToObject(&evaluate_result_object)) return maybe_result; 12996 if (!maybe_result->ToObject(&evaluate_result_object)) return maybe_result;
12964 } 12997 }
(...skipping 2260 matching lines...) Expand 10 before | Expand all | Expand 10 after
15225 } 15258 }
15226 } 15259 }
15227 15260
15228 15261
15229 void Runtime::OutOfMemory() { 15262 void Runtime::OutOfMemory() {
15230 Heap::FatalProcessOutOfMemory("CALL_AND_RETRY_LAST", true); 15263 Heap::FatalProcessOutOfMemory("CALL_AND_RETRY_LAST", true);
15231 UNREACHABLE(); 15264 UNREACHABLE();
15232 } 15265 }
15233 15266
15234 } } // namespace v8::internal 15267 } } // namespace v8::internal
OLDNEW
« no previous file with comments | « src/runtime.h ('k') | src/scopeinfo.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698