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_ARM | 7 #if V8_TARGET_ARCH_ARM |
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 275 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
286 Handle<Cell> cell = JSGlobalObject::EnsurePropertyCell(global, name); | 286 Handle<Cell> cell = JSGlobalObject::EnsurePropertyCell(global, name); |
287 ASSERT(cell->value()->IsTheHole()); | 287 ASSERT(cell->value()->IsTheHole()); |
288 __ mov(scratch, Operand(cell)); | 288 __ mov(scratch, Operand(cell)); |
289 __ ldr(scratch, FieldMemOperand(scratch, Cell::kValueOffset)); | 289 __ ldr(scratch, FieldMemOperand(scratch, Cell::kValueOffset)); |
290 __ LoadRoot(ip, Heap::kTheHoleValueRootIndex); | 290 __ LoadRoot(ip, Heap::kTheHoleValueRootIndex); |
291 __ cmp(scratch, ip); | 291 __ cmp(scratch, ip); |
292 __ b(ne, miss); | 292 __ b(ne, miss); |
293 } | 293 } |
294 | 294 |
295 | 295 |
| 296 static void PushInterceptorArguments(MacroAssembler* masm, Register receiver, |
| 297 Register holder, Register name, |
| 298 Handle<JSObject> holder_obj) { |
| 299 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsNameIndex == 0); |
| 300 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsInfoIndex == 1); |
| 301 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsThisIndex == 2); |
| 302 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsHolderIndex == 3); |
| 303 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsLength == 4); |
| 304 __ push(name); |
| 305 Handle<InterceptorInfo> interceptor(holder_obj->GetNamedInterceptor()); |
| 306 ASSERT(!masm->isolate()->heap()->InNewSpace(*interceptor)); |
| 307 Register scratch = name; |
| 308 __ mov(scratch, Operand(interceptor)); |
| 309 __ push(scratch); |
| 310 __ push(receiver); |
| 311 __ push(holder); |
| 312 } |
| 313 |
| 314 |
| 315 static void CompileCallLoadPropertyWithInterceptor( |
| 316 MacroAssembler* masm, Register receiver, Register holder, Register name, |
| 317 Handle<JSObject> holder_obj, IC::UtilityId id) { |
| 318 PushInterceptorArguments(masm, receiver, holder, name, holder_obj); |
| 319 __ CallExternalReference(ExternalReference(IC_Utility(id), masm->isolate()), |
| 320 NamedLoadHandlerCompiler::kInterceptorArgsLength); |
| 321 } |
| 322 |
| 323 |
| 324 // Generate call to api function. |
| 325 void PropertyHandlerCompiler::GenerateFastApiCall( |
| 326 MacroAssembler* masm, const CallOptimization& optimization, |
| 327 Handle<Map> receiver_map, Register receiver, Register scratch_in, |
| 328 bool is_store, int argc, Register* values) { |
| 329 ASSERT(!receiver.is(scratch_in)); |
| 330 __ push(receiver); |
| 331 // Write the arguments to stack frame. |
| 332 for (int i = 0; i < argc; i++) { |
| 333 Register arg = values[argc - 1 - i]; |
| 334 ASSERT(!receiver.is(arg)); |
| 335 ASSERT(!scratch_in.is(arg)); |
| 336 __ push(arg); |
| 337 } |
| 338 ASSERT(optimization.is_simple_api_call()); |
| 339 |
| 340 // Abi for CallApiFunctionStub. |
| 341 Register callee = r0; |
| 342 Register call_data = r4; |
| 343 Register holder = r2; |
| 344 Register api_function_address = r1; |
| 345 |
| 346 // Put holder in place. |
| 347 CallOptimization::HolderLookup holder_lookup; |
| 348 Handle<JSObject> api_holder = |
| 349 optimization.LookupHolderOfExpectedType(receiver_map, &holder_lookup); |
| 350 switch (holder_lookup) { |
| 351 case CallOptimization::kHolderIsReceiver: |
| 352 __ Move(holder, receiver); |
| 353 break; |
| 354 case CallOptimization::kHolderFound: |
| 355 __ Move(holder, api_holder); |
| 356 break; |
| 357 case CallOptimization::kHolderNotFound: |
| 358 UNREACHABLE(); |
| 359 break; |
| 360 } |
| 361 |
| 362 Isolate* isolate = masm->isolate(); |
| 363 Handle<JSFunction> function = optimization.constant_function(); |
| 364 Handle<CallHandlerInfo> api_call_info = optimization.api_call_info(); |
| 365 Handle<Object> call_data_obj(api_call_info->data(), isolate); |
| 366 |
| 367 // Put callee in place. |
| 368 __ Move(callee, function); |
| 369 |
| 370 bool call_data_undefined = false; |
| 371 // Put call_data in place. |
| 372 if (isolate->heap()->InNewSpace(*call_data_obj)) { |
| 373 __ Move(call_data, api_call_info); |
| 374 __ ldr(call_data, FieldMemOperand(call_data, CallHandlerInfo::kDataOffset)); |
| 375 } else if (call_data_obj->IsUndefined()) { |
| 376 call_data_undefined = true; |
| 377 __ LoadRoot(call_data, Heap::kUndefinedValueRootIndex); |
| 378 } else { |
| 379 __ Move(call_data, call_data_obj); |
| 380 } |
| 381 |
| 382 // Put api_function_address in place. |
| 383 Address function_address = v8::ToCData<Address>(api_call_info->callback()); |
| 384 ApiFunction fun(function_address); |
| 385 ExternalReference::Type type = ExternalReference::DIRECT_API_CALL; |
| 386 ExternalReference ref = ExternalReference(&fun, type, masm->isolate()); |
| 387 __ mov(api_function_address, Operand(ref)); |
| 388 |
| 389 // Jump to stub. |
| 390 CallApiFunctionStub stub(isolate, is_store, call_data_undefined, argc); |
| 391 __ TailCallStub(&stub); |
| 392 } |
| 393 |
| 394 |
| 395 void PropertyAccessCompiler::GenerateTailCall(MacroAssembler* masm, |
| 396 Handle<Code> code) { |
| 397 __ Jump(code, RelocInfo::CODE_TARGET); |
| 398 } |
| 399 |
| 400 |
| 401 #undef __ |
| 402 #define __ ACCESS_MASM(masm()) |
| 403 |
| 404 |
| 405 void NamedStoreHandlerCompiler::GenerateRestoreName(Label* label, |
| 406 Handle<Name> name) { |
| 407 if (!label->is_unused()) { |
| 408 __ bind(label); |
| 409 __ mov(this->name(), Operand(name)); |
| 410 } |
| 411 } |
| 412 |
| 413 |
296 void NamedStoreHandlerCompiler::GenerateNegativeHolderLookup( | 414 void NamedStoreHandlerCompiler::GenerateNegativeHolderLookup( |
297 MacroAssembler* masm, Handle<JSObject> holder, Register holder_reg, | 415 Register holder_reg, Handle<Name> name, Label* miss) { |
298 Handle<Name> name, Label* miss) { | 416 if (holder()->IsJSGlobalObject()) { |
299 if (holder->IsJSGlobalObject()) { | 417 GenerateCheckPropertyCell(masm(), Handle<JSGlobalObject>::cast(holder()), |
300 GenerateCheckPropertyCell( | 418 name, scratch1(), miss); |
301 masm, Handle<JSGlobalObject>::cast(holder), name, scratch1(), miss); | 419 } else if (!holder()->HasFastProperties()) { |
302 } else if (!holder->HasFastProperties() && !holder->IsJSGlobalProxy()) { | 420 GenerateDictionaryNegativeLookup(masm(), miss, holder_reg, name, scratch1(), |
303 GenerateDictionaryNegativeLookup( | 421 scratch2()); |
304 masm, miss, holder_reg, name, scratch1(), scratch2()); | |
305 } | 422 } |
306 } | 423 } |
307 | 424 |
308 | 425 |
309 // Generate StoreTransition code, value is passed in r0 register. | 426 // Generate StoreTransition code, value is passed in r0 register. |
310 // When leaving generated code after success, the receiver_reg and name_reg | 427 // When leaving generated code after success, the receiver_reg and name_reg |
311 // may be clobbered. Upon branch to miss_label, the receiver and name | 428 // may be clobbered. Upon branch to miss_label, the receiver and name |
312 // registers have their original values. | 429 // registers have their original values. |
313 void NamedStoreHandlerCompiler::GenerateStoreTransition( | 430 void NamedStoreHandlerCompiler::GenerateStoreTransition( |
314 MacroAssembler* masm, LookupResult* lookup, Handle<Map> transition, | 431 Handle<Map> transition, Handle<Name> name, Register receiver_reg, |
315 Handle<Name> name, Register receiver_reg, Register storage_reg, | 432 Register storage_reg, Register value_reg, Register scratch1, |
316 Register value_reg, Register scratch1, Register scratch2, Register scratch3, | 433 Register scratch2, Register scratch3, Label* miss_label, Label* slow) { |
317 Label* miss_label, Label* slow) { | |
318 // r0 : value | 434 // r0 : value |
319 Label exit; | 435 Label exit; |
320 | 436 |
321 int descriptor = transition->LastAdded(); | 437 int descriptor = transition->LastAdded(); |
322 DescriptorArray* descriptors = transition->instance_descriptors(); | 438 DescriptorArray* descriptors = transition->instance_descriptors(); |
323 PropertyDetails details = descriptors->GetDetails(descriptor); | 439 PropertyDetails details = descriptors->GetDetails(descriptor); |
324 Representation representation = details.representation(); | 440 Representation representation = details.representation(); |
325 ASSERT(!representation.IsNone()); | 441 ASSERT(!representation.IsNone()); |
326 | 442 |
327 if (details.type() == CONSTANT) { | 443 if (details.type() == CONSTANT) { |
328 Handle<Object> constant(descriptors->GetValue(descriptor), masm->isolate()); | 444 Handle<Object> constant(descriptors->GetValue(descriptor), isolate()); |
329 __ Move(scratch1, constant); | 445 __ Move(scratch1, constant); |
330 __ cmp(value_reg, scratch1); | 446 __ cmp(value_reg, scratch1); |
331 __ b(ne, miss_label); | 447 __ b(ne, miss_label); |
332 } else if (representation.IsSmi()) { | 448 } else if (representation.IsSmi()) { |
333 __ JumpIfNotSmi(value_reg, miss_label); | 449 __ JumpIfNotSmi(value_reg, miss_label); |
334 } else if (representation.IsHeapObject()) { | 450 } else if (representation.IsHeapObject()) { |
335 __ JumpIfSmi(value_reg, miss_label); | 451 __ JumpIfSmi(value_reg, miss_label); |
336 HeapType* field_type = descriptors->GetFieldType(descriptor); | 452 HeapType* field_type = descriptors->GetFieldType(descriptor); |
337 HeapType::Iterator<Map> it = field_type->Classes(); | 453 HeapType::Iterator<Map> it = field_type->Classes(); |
338 if (!it.Done()) { | 454 if (!it.Done()) { |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
376 // Perform map transition for the receiver if necessary. | 492 // Perform map transition for the receiver if necessary. |
377 if (details.type() == FIELD && | 493 if (details.type() == FIELD && |
378 Map::cast(transition->GetBackPointer())->unused_property_fields() == 0) { | 494 Map::cast(transition->GetBackPointer())->unused_property_fields() == 0) { |
379 // The properties must be extended before we can store the value. | 495 // The properties must be extended before we can store the value. |
380 // We jump to a runtime call that extends the properties array. | 496 // We jump to a runtime call that extends the properties array. |
381 __ push(receiver_reg); | 497 __ push(receiver_reg); |
382 __ mov(r2, Operand(transition)); | 498 __ mov(r2, Operand(transition)); |
383 __ Push(r2, r0); | 499 __ Push(r2, r0); |
384 __ TailCallExternalReference( | 500 __ TailCallExternalReference( |
385 ExternalReference(IC_Utility(IC::kSharedStoreIC_ExtendStorage), | 501 ExternalReference(IC_Utility(IC::kSharedStoreIC_ExtendStorage), |
386 masm->isolate()), | 502 isolate()), |
387 3, | 503 3, 1); |
388 1); | |
389 return; | 504 return; |
390 } | 505 } |
391 | 506 |
392 // Update the map of the object. | 507 // Update the map of the object. |
393 __ mov(scratch1, Operand(transition)); | 508 __ mov(scratch1, Operand(transition)); |
394 __ str(scratch1, FieldMemOperand(receiver_reg, HeapObject::kMapOffset)); | 509 __ str(scratch1, FieldMemOperand(receiver_reg, HeapObject::kMapOffset)); |
395 | 510 |
396 // Update the write barrier for the map field. | 511 // Update the write barrier for the map field. |
397 __ RecordWriteField(receiver_reg, | 512 __ RecordWriteField(receiver_reg, |
398 HeapObject::kMapOffset, | 513 HeapObject::kMapOffset, |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
476 __ bind(&exit); | 591 __ bind(&exit); |
477 __ Ret(); | 592 __ Ret(); |
478 } | 593 } |
479 | 594 |
480 | 595 |
481 // Generate StoreField code, value is passed in r0 register. | 596 // Generate StoreField code, value is passed in r0 register. |
482 // When leaving generated code after success, the receiver_reg and name_reg | 597 // When leaving generated code after success, the receiver_reg and name_reg |
483 // may be clobbered. Upon branch to miss_label, the receiver and name | 598 // may be clobbered. Upon branch to miss_label, the receiver and name |
484 // registers have their original values. | 599 // registers have their original values. |
485 void NamedStoreHandlerCompiler::GenerateStoreField( | 600 void NamedStoreHandlerCompiler::GenerateStoreField( |
486 MacroAssembler* masm, Handle<JSObject> object, LookupResult* lookup, | 601 Handle<JSObject> object, LookupResult* lookup, Register receiver_reg, |
487 Register receiver_reg, Register name_reg, Register value_reg, | 602 Register name_reg, Register value_reg, Register scratch1, Register scratch2, |
488 Register scratch1, Register scratch2, Label* miss_label) { | 603 Label* miss_label) { |
489 // r0 : value | 604 // r0 : value |
490 Label exit; | 605 Label exit; |
491 | 606 |
492 // Stub never generated for non-global objects that require access | 607 // Stub never generated for objects that require access checks. |
493 // checks. | 608 ASSERT(!object->IsAccessCheckNeeded()); |
494 ASSERT(object->IsJSGlobalProxy() || !object->IsAccessCheckNeeded()); | 609 ASSERT(!object->IsJSGlobalProxy()); |
495 | 610 |
496 FieldIndex index = lookup->GetFieldIndex(); | 611 FieldIndex index = lookup->GetFieldIndex(); |
497 | 612 |
498 Representation representation = lookup->representation(); | 613 Representation representation = lookup->representation(); |
499 ASSERT(!representation.IsNone()); | 614 ASSERT(!representation.IsNone()); |
500 if (representation.IsSmi()) { | 615 if (representation.IsSmi()) { |
501 __ JumpIfNotSmi(value_reg, miss_label); | 616 __ JumpIfNotSmi(value_reg, miss_label); |
502 } else if (representation.IsHeapObject()) { | 617 } else if (representation.IsHeapObject()) { |
503 __ JumpIfSmi(value_reg, miss_label); | 618 __ JumpIfSmi(value_reg, miss_label); |
504 HeapType* field_type = lookup->GetFieldType(); | 619 HeapType* field_type = lookup->GetFieldType(); |
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
596 } | 711 } |
597 } | 712 } |
598 | 713 |
599 // Return the value (register r0). | 714 // Return the value (register r0). |
600 ASSERT(value_reg.is(r0)); | 715 ASSERT(value_reg.is(r0)); |
601 __ bind(&exit); | 716 __ bind(&exit); |
602 __ Ret(); | 717 __ Ret(); |
603 } | 718 } |
604 | 719 |
605 | 720 |
606 void NamedStoreHandlerCompiler::GenerateRestoreName(MacroAssembler* masm, | |
607 Label* label, | |
608 Handle<Name> name) { | |
609 if (!label->is_unused()) { | |
610 __ bind(label); | |
611 __ mov(this->name(), Operand(name)); | |
612 } | |
613 } | |
614 | |
615 | |
616 static void PushInterceptorArguments(MacroAssembler* masm, | |
617 Register receiver, | |
618 Register holder, | |
619 Register name, | |
620 Handle<JSObject> holder_obj) { | |
621 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsNameIndex == 0); | |
622 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsInfoIndex == 1); | |
623 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsThisIndex == 2); | |
624 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsHolderIndex == 3); | |
625 STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsLength == 4); | |
626 __ push(name); | |
627 Handle<InterceptorInfo> interceptor(holder_obj->GetNamedInterceptor()); | |
628 ASSERT(!masm->isolate()->heap()->InNewSpace(*interceptor)); | |
629 Register scratch = name; | |
630 __ mov(scratch, Operand(interceptor)); | |
631 __ push(scratch); | |
632 __ push(receiver); | |
633 __ push(holder); | |
634 } | |
635 | |
636 | |
637 static void CompileCallLoadPropertyWithInterceptor( | |
638 MacroAssembler* masm, | |
639 Register receiver, | |
640 Register holder, | |
641 Register name, | |
642 Handle<JSObject> holder_obj, | |
643 IC::UtilityId id) { | |
644 PushInterceptorArguments(masm, receiver, holder, name, holder_obj); | |
645 __ CallExternalReference(ExternalReference(IC_Utility(id), masm->isolate()), | |
646 NamedLoadHandlerCompiler::kInterceptorArgsLength); | |
647 } | |
648 | |
649 | |
650 // Generate call to api function. | |
651 void PropertyHandlerCompiler::GenerateFastApiCall( | |
652 MacroAssembler* masm, const CallOptimization& optimization, | |
653 Handle<Map> receiver_map, Register receiver, Register scratch_in, | |
654 bool is_store, int argc, Register* values) { | |
655 ASSERT(!receiver.is(scratch_in)); | |
656 __ push(receiver); | |
657 // Write the arguments to stack frame. | |
658 for (int i = 0; i < argc; i++) { | |
659 Register arg = values[argc-1-i]; | |
660 ASSERT(!receiver.is(arg)); | |
661 ASSERT(!scratch_in.is(arg)); | |
662 __ push(arg); | |
663 } | |
664 ASSERT(optimization.is_simple_api_call()); | |
665 | |
666 // Abi for CallApiFunctionStub. | |
667 Register callee = r0; | |
668 Register call_data = r4; | |
669 Register holder = r2; | |
670 Register api_function_address = r1; | |
671 | |
672 // Put holder in place. | |
673 CallOptimization::HolderLookup holder_lookup; | |
674 Handle<JSObject> api_holder = optimization.LookupHolderOfExpectedType( | |
675 receiver_map, | |
676 &holder_lookup); | |
677 switch (holder_lookup) { | |
678 case CallOptimization::kHolderIsReceiver: | |
679 __ Move(holder, receiver); | |
680 break; | |
681 case CallOptimization::kHolderFound: | |
682 __ Move(holder, api_holder); | |
683 break; | |
684 case CallOptimization::kHolderNotFound: | |
685 UNREACHABLE(); | |
686 break; | |
687 } | |
688 | |
689 Isolate* isolate = masm->isolate(); | |
690 Handle<JSFunction> function = optimization.constant_function(); | |
691 Handle<CallHandlerInfo> api_call_info = optimization.api_call_info(); | |
692 Handle<Object> call_data_obj(api_call_info->data(), isolate); | |
693 | |
694 // Put callee in place. | |
695 __ Move(callee, function); | |
696 | |
697 bool call_data_undefined = false; | |
698 // Put call_data in place. | |
699 if (isolate->heap()->InNewSpace(*call_data_obj)) { | |
700 __ Move(call_data, api_call_info); | |
701 __ ldr(call_data, FieldMemOperand(call_data, CallHandlerInfo::kDataOffset)); | |
702 } else if (call_data_obj->IsUndefined()) { | |
703 call_data_undefined = true; | |
704 __ LoadRoot(call_data, Heap::kUndefinedValueRootIndex); | |
705 } else { | |
706 __ Move(call_data, call_data_obj); | |
707 } | |
708 | |
709 // Put api_function_address in place. | |
710 Address function_address = v8::ToCData<Address>(api_call_info->callback()); | |
711 ApiFunction fun(function_address); | |
712 ExternalReference::Type type = ExternalReference::DIRECT_API_CALL; | |
713 ExternalReference ref = ExternalReference(&fun, | |
714 type, | |
715 masm->isolate()); | |
716 __ mov(api_function_address, Operand(ref)); | |
717 | |
718 // Jump to stub. | |
719 CallApiFunctionStub stub(isolate, is_store, call_data_undefined, argc); | |
720 __ TailCallStub(&stub); | |
721 } | |
722 | |
723 | |
724 void PropertyAccessCompiler::GenerateTailCall(MacroAssembler* masm, | |
725 Handle<Code> code) { | |
726 __ Jump(code, RelocInfo::CODE_TARGET); | |
727 } | |
728 | |
729 | |
730 #undef __ | |
731 #define __ ACCESS_MASM(masm()) | |
732 | |
733 | |
734 Register PropertyHandlerCompiler::CheckPrototypes( | 721 Register PropertyHandlerCompiler::CheckPrototypes( |
735 Register object_reg, Register holder_reg, Register scratch1, | 722 Register object_reg, Register holder_reg, Register scratch1, |
736 Register scratch2, Handle<Name> name, Label* miss, | 723 Register scratch2, Handle<Name> name, Label* miss, |
737 PrototypeCheckType check) { | 724 PrototypeCheckType check) { |
738 Handle<Map> receiver_map(IC::TypeToMap(*type(), isolate())); | 725 Handle<Map> receiver_map(IC::TypeToMap(*type(), isolate())); |
739 | 726 |
740 // Make sure there's no overlap between holder and object registers. | 727 // Make sure there's no overlap between holder and object registers. |
741 ASSERT(!scratch1.is(object_reg) && !scratch1.is(holder_reg)); | 728 ASSERT(!scratch1.is(object_reg) && !scratch1.is(holder_reg)); |
742 ASSERT(!scratch2.is(object_reg) && !scratch2.is(holder_reg) | 729 ASSERT(!scratch2.is(object_reg) && !scratch2.is(holder_reg) |
743 && !scratch2.is(scratch1)); | 730 && !scratch2.is(scratch1)); |
(...skipping 105 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
849 TailCallBuiltin(masm(), MissBuiltin(kind())); | 836 TailCallBuiltin(masm(), MissBuiltin(kind())); |
850 __ bind(&success); | 837 __ bind(&success); |
851 } | 838 } |
852 } | 839 } |
853 | 840 |
854 | 841 |
855 void NamedStoreHandlerCompiler::FrontendFooter(Handle<Name> name, Label* miss) { | 842 void NamedStoreHandlerCompiler::FrontendFooter(Handle<Name> name, Label* miss) { |
856 if (!miss->is_unused()) { | 843 if (!miss->is_unused()) { |
857 Label success; | 844 Label success; |
858 __ b(&success); | 845 __ b(&success); |
859 GenerateRestoreName(masm(), miss, name); | 846 GenerateRestoreName(miss, name); |
860 TailCallBuiltin(masm(), MissBuiltin(kind())); | 847 TailCallBuiltin(masm(), MissBuiltin(kind())); |
861 __ bind(&success); | 848 __ bind(&success); |
862 } | 849 } |
863 } | 850 } |
864 | 851 |
865 | 852 |
866 Register NamedLoadHandlerCompiler::CallbackFrontend(Register object_reg, | 853 Register NamedLoadHandlerCompiler::CallbackFrontend(Register object_reg, |
867 Handle<Name> name, | 854 Handle<Name> name, |
868 Handle<Object> callback) { | 855 Handle<Object> callback) { |
869 Label miss; | 856 Label miss; |
(...skipping 437 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1307 __ bind(&miss); | 1294 __ bind(&miss); |
1308 TailCallBuiltin(masm(), MissBuiltin(kind())); | 1295 TailCallBuiltin(masm(), MissBuiltin(kind())); |
1309 | 1296 |
1310 // Return the generated code. | 1297 // Return the generated code. |
1311 InlineCacheState state = | 1298 InlineCacheState state = |
1312 number_of_handled_maps > 1 ? POLYMORPHIC : MONOMORPHIC; | 1299 number_of_handled_maps > 1 ? POLYMORPHIC : MONOMORPHIC; |
1313 return GetCode(kind(), type, name, state); | 1300 return GetCode(kind(), type, name, state); |
1314 } | 1301 } |
1315 | 1302 |
1316 | 1303 |
1317 void NamedStoreHandlerCompiler::GenerateStoreArrayLength() { | |
1318 // Prepare tail call to StoreIC_ArrayLength. | |
1319 __ Push(receiver(), value()); | |
1320 | |
1321 ExternalReference ref = | |
1322 ExternalReference(IC_Utility(IC::kStoreIC_ArrayLength), | |
1323 masm()->isolate()); | |
1324 __ TailCallExternalReference(ref, 2, 1); | |
1325 } | |
1326 | |
1327 | |
1328 Handle<Code> PropertyICCompiler::CompileKeyedStorePolymorphic( | 1304 Handle<Code> PropertyICCompiler::CompileKeyedStorePolymorphic( |
1329 MapHandleList* receiver_maps, CodeHandleList* handler_stubs, | 1305 MapHandleList* receiver_maps, CodeHandleList* handler_stubs, |
1330 MapHandleList* transitioned_maps) { | 1306 MapHandleList* transitioned_maps) { |
1331 Label miss; | 1307 Label miss; |
1332 __ JumpIfSmi(receiver(), &miss); | 1308 __ JumpIfSmi(receiver(), &miss); |
1333 | 1309 |
1334 int receiver_count = receiver_maps->length(); | 1310 int receiver_count = receiver_maps->length(); |
1335 __ ldr(scratch1(), FieldMemOperand(receiver(), HeapObject::kMapOffset)); | 1311 __ ldr(scratch1(), FieldMemOperand(receiver(), HeapObject::kMapOffset)); |
1336 for (int i = 0; i < receiver_count; ++i) { | 1312 for (int i = 0; i < receiver_count; ++i) { |
1337 __ mov(ip, Operand(receiver_maps->at(i))); | 1313 __ mov(ip, Operand(receiver_maps->at(i))); |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1386 | 1362 |
1387 TailCallBuiltin(masm, Builtins::kKeyedLoadIC_Miss); | 1363 TailCallBuiltin(masm, Builtins::kKeyedLoadIC_Miss); |
1388 } | 1364 } |
1389 | 1365 |
1390 | 1366 |
1391 #undef __ | 1367 #undef __ |
1392 | 1368 |
1393 } } // namespace v8::internal | 1369 } } // namespace v8::internal |
1394 | 1370 |
1395 #endif // V8_TARGET_ARCH_ARM | 1371 #endif // V8_TARGET_ARCH_ARM |
OLD | NEW |