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/base/bits.h" | 9 #include "src/base/bits.h" |
10 #include "src/bootstrapper.h" | 10 #include "src/bootstrapper.h" |
(...skipping 4584 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4595 } | 4595 } |
4596 | 4596 |
4597 | 4597 |
4598 void VectorRawLoadStub::GenerateForTrampoline(MacroAssembler* masm) { | 4598 void VectorRawLoadStub::GenerateForTrampoline(MacroAssembler* masm) { |
4599 GenerateImpl(masm, true); | 4599 GenerateImpl(masm, true); |
4600 } | 4600 } |
4601 | 4601 |
4602 | 4602 |
4603 static void HandleArrayCases(MacroAssembler* masm, Register receiver, | 4603 static void HandleArrayCases(MacroAssembler* masm, Register receiver, |
4604 Register key, Register vector, Register slot, | 4604 Register key, Register vector, Register slot, |
4605 Register feedback, Register receiver_map, | 4605 Register feedback, Register scratch1, |
4606 Register scratch1, Register scratch2, | 4606 Register scratch2, Register scratch3, |
4607 bool is_polymorphic, Label* miss) { | 4607 bool is_polymorphic, Label* miss) { |
4608 // feedback initially contains the feedback array | 4608 // feedback initially contains the feedback array |
4609 Label next_loop, prepare_next; | 4609 Label next_loop, prepare_next; |
| 4610 Label load_smi_map, compare_map; |
4610 Label start_polymorphic; | 4611 Label start_polymorphic; |
4611 | 4612 |
4612 Register cached_map = scratch1; | 4613 Register receiver_map = scratch1; |
| 4614 Register cached_map = scratch2; |
4613 | 4615 |
| 4616 // Receiver might not be a heap object. |
| 4617 __ JumpIfSmi(receiver, &load_smi_map); |
| 4618 __ lw(receiver_map, FieldMemOperand(receiver, HeapObject::kMapOffset)); |
| 4619 __ bind(&compare_map); |
4614 __ lw(cached_map, | 4620 __ lw(cached_map, |
4615 FieldMemOperand(feedback, FixedArray::OffsetOfElementAt(0))); | 4621 FieldMemOperand(feedback, FixedArray::OffsetOfElementAt(0))); |
4616 __ lw(cached_map, FieldMemOperand(cached_map, WeakCell::kValueOffset)); | 4622 __ lw(cached_map, FieldMemOperand(cached_map, WeakCell::kValueOffset)); |
4617 __ Branch(&start_polymorphic, ne, receiver_map, Operand(cached_map)); | 4623 __ Branch(&start_polymorphic, ne, receiver_map, Operand(cached_map)); |
4618 // found, now call handler. | 4624 // found, now call handler. |
4619 Register handler = feedback; | 4625 Register handler = feedback; |
4620 __ lw(handler, FieldMemOperand(feedback, FixedArray::OffsetOfElementAt(1))); | 4626 __ lw(handler, FieldMemOperand(feedback, FixedArray::OffsetOfElementAt(1))); |
4621 __ Addu(t9, handler, Operand(Code::kHeaderSize - kHeapObjectTag)); | 4627 __ Addu(t9, handler, Operand(Code::kHeaderSize - kHeapObjectTag)); |
4622 __ Jump(t9); | 4628 __ Jump(t9); |
4623 | 4629 |
4624 | 4630 |
4625 Register length = scratch2; | 4631 Register length = scratch3; |
4626 __ bind(&start_polymorphic); | 4632 __ bind(&start_polymorphic); |
4627 __ lw(length, FieldMemOperand(feedback, FixedArray::kLengthOffset)); | 4633 __ lw(length, FieldMemOperand(feedback, FixedArray::kLengthOffset)); |
4628 if (!is_polymorphic) { | 4634 if (!is_polymorphic) { |
4629 // If the IC could be monomorphic we have to make sure we don't go past the | 4635 // If the IC could be monomorphic we have to make sure we don't go past the |
4630 // end of the feedback array. | 4636 // end of the feedback array. |
4631 __ Branch(miss, eq, length, Operand(Smi::FromInt(2))); | 4637 __ Branch(miss, eq, length, Operand(Smi::FromInt(2))); |
4632 } | 4638 } |
4633 | 4639 |
4634 Register too_far = length; | 4640 Register too_far = length; |
4635 Register pointer_reg = feedback; | 4641 Register pointer_reg = feedback; |
4636 | 4642 |
4637 // +-----+------+------+-----+-----+ ... ----+ | 4643 // +-----+------+------+-----+-----+ ... ----+ |
4638 // | map | len | wm0 | h0 | wm1 | hN | | 4644 // | map | len | wm0 | h0 | wm1 | hN | |
4639 // +-----+------+------+-----+-----+ ... ----+ | 4645 // +-----+------+------+-----+-----+ ... ----+ |
4640 // 0 1 2 len-1 | 4646 // 0 1 2 len-1 |
4641 // ^ ^ | 4647 // ^ ^ |
4642 // | | | 4648 // | | |
4643 // pointer_reg too_far | 4649 // pointer_reg too_far |
4644 // aka feedback scratch2 | 4650 // aka feedback scratch3 |
4645 // also need receiver_map | 4651 // also need receiver_map (aka scratch1) |
4646 // use cached_map (scratch1) to look in the weak map values. | 4652 // use cached_map (scratch2) to look in the weak map values. |
4647 __ sll(at, length, kPointerSizeLog2 - kSmiTagSize); | 4653 __ sll(at, length, kPointerSizeLog2 - kSmiTagSize); |
4648 __ Addu(too_far, feedback, Operand(at)); | 4654 __ Addu(too_far, feedback, Operand(at)); |
4649 __ Addu(too_far, too_far, Operand(FixedArray::kHeaderSize - kHeapObjectTag)); | 4655 __ Addu(too_far, too_far, Operand(FixedArray::kHeaderSize - kHeapObjectTag)); |
4650 __ Addu(pointer_reg, feedback, | 4656 __ Addu(pointer_reg, feedback, |
4651 Operand(FixedArray::OffsetOfElementAt(2) - kHeapObjectTag)); | 4657 Operand(FixedArray::OffsetOfElementAt(2) - kHeapObjectTag)); |
4652 | 4658 |
4653 __ bind(&next_loop); | 4659 __ bind(&next_loop); |
4654 __ lw(cached_map, MemOperand(pointer_reg)); | 4660 __ lw(cached_map, MemOperand(pointer_reg)); |
4655 __ lw(cached_map, FieldMemOperand(cached_map, WeakCell::kValueOffset)); | 4661 __ lw(cached_map, FieldMemOperand(cached_map, WeakCell::kValueOffset)); |
4656 __ Branch(&prepare_next, ne, receiver_map, Operand(cached_map)); | 4662 __ Branch(&prepare_next, ne, receiver_map, Operand(cached_map)); |
4657 __ lw(handler, MemOperand(pointer_reg, kPointerSize)); | 4663 __ lw(handler, MemOperand(pointer_reg, kPointerSize)); |
4658 __ Addu(t9, handler, Operand(Code::kHeaderSize - kHeapObjectTag)); | 4664 __ Addu(t9, handler, Operand(Code::kHeaderSize - kHeapObjectTag)); |
4659 __ Jump(t9); | 4665 __ Jump(t9); |
4660 | 4666 |
4661 __ bind(&prepare_next); | 4667 __ bind(&prepare_next); |
4662 __ Addu(pointer_reg, pointer_reg, Operand(kPointerSize * 2)); | 4668 __ Addu(pointer_reg, pointer_reg, Operand(kPointerSize * 2)); |
4663 __ Branch(&next_loop, lt, pointer_reg, Operand(too_far)); | 4669 __ Branch(&next_loop, lt, pointer_reg, Operand(too_far)); |
4664 | 4670 |
4665 // We exhausted our array of map handler pairs. | 4671 // We exhausted our array of map handler pairs. |
4666 __ jmp(miss); | 4672 __ jmp(miss); |
| 4673 |
| 4674 __ bind(&load_smi_map); |
| 4675 __ LoadRoot(receiver_map, Heap::kHeapNumberMapRootIndex); |
| 4676 __ jmp(&compare_map); |
4667 } | 4677 } |
4668 | 4678 |
4669 | 4679 |
4670 static void HandleMonomorphicCase(MacroAssembler* masm, Register receiver, | 4680 static void HandleMonomorphicCase(MacroAssembler* masm, Register receiver, |
4671 Register receiver_map, Register feedback, | 4681 Register key, Register vector, Register slot, |
4672 Register vector, Register slot, | 4682 Register weak_cell, Register scratch, |
4673 Register scratch, Label* compare_map, | 4683 Label* miss) { |
4674 Label* load_smi_map, Label* try_array) { | 4684 // feedback initially contains the feedback array |
4675 __ JumpIfSmi(receiver, load_smi_map); | 4685 Label compare_smi_map; |
| 4686 Register receiver_map = scratch; |
| 4687 Register cached_map = weak_cell; |
| 4688 |
| 4689 // Move the weak map into the weak_cell register. |
| 4690 __ lw(cached_map, FieldMemOperand(weak_cell, WeakCell::kValueOffset)); |
| 4691 |
| 4692 // Receiver might not be a heap object. |
| 4693 __ JumpIfSmi(receiver, &compare_smi_map); |
4676 __ lw(receiver_map, FieldMemOperand(receiver, HeapObject::kMapOffset)); | 4694 __ lw(receiver_map, FieldMemOperand(receiver, HeapObject::kMapOffset)); |
4677 __ bind(compare_map); | 4695 __ Branch(miss, ne, cached_map, Operand(receiver_map)); |
4678 Register cached_map = scratch; | |
4679 // Move the weak map into the weak_cell register. | |
4680 __ lw(cached_map, FieldMemOperand(feedback, WeakCell::kValueOffset)); | |
4681 __ Branch(try_array, ne, cached_map, Operand(receiver_map)); | |
4682 Register handler = feedback; | |
4683 | 4696 |
| 4697 Register handler = weak_cell; |
4684 __ sll(at, slot, kPointerSizeLog2 - kSmiTagSize); | 4698 __ sll(at, slot, kPointerSizeLog2 - kSmiTagSize); |
4685 __ Addu(handler, vector, Operand(at)); | 4699 __ Addu(handler, vector, Operand(at)); |
4686 __ lw(handler, | 4700 __ lw(handler, |
| 4701 FieldMemOperand(handler, FixedArray::kHeaderSize + kPointerSize)); |
| 4702 __ Addu(t9, handler, Operand(Code::kHeaderSize - kHeapObjectTag)); |
| 4703 __ Jump(t9); |
| 4704 |
| 4705 // In microbenchmarks, it made sense to unroll this code so that the call to |
| 4706 // the handler is duplicated for a HeapObject receiver and a Smi receiver. |
| 4707 __ bind(&compare_smi_map); |
| 4708 __ LoadRoot(at, Heap::kHeapNumberMapRootIndex); |
| 4709 __ Branch(miss, ne, at, Operand(weak_cell)); |
| 4710 __ sll(at, slot, kPointerSizeLog2 - kSmiTagSize); |
| 4711 __ Addu(handler, vector, Operand(at)); |
| 4712 __ lw(handler, |
4687 FieldMemOperand(handler, FixedArray::kHeaderSize + kPointerSize)); | 4713 FieldMemOperand(handler, FixedArray::kHeaderSize + kPointerSize)); |
4688 __ Addu(t9, handler, Operand(Code::kHeaderSize - kHeapObjectTag)); | 4714 __ Addu(t9, handler, Operand(Code::kHeaderSize - kHeapObjectTag)); |
4689 __ Jump(t9); | 4715 __ Jump(t9); |
4690 } | 4716 } |
4691 | 4717 |
4692 | 4718 |
4693 void VectorRawLoadStub::GenerateImpl(MacroAssembler* masm, bool in_frame) { | 4719 void VectorRawLoadStub::GenerateImpl(MacroAssembler* masm, bool in_frame) { |
4694 Register receiver = VectorLoadICDescriptor::ReceiverRegister(); // a1 | 4720 Register receiver = VectorLoadICDescriptor::ReceiverRegister(); // a1 |
4695 Register name = VectorLoadICDescriptor::NameRegister(); // a2 | 4721 Register name = VectorLoadICDescriptor::NameRegister(); // a2 |
4696 Register vector = VectorLoadICDescriptor::VectorRegister(); // a3 | 4722 Register vector = VectorLoadICDescriptor::VectorRegister(); // a3 |
4697 Register slot = VectorLoadICDescriptor::SlotRegister(); // a0 | 4723 Register slot = VectorLoadICDescriptor::SlotRegister(); // a0 |
4698 Register feedback = t0; | 4724 Register feedback = t0; |
4699 Register receiver_map = t1; | 4725 Register scratch1 = t1; |
4700 Register scratch1 = t4; | |
4701 | 4726 |
4702 __ sll(at, slot, kPointerSizeLog2 - kSmiTagSize); | 4727 __ sll(at, slot, kPointerSizeLog2 - kSmiTagSize); |
4703 __ Addu(feedback, vector, Operand(at)); | 4728 __ Addu(feedback, vector, Operand(at)); |
4704 __ lw(feedback, FieldMemOperand(feedback, FixedArray::kHeaderSize)); | 4729 __ lw(feedback, FieldMemOperand(feedback, FixedArray::kHeaderSize)); |
4705 | 4730 |
4706 // Try to quickly handle the monomorphic case without knowing for sure | 4731 // Is it a weak cell? |
4707 // if we have a weak cell in feedback. We do know it's safe to look | 4732 Label try_array; |
4708 // at WeakCell::kValueOffset. | 4733 Label not_array, smi_key, key_okay, miss; |
4709 Label try_array, load_smi_map, compare_map; | 4734 __ lw(scratch1, FieldMemOperand(feedback, HeapObject::kMapOffset)); |
4710 Label not_array, miss; | 4735 __ LoadRoot(at, Heap::kWeakCellMapRootIndex); |
4711 HandleMonomorphicCase(masm, receiver, receiver_map, feedback, vector, slot, | 4736 __ Branch(&try_array, ne, at, Operand(scratch1)); |
4712 scratch1, &compare_map, &load_smi_map, &try_array); | 4737 HandleMonomorphicCase(masm, receiver, name, vector, slot, feedback, scratch1, |
| 4738 &miss); |
4713 | 4739 |
4714 // Is it a fixed array? | 4740 // Is it a fixed array? |
4715 __ bind(&try_array); | 4741 __ bind(&try_array); |
4716 __ lw(scratch1, FieldMemOperand(feedback, HeapObject::kMapOffset)); | |
4717 __ LoadRoot(at, Heap::kFixedArrayMapRootIndex); | 4742 __ LoadRoot(at, Heap::kFixedArrayMapRootIndex); |
4718 __ Branch(¬_array, ne, at, Operand(scratch1)); | 4743 __ Branch(¬_array, ne, at, Operand(scratch1)); |
4719 HandleArrayCases(masm, receiver, name, vector, slot, feedback, receiver_map, | 4744 HandleArrayCases(masm, receiver, name, vector, slot, feedback, scratch1, t4, |
4720 scratch1, t5, true, &miss); | 4745 t5, true, &miss); |
4721 | 4746 |
4722 __ bind(¬_array); | 4747 __ bind(¬_array); |
4723 __ LoadRoot(at, Heap::kmegamorphic_symbolRootIndex); | 4748 __ LoadRoot(at, Heap::kmegamorphic_symbolRootIndex); |
4724 __ Branch(&miss, ne, at, Operand(feedback)); | 4749 __ Branch(&miss, ne, at, Operand(feedback)); |
4725 Code::Flags code_flags = Code::RemoveTypeAndHolderFromFlags( | 4750 Code::Flags code_flags = Code::RemoveTypeAndHolderFromFlags( |
4726 Code::ComputeHandlerFlags(Code::LOAD_IC)); | 4751 Code::ComputeHandlerFlags(Code::LOAD_IC)); |
4727 masm->isolate()->stub_cache()->GenerateProbe(masm, Code::LOAD_IC, code_flags, | 4752 masm->isolate()->stub_cache()->GenerateProbe(masm, Code::LOAD_IC, code_flags, |
4728 false, receiver, name, feedback, | 4753 false, receiver, name, feedback, |
4729 receiver_map, scratch1, t5); | 4754 scratch1, t4, t5); |
4730 | 4755 |
4731 __ bind(&miss); | 4756 __ bind(&miss); |
4732 LoadIC::GenerateMiss(masm); | 4757 LoadIC::GenerateMiss(masm); |
4733 | |
4734 __ bind(&load_smi_map); | |
4735 __ LoadRoot(receiver_map, Heap::kHeapNumberMapRootIndex); | |
4736 __ jmp(&compare_map); | |
4737 } | 4758 } |
4738 | 4759 |
4739 | 4760 |
4740 void VectorRawKeyedLoadStub::Generate(MacroAssembler* masm) { | 4761 void VectorRawKeyedLoadStub::Generate(MacroAssembler* masm) { |
4741 GenerateImpl(masm, false); | 4762 GenerateImpl(masm, false); |
4742 } | 4763 } |
4743 | 4764 |
4744 | 4765 |
4745 void VectorRawKeyedLoadStub::GenerateForTrampoline(MacroAssembler* masm) { | 4766 void VectorRawKeyedLoadStub::GenerateForTrampoline(MacroAssembler* masm) { |
4746 GenerateImpl(masm, true); | 4767 GenerateImpl(masm, true); |
4747 } | 4768 } |
4748 | 4769 |
4749 | 4770 |
4750 void VectorRawKeyedLoadStub::GenerateImpl(MacroAssembler* masm, bool in_frame) { | 4771 void VectorRawKeyedLoadStub::GenerateImpl(MacroAssembler* masm, bool in_frame) { |
4751 Register receiver = VectorLoadICDescriptor::ReceiverRegister(); // a1 | 4772 Register receiver = VectorLoadICDescriptor::ReceiverRegister(); // a1 |
4752 Register key = VectorLoadICDescriptor::NameRegister(); // a2 | 4773 Register key = VectorLoadICDescriptor::NameRegister(); // a2 |
4753 Register vector = VectorLoadICDescriptor::VectorRegister(); // a3 | 4774 Register vector = VectorLoadICDescriptor::VectorRegister(); // a3 |
4754 Register slot = VectorLoadICDescriptor::SlotRegister(); // a0 | 4775 Register slot = VectorLoadICDescriptor::SlotRegister(); // a0 |
4755 Register feedback = t0; | 4776 Register feedback = t0; |
4756 Register receiver_map = t1; | 4777 Register scratch1 = t1; |
4757 Register scratch1 = t4; | |
4758 | 4778 |
4759 __ sll(at, slot, kPointerSizeLog2 - kSmiTagSize); | 4779 __ sll(at, slot, kPointerSizeLog2 - kSmiTagSize); |
4760 __ Addu(feedback, vector, Operand(at)); | 4780 __ Addu(feedback, vector, Operand(at)); |
4761 __ lw(feedback, FieldMemOperand(feedback, FixedArray::kHeaderSize)); | 4781 __ lw(feedback, FieldMemOperand(feedback, FixedArray::kHeaderSize)); |
4762 | 4782 |
4763 // Try to quickly handle the monomorphic case without knowing for sure | 4783 // Is it a weak cell? |
4764 // if we have a weak cell in feedback. We do know it's safe to look | 4784 Label try_array; |
4765 // at WeakCell::kValueOffset. | 4785 Label not_array, smi_key, key_okay, miss; |
4766 Label try_array, load_smi_map, compare_map; | 4786 __ lw(scratch1, FieldMemOperand(feedback, HeapObject::kMapOffset)); |
4767 Label not_array, miss; | 4787 __ LoadRoot(at, Heap::kWeakCellMapRootIndex); |
4768 HandleMonomorphicCase(masm, receiver, receiver_map, feedback, vector, slot, | 4788 __ Branch(&try_array, ne, at, Operand(scratch1)); |
4769 scratch1, &compare_map, &load_smi_map, &try_array); | 4789 __ JumpIfNotSmi(key, &miss); |
| 4790 HandleMonomorphicCase(masm, receiver, key, vector, slot, feedback, scratch1, |
| 4791 &miss); |
4770 | 4792 |
4771 __ bind(&try_array); | 4793 __ bind(&try_array); |
4772 // Is it a fixed array? | 4794 // Is it a fixed array? |
4773 __ lw(scratch1, FieldMemOperand(feedback, HeapObject::kMapOffset)); | |
4774 __ LoadRoot(at, Heap::kFixedArrayMapRootIndex); | 4795 __ LoadRoot(at, Heap::kFixedArrayMapRootIndex); |
4775 __ Branch(¬_array, ne, at, Operand(scratch1)); | 4796 __ Branch(¬_array, ne, at, Operand(scratch1)); |
4776 // We have a polymorphic element handler. | 4797 // We have a polymorphic element handler. |
4777 __ JumpIfNotSmi(key, &miss); | 4798 __ JumpIfNotSmi(key, &miss); |
4778 | 4799 |
4779 Label polymorphic, try_poly_name; | 4800 Label polymorphic, try_poly_name; |
4780 __ bind(&polymorphic); | 4801 __ bind(&polymorphic); |
4781 HandleArrayCases(masm, receiver, key, vector, slot, feedback, receiver_map, | 4802 HandleArrayCases(masm, receiver, key, vector, slot, feedback, scratch1, t4, |
4782 scratch1, t5, true, &miss); | 4803 t5, true, &miss); |
4783 | 4804 |
4784 __ bind(¬_array); | 4805 __ bind(¬_array); |
4785 // Is it generic? | 4806 // Is it generic? |
4786 __ LoadRoot(at, Heap::kmegamorphic_symbolRootIndex); | 4807 __ LoadRoot(at, Heap::kmegamorphic_symbolRootIndex); |
4787 __ Branch(&try_poly_name, ne, at, Operand(feedback)); | 4808 __ Branch(&try_poly_name, ne, at, Operand(feedback)); |
4788 Handle<Code> megamorphic_stub = | 4809 Handle<Code> megamorphic_stub = |
4789 KeyedLoadIC::ChooseMegamorphicStub(masm->isolate()); | 4810 KeyedLoadIC::ChooseMegamorphicStub(masm->isolate()); |
4790 __ Jump(megamorphic_stub, RelocInfo::CODE_TARGET); | 4811 __ Jump(megamorphic_stub, RelocInfo::CODE_TARGET); |
4791 | 4812 |
4792 __ bind(&try_poly_name); | 4813 __ bind(&try_poly_name); |
4793 // We might have a name in feedback, and a fixed array in the next slot. | 4814 // We might have a name in feedback, and a fixed array in the next slot. |
4794 __ Branch(&miss, ne, key, Operand(feedback)); | 4815 __ Branch(&miss, ne, key, Operand(feedback)); |
4795 // If the name comparison succeeded, we know we have a fixed array with | 4816 // If the name comparison succeeded, we know we have a fixed array with |
4796 // at least one map/handler pair. | 4817 // at least one map/handler pair. |
4797 __ sll(at, slot, kPointerSizeLog2 - kSmiTagSize); | 4818 __ sll(at, slot, kPointerSizeLog2 - kSmiTagSize); |
4798 __ Addu(feedback, vector, Operand(at)); | 4819 __ Addu(feedback, vector, Operand(at)); |
4799 __ lw(feedback, | 4820 __ lw(feedback, |
4800 FieldMemOperand(feedback, FixedArray::kHeaderSize + kPointerSize)); | 4821 FieldMemOperand(feedback, FixedArray::kHeaderSize + kPointerSize)); |
4801 HandleArrayCases(masm, receiver, key, vector, slot, feedback, receiver_map, | 4822 HandleArrayCases(masm, receiver, key, vector, slot, feedback, scratch1, t4, |
4802 scratch1, t5, false, &miss); | 4823 t5, false, &miss); |
4803 | 4824 |
4804 __ bind(&miss); | 4825 __ bind(&miss); |
4805 KeyedLoadIC::GenerateMiss(masm); | 4826 KeyedLoadIC::GenerateMiss(masm); |
4806 | |
4807 __ bind(&load_smi_map); | |
4808 __ LoadRoot(receiver_map, Heap::kHeapNumberMapRootIndex); | |
4809 __ jmp(&compare_map); | |
4810 } | 4827 } |
4811 | 4828 |
4812 | 4829 |
4813 void ProfileEntryHookStub::MaybeCallEntryHook(MacroAssembler* masm) { | 4830 void ProfileEntryHookStub::MaybeCallEntryHook(MacroAssembler* masm) { |
4814 if (masm->isolate()->function_entry_hook() != NULL) { | 4831 if (masm->isolate()->function_entry_hook() != NULL) { |
4815 ProfileEntryHookStub stub(masm->isolate()); | 4832 ProfileEntryHookStub stub(masm->isolate()); |
4816 __ push(ra); | 4833 __ push(ra); |
4817 __ CallStub(&stub); | 4834 __ CallStub(&stub); |
4818 __ pop(ra); | 4835 __ pop(ra); |
4819 } | 4836 } |
(...skipping 674 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5494 kStackUnwindSpace, kInvalidStackOffset, | 5511 kStackUnwindSpace, kInvalidStackOffset, |
5495 MemOperand(fp, 6 * kPointerSize), NULL); | 5512 MemOperand(fp, 6 * kPointerSize), NULL); |
5496 } | 5513 } |
5497 | 5514 |
5498 | 5515 |
5499 #undef __ | 5516 #undef __ |
5500 | 5517 |
5501 } } // namespace v8::internal | 5518 } } // namespace v8::internal |
5502 | 5519 |
5503 #endif // V8_TARGET_ARCH_MIPS | 5520 #endif // V8_TARGET_ARCH_MIPS |
OLD | NEW |