OLD | NEW |
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "src/v8.h" | 5 #include "src/v8.h" |
6 | 6 |
7 #if V8_TARGET_ARCH_MIPS | 7 #if V8_TARGET_ARCH_MIPS |
8 | 8 |
9 #include "src/codegen.h" | 9 #include "src/codegen.h" |
10 #include "src/ic-inl.h" | 10 #include "src/ic-inl.h" |
(...skipping 262 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
273 Register scratch, Label* miss) { | 273 Register scratch, Label* miss) { |
274 Handle<Cell> cell = JSGlobalObject::EnsurePropertyCell(global, name); | 274 Handle<Cell> cell = JSGlobalObject::EnsurePropertyCell(global, name); |
275 DCHECK(cell->value()->IsTheHole()); | 275 DCHECK(cell->value()->IsTheHole()); |
276 __ li(scratch, Operand(cell)); | 276 __ li(scratch, Operand(cell)); |
277 __ lw(scratch, FieldMemOperand(scratch, Cell::kValueOffset)); | 277 __ lw(scratch, FieldMemOperand(scratch, Cell::kValueOffset)); |
278 __ LoadRoot(at, Heap::kTheHoleValueRootIndex); | 278 __ LoadRoot(at, Heap::kTheHoleValueRootIndex); |
279 __ Branch(miss, ne, scratch, Operand(at)); | 279 __ Branch(miss, ne, scratch, Operand(at)); |
280 } | 280 } |
281 | 281 |
282 | 282 |
| 283 static void PushInterceptorArguments(MacroAssembler* masm, |
| 284 Register receiver, |
| 285 Register holder, |
| 286 Register name, |
| 287 Handle<JSObject> holder_obj) { |
| 288 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsNameIndex == 0); |
| 289 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsInfoIndex == 1); |
| 290 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsThisIndex == 2); |
| 291 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsHolderIndex == 3); |
| 292 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsLength == 4); |
| 293 __ push(name); |
| 294 Handle<InterceptorInfo> interceptor(holder_obj->GetNamedInterceptor()); |
| 295 DCHECK(!masm->isolate()->heap()->InNewSpace(*interceptor)); |
| 296 Register scratch = name; |
| 297 __ li(scratch, Operand(interceptor)); |
| 298 __ Push(scratch, receiver, holder); |
| 299 } |
| 300 |
| 301 |
| 302 static void CompileCallLoadPropertyWithInterceptor( |
| 303 MacroAssembler* masm, |
| 304 Register receiver, |
| 305 Register holder, |
| 306 Register name, |
| 307 Handle<JSObject> holder_obj, |
| 308 IC::UtilityId id) { |
| 309 PushInterceptorArguments(masm, receiver, holder, name, holder_obj); |
| 310 __ CallExternalReference(ExternalReference(IC_Utility(id), masm->isolate()), |
| 311 NamedLoadHandlerCompiler::kInterceptorArgsLength); |
| 312 } |
| 313 |
| 314 |
| 315 // Generate call to api function. |
| 316 void PropertyHandlerCompiler::GenerateFastApiCall( |
| 317 MacroAssembler* masm, const CallOptimization& optimization, |
| 318 Handle<Map> receiver_map, Register receiver, Register scratch_in, |
| 319 bool is_store, int argc, Register* values) { |
| 320 DCHECK(!receiver.is(scratch_in)); |
| 321 // Preparing to push, adjust sp. |
| 322 __ Subu(sp, sp, Operand((argc + 1) * kPointerSize)); |
| 323 __ sw(receiver, MemOperand(sp, argc * kPointerSize)); // Push receiver. |
| 324 // Write the arguments to stack frame. |
| 325 for (int i = 0; i < argc; i++) { |
| 326 Register arg = values[argc-1-i]; |
| 327 DCHECK(!receiver.is(arg)); |
| 328 DCHECK(!scratch_in.is(arg)); |
| 329 __ sw(arg, MemOperand(sp, (argc-1-i) * kPointerSize)); // Push arg. |
| 330 } |
| 331 DCHECK(optimization.is_simple_api_call()); |
| 332 |
| 333 // Abi for CallApiFunctionStub. |
| 334 Register callee = a0; |
| 335 Register call_data = t0; |
| 336 Register holder = a2; |
| 337 Register api_function_address = a1; |
| 338 |
| 339 // Put holder in place. |
| 340 CallOptimization::HolderLookup holder_lookup; |
| 341 Handle<JSObject> api_holder = optimization.LookupHolderOfExpectedType( |
| 342 receiver_map, |
| 343 &holder_lookup); |
| 344 switch (holder_lookup) { |
| 345 case CallOptimization::kHolderIsReceiver: |
| 346 __ Move(holder, receiver); |
| 347 break; |
| 348 case CallOptimization::kHolderFound: |
| 349 __ li(holder, api_holder); |
| 350 break; |
| 351 case CallOptimization::kHolderNotFound: |
| 352 UNREACHABLE(); |
| 353 break; |
| 354 } |
| 355 |
| 356 Isolate* isolate = masm->isolate(); |
| 357 Handle<JSFunction> function = optimization.constant_function(); |
| 358 Handle<CallHandlerInfo> api_call_info = optimization.api_call_info(); |
| 359 Handle<Object> call_data_obj(api_call_info->data(), isolate); |
| 360 |
| 361 // Put callee in place. |
| 362 __ li(callee, function); |
| 363 |
| 364 bool call_data_undefined = false; |
| 365 // Put call_data in place. |
| 366 if (isolate->heap()->InNewSpace(*call_data_obj)) { |
| 367 __ li(call_data, api_call_info); |
| 368 __ lw(call_data, FieldMemOperand(call_data, CallHandlerInfo::kDataOffset)); |
| 369 } else if (call_data_obj->IsUndefined()) { |
| 370 call_data_undefined = true; |
| 371 __ LoadRoot(call_data, Heap::kUndefinedValueRootIndex); |
| 372 } else { |
| 373 __ li(call_data, call_data_obj); |
| 374 } |
| 375 // Put api_function_address in place. |
| 376 Address function_address = v8::ToCData<Address>(api_call_info->callback()); |
| 377 ApiFunction fun(function_address); |
| 378 ExternalReference::Type type = ExternalReference::DIRECT_API_CALL; |
| 379 ExternalReference ref = ExternalReference(&fun, type, masm->isolate()); |
| 380 __ li(api_function_address, Operand(ref)); |
| 381 |
| 382 // Jump to stub. |
| 383 CallApiFunctionStub stub(isolate, is_store, call_data_undefined, argc); |
| 384 __ TailCallStub(&stub); |
| 385 } |
| 386 |
| 387 |
| 388 void PropertyAccessCompiler::GenerateTailCall(MacroAssembler* masm, |
| 389 Handle<Code> code) { |
| 390 __ Jump(code, RelocInfo::CODE_TARGET); |
| 391 } |
| 392 |
| 393 |
| 394 #undef __ |
| 395 #define __ ACCESS_MASM(masm()) |
| 396 |
| 397 |
| 398 void NamedStoreHandlerCompiler::GenerateRestoreName(Label* label, |
| 399 Handle<Name> name) { |
| 400 if (!label->is_unused()) { |
| 401 __ bind(label); |
| 402 __ li(this->name(), Operand(name)); |
| 403 } |
| 404 } |
| 405 |
| 406 |
283 // Generate StoreTransition code, value is passed in a0 register. | 407 // Generate StoreTransition code, value is passed in a0 register. |
284 // After executing generated code, the receiver_reg and name_reg | 408 // After executing generated code, the receiver_reg and name_reg |
285 // may be clobbered. | 409 // may be clobbered. |
286 void NamedStoreHandlerCompiler::GenerateStoreTransition( | 410 void NamedStoreHandlerCompiler::GenerateStoreTransition( |
287 MacroAssembler* masm, LookupResult* lookup, Handle<Map> transition, | 411 Handle<Map> transition, Handle<Name> name, Register receiver_reg, |
288 Handle<Name> name, Register receiver_reg, Register storage_reg, | 412 Register storage_reg, Register value_reg, Register scratch1, |
289 Register value_reg, Register scratch1, Register scratch2, Register scratch3, | 413 Register scratch2, Register scratch3, Label* miss_label, Label* slow) { |
290 Label* miss_label, Label* slow) { | |
291 // a0 : value. | 414 // a0 : value. |
292 Label exit; | 415 Label exit; |
293 | 416 |
294 int descriptor = transition->LastAdded(); | 417 int descriptor = transition->LastAdded(); |
295 DescriptorArray* descriptors = transition->instance_descriptors(); | 418 DescriptorArray* descriptors = transition->instance_descriptors(); |
296 PropertyDetails details = descriptors->GetDetails(descriptor); | 419 PropertyDetails details = descriptors->GetDetails(descriptor); |
297 Representation representation = details.representation(); | 420 Representation representation = details.representation(); |
298 DCHECK(!representation.IsNone()); | 421 DCHECK(!representation.IsNone()); |
299 | 422 |
300 if (details.type() == CONSTANT) { | 423 if (details.type() == CONSTANT) { |
301 Handle<Object> constant(descriptors->GetValue(descriptor), masm->isolate()); | 424 Handle<Object> constant(descriptors->GetValue(descriptor), isolate()); |
302 __ li(scratch1, constant); | 425 __ li(scratch1, constant); |
303 __ Branch(miss_label, ne, value_reg, Operand(scratch1)); | 426 __ Branch(miss_label, ne, value_reg, Operand(scratch1)); |
304 } else if (representation.IsSmi()) { | 427 } else if (representation.IsSmi()) { |
305 __ JumpIfNotSmi(value_reg, miss_label); | 428 __ JumpIfNotSmi(value_reg, miss_label); |
306 } else if (representation.IsHeapObject()) { | 429 } else if (representation.IsHeapObject()) { |
307 __ JumpIfSmi(value_reg, miss_label); | 430 __ JumpIfSmi(value_reg, miss_label); |
308 HeapType* field_type = descriptors->GetFieldType(descriptor); | 431 HeapType* field_type = descriptors->GetFieldType(descriptor); |
309 HeapType::Iterator<Map> it = field_type->Classes(); | 432 HeapType::Iterator<Map> it = field_type->Classes(); |
310 Handle<Map> current; | 433 Handle<Map> current; |
311 if (!it.Done()) { | 434 if (!it.Done()) { |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
350 // Perform map transition for the receiver if necessary. | 473 // Perform map transition for the receiver if necessary. |
351 if (details.type() == FIELD && | 474 if (details.type() == FIELD && |
352 Map::cast(transition->GetBackPointer())->unused_property_fields() == 0) { | 475 Map::cast(transition->GetBackPointer())->unused_property_fields() == 0) { |
353 // The properties must be extended before we can store the value. | 476 // The properties must be extended before we can store the value. |
354 // We jump to a runtime call that extends the properties array. | 477 // We jump to a runtime call that extends the properties array. |
355 __ push(receiver_reg); | 478 __ push(receiver_reg); |
356 __ li(a2, Operand(transition)); | 479 __ li(a2, Operand(transition)); |
357 __ Push(a2, a0); | 480 __ Push(a2, a0); |
358 __ TailCallExternalReference( | 481 __ TailCallExternalReference( |
359 ExternalReference(IC_Utility(IC::kSharedStoreIC_ExtendStorage), | 482 ExternalReference(IC_Utility(IC::kSharedStoreIC_ExtendStorage), |
360 masm->isolate()), | 483 isolate()), |
361 3, 1); | 484 3, 1); |
362 return; | 485 return; |
363 } | 486 } |
364 | 487 |
365 // Update the map of the object. | 488 // Update the map of the object. |
366 __ li(scratch1, Operand(transition)); | 489 __ li(scratch1, Operand(transition)); |
367 __ sw(scratch1, FieldMemOperand(receiver_reg, HeapObject::kMapOffset)); | 490 __ sw(scratch1, FieldMemOperand(receiver_reg, HeapObject::kMapOffset)); |
368 | 491 |
369 // Update the write barrier for the map field. | 492 // Update the write barrier for the map field. |
370 __ RecordWriteField(receiver_reg, | 493 __ RecordWriteField(receiver_reg, |
(...skipping 80 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
451 __ Ret(USE_DELAY_SLOT); | 574 __ Ret(USE_DELAY_SLOT); |
452 __ mov(v0, a0); | 575 __ mov(v0, a0); |
453 } | 576 } |
454 | 577 |
455 | 578 |
456 // Generate StoreField code, value is passed in a0 register. | 579 // Generate StoreField code, value is passed in a0 register. |
457 // When leaving generated code after success, the receiver_reg and name_reg | 580 // When leaving generated code after success, the receiver_reg and name_reg |
458 // may be clobbered. Upon branch to miss_label, the receiver and name | 581 // may be clobbered. Upon branch to miss_label, the receiver and name |
459 // registers have their original values. | 582 // registers have their original values. |
460 void NamedStoreHandlerCompiler::GenerateStoreField( | 583 void NamedStoreHandlerCompiler::GenerateStoreField( |
461 MacroAssembler* masm, Handle<JSObject> object, LookupResult* lookup, | 584 Handle<JSObject> object, LookupResult* lookup, Register receiver_reg, |
462 Register receiver_reg, Register name_reg, Register value_reg, | 585 Register name_reg, Register value_reg, Register scratch1, Register scratch2, |
463 Register scratch1, Register scratch2, Label* miss_label) { | 586 Label* miss_label) { |
464 // a0 : value | 587 // a0 : value |
465 Label exit; | 588 Label exit; |
466 | 589 |
467 // Stub never generated for non-global objects that require access | 590 // Stub never generated for objects that require access checks. |
468 // checks. | 591 DCHECK(!object->IsAccessCheckNeeded()); |
469 DCHECK(object->IsJSGlobalProxy() || !object->IsAccessCheckNeeded()); | 592 DCHECK(!object->IsJSGlobalProxy()); |
470 | 593 |
471 FieldIndex index = lookup->GetFieldIndex(); | 594 FieldIndex index = lookup->GetFieldIndex(); |
472 | 595 |
473 Representation representation = lookup->representation(); | 596 Representation representation = lookup->representation(); |
474 DCHECK(!representation.IsNone()); | 597 DCHECK(!representation.IsNone()); |
475 if (representation.IsSmi()) { | 598 if (representation.IsSmi()) { |
476 __ JumpIfNotSmi(value_reg, miss_label); | 599 __ JumpIfNotSmi(value_reg, miss_label); |
477 } else if (representation.IsHeapObject()) { | 600 } else if (representation.IsHeapObject()) { |
478 __ JumpIfSmi(value_reg, miss_label); | 601 __ JumpIfSmi(value_reg, miss_label); |
479 HeapType* field_type = lookup->GetFieldType(); | 602 HeapType* field_type = lookup->GetFieldType(); |
(...skipping 95 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
575 } | 698 } |
576 | 699 |
577 // Return the value (register v0). | 700 // Return the value (register v0). |
578 DCHECK(value_reg.is(a0)); | 701 DCHECK(value_reg.is(a0)); |
579 __ bind(&exit); | 702 __ bind(&exit); |
580 __ Ret(USE_DELAY_SLOT); | 703 __ Ret(USE_DELAY_SLOT); |
581 __ mov(v0, a0); | 704 __ mov(v0, a0); |
582 } | 705 } |
583 | 706 |
584 | 707 |
585 void NamedStoreHandlerCompiler::GenerateRestoreName(MacroAssembler* masm, | |
586 Label* label, | |
587 Handle<Name> name) { | |
588 if (!label->is_unused()) { | |
589 __ bind(label); | |
590 __ li(this->name(), Operand(name)); | |
591 } | |
592 } | |
593 | |
594 | |
595 static void PushInterceptorArguments(MacroAssembler* masm, | |
596 Register receiver, | |
597 Register holder, | |
598 Register name, | |
599 Handle<JSObject> holder_obj) { | |
600 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsNameIndex == 0); | |
601 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsInfoIndex == 1); | |
602 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsThisIndex == 2); | |
603 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsHolderIndex == 3); | |
604 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsLength == 4); | |
605 __ push(name); | |
606 Handle<InterceptorInfo> interceptor(holder_obj->GetNamedInterceptor()); | |
607 DCHECK(!masm->isolate()->heap()->InNewSpace(*interceptor)); | |
608 Register scratch = name; | |
609 __ li(scratch, Operand(interceptor)); | |
610 __ Push(scratch, receiver, holder); | |
611 } | |
612 | |
613 | |
614 static void CompileCallLoadPropertyWithInterceptor( | |
615 MacroAssembler* masm, | |
616 Register receiver, | |
617 Register holder, | |
618 Register name, | |
619 Handle<JSObject> holder_obj, | |
620 IC::UtilityId id) { | |
621 PushInterceptorArguments(masm, receiver, holder, name, holder_obj); | |
622 __ CallExternalReference(ExternalReference(IC_Utility(id), masm->isolate()), | |
623 NamedLoadHandlerCompiler::kInterceptorArgsLength); | |
624 } | |
625 | |
626 | |
627 // Generate call to api function. | |
628 void PropertyHandlerCompiler::GenerateFastApiCall( | |
629 MacroAssembler* masm, const CallOptimization& optimization, | |
630 Handle<Map> receiver_map, Register receiver, Register scratch_in, | |
631 bool is_store, int argc, Register* values) { | |
632 DCHECK(!receiver.is(scratch_in)); | |
633 // Preparing to push, adjust sp. | |
634 __ Subu(sp, sp, Operand((argc + 1) * kPointerSize)); | |
635 __ sw(receiver, MemOperand(sp, argc * kPointerSize)); // Push receiver. | |
636 // Write the arguments to stack frame. | |
637 for (int i = 0; i < argc; i++) { | |
638 Register arg = values[argc-1-i]; | |
639 DCHECK(!receiver.is(arg)); | |
640 DCHECK(!scratch_in.is(arg)); | |
641 __ sw(arg, MemOperand(sp, (argc-1-i) * kPointerSize)); // Push arg. | |
642 } | |
643 DCHECK(optimization.is_simple_api_call()); | |
644 | |
645 // Abi for CallApiFunctionStub. | |
646 Register callee = a0; | |
647 Register call_data = t0; | |
648 Register holder = a2; | |
649 Register api_function_address = a1; | |
650 | |
651 // Put holder in place. | |
652 CallOptimization::HolderLookup holder_lookup; | |
653 Handle<JSObject> api_holder = optimization.LookupHolderOfExpectedType( | |
654 receiver_map, | |
655 &holder_lookup); | |
656 switch (holder_lookup) { | |
657 case CallOptimization::kHolderIsReceiver: | |
658 __ Move(holder, receiver); | |
659 break; | |
660 case CallOptimization::kHolderFound: | |
661 __ li(holder, api_holder); | |
662 break; | |
663 case CallOptimization::kHolderNotFound: | |
664 UNREACHABLE(); | |
665 break; | |
666 } | |
667 | |
668 Isolate* isolate = masm->isolate(); | |
669 Handle<JSFunction> function = optimization.constant_function(); | |
670 Handle<CallHandlerInfo> api_call_info = optimization.api_call_info(); | |
671 Handle<Object> call_data_obj(api_call_info->data(), isolate); | |
672 | |
673 // Put callee in place. | |
674 __ li(callee, function); | |
675 | |
676 bool call_data_undefined = false; | |
677 // Put call_data in place. | |
678 if (isolate->heap()->InNewSpace(*call_data_obj)) { | |
679 __ li(call_data, api_call_info); | |
680 __ lw(call_data, FieldMemOperand(call_data, CallHandlerInfo::kDataOffset)); | |
681 } else if (call_data_obj->IsUndefined()) { | |
682 call_data_undefined = true; | |
683 __ LoadRoot(call_data, Heap::kUndefinedValueRootIndex); | |
684 } else { | |
685 __ li(call_data, call_data_obj); | |
686 } | |
687 // Put api_function_address in place. | |
688 Address function_address = v8::ToCData<Address>(api_call_info->callback()); | |
689 ApiFunction fun(function_address); | |
690 ExternalReference::Type type = ExternalReference::DIRECT_API_CALL; | |
691 ExternalReference ref = | |
692 ExternalReference(&fun, | |
693 type, | |
694 masm->isolate()); | |
695 __ li(api_function_address, Operand(ref)); | |
696 | |
697 // Jump to stub. | |
698 CallApiFunctionStub stub(isolate, is_store, call_data_undefined, argc); | |
699 __ TailCallStub(&stub); | |
700 } | |
701 | |
702 | |
703 void PropertyAccessCompiler::GenerateTailCall(MacroAssembler* masm, | |
704 Handle<Code> code) { | |
705 __ Jump(code, RelocInfo::CODE_TARGET); | |
706 } | |
707 | |
708 | |
709 #undef __ | |
710 #define __ ACCESS_MASM(masm()) | |
711 | |
712 | |
713 Register PropertyHandlerCompiler::CheckPrototypes( | 708 Register PropertyHandlerCompiler::CheckPrototypes( |
714 Register object_reg, Register holder_reg, Register scratch1, | 709 Register object_reg, Register holder_reg, Register scratch1, |
715 Register scratch2, Handle<Name> name, Label* miss, | 710 Register scratch2, Handle<Name> name, Label* miss, |
716 PrototypeCheckType check) { | 711 PrototypeCheckType check) { |
717 Handle<Map> receiver_map(IC::TypeToMap(*type(), isolate())); | 712 Handle<Map> receiver_map(IC::TypeToMap(*type(), isolate())); |
718 | 713 |
719 // Make sure there's no overlap between holder and object registers. | 714 // Make sure there's no overlap between holder and object registers. |
720 DCHECK(!scratch1.is(object_reg) && !scratch1.is(holder_reg)); | 715 DCHECK(!scratch1.is(object_reg) && !scratch1.is(holder_reg)); |
721 DCHECK(!scratch2.is(object_reg) && !scratch2.is(holder_reg) | 716 DCHECK(!scratch2.is(object_reg) && !scratch2.is(holder_reg) |
722 && !scratch2.is(scratch1)); | 717 && !scratch2.is(scratch1)); |
(...skipping 105 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
828 TailCallBuiltin(masm(), MissBuiltin(kind())); | 823 TailCallBuiltin(masm(), MissBuiltin(kind())); |
829 __ bind(&success); | 824 __ bind(&success); |
830 } | 825 } |
831 } | 826 } |
832 | 827 |
833 | 828 |
834 void NamedStoreHandlerCompiler::FrontendFooter(Handle<Name> name, Label* miss) { | 829 void NamedStoreHandlerCompiler::FrontendFooter(Handle<Name> name, Label* miss) { |
835 if (!miss->is_unused()) { | 830 if (!miss->is_unused()) { |
836 Label success; | 831 Label success; |
837 __ Branch(&success); | 832 __ Branch(&success); |
838 GenerateRestoreName(masm(), miss, name); | 833 GenerateRestoreName(miss, name); |
839 TailCallBuiltin(masm(), MissBuiltin(kind())); | 834 TailCallBuiltin(masm(), MissBuiltin(kind())); |
840 __ bind(&success); | 835 __ bind(&success); |
841 } | 836 } |
842 } | 837 } |
843 | 838 |
844 | 839 |
845 Register NamedLoadHandlerCompiler::CallbackFrontend(Register object_reg, | 840 Register NamedLoadHandlerCompiler::CallbackFrontend(Register object_reg, |
846 Handle<Name> name, | 841 Handle<Name> name, |
847 Handle<Object> callback) { | 842 Handle<Object> callback) { |
848 Label miss; | 843 Label miss; |
(...skipping 415 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1264 __ bind(&miss); | 1259 __ bind(&miss); |
1265 TailCallBuiltin(masm(), MissBuiltin(kind())); | 1260 TailCallBuiltin(masm(), MissBuiltin(kind())); |
1266 | 1261 |
1267 // Return the generated code. | 1262 // Return the generated code. |
1268 InlineCacheState state = | 1263 InlineCacheState state = |
1269 number_of_handled_maps > 1 ? POLYMORPHIC : MONOMORPHIC; | 1264 number_of_handled_maps > 1 ? POLYMORPHIC : MONOMORPHIC; |
1270 return GetCode(kind(), type, name, state); | 1265 return GetCode(kind(), type, name, state); |
1271 } | 1266 } |
1272 | 1267 |
1273 | 1268 |
1274 void NamedStoreHandlerCompiler::GenerateStoreArrayLength() { | |
1275 // Prepare tail call to StoreIC_ArrayLength. | |
1276 __ Push(receiver(), value()); | |
1277 | |
1278 ExternalReference ref = | |
1279 ExternalReference(IC_Utility(IC::kStoreIC_ArrayLength), | |
1280 masm()->isolate()); | |
1281 __ TailCallExternalReference(ref, 2, 1); | |
1282 } | |
1283 | |
1284 | |
1285 Handle<Code> PropertyICCompiler::CompileKeyedStorePolymorphic( | 1269 Handle<Code> PropertyICCompiler::CompileKeyedStorePolymorphic( |
1286 MapHandleList* receiver_maps, CodeHandleList* handler_stubs, | 1270 MapHandleList* receiver_maps, CodeHandleList* handler_stubs, |
1287 MapHandleList* transitioned_maps) { | 1271 MapHandleList* transitioned_maps) { |
1288 Label miss; | 1272 Label miss; |
1289 __ JumpIfSmi(receiver(), &miss); | 1273 __ JumpIfSmi(receiver(), &miss); |
1290 | 1274 |
1291 int receiver_count = receiver_maps->length(); | 1275 int receiver_count = receiver_maps->length(); |
1292 __ lw(scratch1(), FieldMemOperand(receiver(), HeapObject::kMapOffset)); | 1276 __ lw(scratch1(), FieldMemOperand(receiver(), HeapObject::kMapOffset)); |
1293 for (int i = 0; i < receiver_count; ++i) { | 1277 for (int i = 0; i < receiver_count; ++i) { |
1294 if (transitioned_maps->at(i).is_null()) { | 1278 if (transitioned_maps->at(i).is_null()) { |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1343 | 1327 |
1344 TailCallBuiltin(masm, Builtins::kKeyedLoadIC_Miss); | 1328 TailCallBuiltin(masm, Builtins::kKeyedLoadIC_Miss); |
1345 } | 1329 } |
1346 | 1330 |
1347 | 1331 |
1348 #undef __ | 1332 #undef __ |
1349 | 1333 |
1350 } } // namespace v8::internal | 1334 } } // namespace v8::internal |
1351 | 1335 |
1352 #endif // V8_TARGET_ARCH_MIPS | 1336 #endif // V8_TARGET_ARCH_MIPS |
OLD | NEW |