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" |
11 #include "src/code-stubs.h" | 11 #include "src/code-stubs.h" |
12 #include "src/codegen.h" | 12 #include "src/codegen.h" |
13 #include "src/ic/handler-compiler.h" | 13 #include "src/ic/handler-compiler.h" |
14 #include "src/ic/ic.h" | 14 #include "src/ic/ic.h" |
| 15 #include "src/ic/stub-cache.h" |
15 #include "src/isolate.h" | 16 #include "src/isolate.h" |
16 #include "src/jsregexp.h" | 17 #include "src/jsregexp.h" |
17 #include "src/regexp-macro-assembler.h" | 18 #include "src/regexp-macro-assembler.h" |
18 #include "src/runtime/runtime.h" | 19 #include "src/runtime/runtime.h" |
19 | 20 |
20 namespace v8 { | 21 namespace v8 { |
21 namespace internal { | 22 namespace internal { |
22 | 23 |
23 | 24 |
24 static void InitializeArrayConstructorDescriptor( | 25 static void InitializeArrayConstructorDescriptor( |
(...skipping 4522 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4547 } | 4548 } |
4548 masm->LeaveFrame(StackFrame::STUB_FAILURE_TRAMPOLINE); | 4549 masm->LeaveFrame(StackFrame::STUB_FAILURE_TRAMPOLINE); |
4549 __ sll(a1, a1, kPointerSizeLog2); | 4550 __ sll(a1, a1, kPointerSizeLog2); |
4550 __ Ret(USE_DELAY_SLOT); | 4551 __ Ret(USE_DELAY_SLOT); |
4551 __ Addu(sp, sp, a1); | 4552 __ Addu(sp, sp, a1); |
4552 } | 4553 } |
4553 | 4554 |
4554 | 4555 |
4555 void LoadICTrampolineStub::Generate(MacroAssembler* masm) { | 4556 void LoadICTrampolineStub::Generate(MacroAssembler* masm) { |
4556 EmitLoadTypeFeedbackVector(masm, VectorLoadICDescriptor::VectorRegister()); | 4557 EmitLoadTypeFeedbackVector(masm, VectorLoadICDescriptor::VectorRegister()); |
4557 VectorLoadStub stub(isolate(), state()); | 4558 VectorRawLoadStub stub(isolate(), state()); |
4558 __ Jump(stub.GetCode(), RelocInfo::CODE_TARGET); | 4559 stub.GenerateForTrampoline(masm); |
4559 } | 4560 } |
4560 | 4561 |
4561 | 4562 |
4562 void KeyedLoadICTrampolineStub::Generate(MacroAssembler* masm) { | 4563 void KeyedLoadICTrampolineStub::Generate(MacroAssembler* masm) { |
4563 EmitLoadTypeFeedbackVector(masm, VectorLoadICDescriptor::VectorRegister()); | 4564 EmitLoadTypeFeedbackVector(masm, VectorLoadICDescriptor::VectorRegister()); |
4564 VectorKeyedLoadStub stub(isolate()); | 4565 VectorRawKeyedLoadStub stub(isolate()); |
4565 __ Jump(stub.GetCode(), RelocInfo::CODE_TARGET); | 4566 stub.GenerateForTrampoline(masm); |
4566 } | 4567 } |
4567 | 4568 |
4568 | 4569 |
4569 void CallICTrampolineStub::Generate(MacroAssembler* masm) { | 4570 void CallICTrampolineStub::Generate(MacroAssembler* masm) { |
4570 EmitLoadTypeFeedbackVector(masm, a2); | 4571 EmitLoadTypeFeedbackVector(masm, a2); |
4571 CallICStub stub(isolate(), state()); | 4572 CallICStub stub(isolate(), state()); |
4572 __ Jump(stub.GetCode(), RelocInfo::CODE_TARGET); | 4573 __ Jump(stub.GetCode(), RelocInfo::CODE_TARGET); |
4573 } | 4574 } |
4574 | 4575 |
4575 | 4576 |
4576 void CallIC_ArrayTrampolineStub::Generate(MacroAssembler* masm) { | 4577 void CallIC_ArrayTrampolineStub::Generate(MacroAssembler* masm) { |
4577 EmitLoadTypeFeedbackVector(masm, a2); | 4578 EmitLoadTypeFeedbackVector(masm, a2); |
4578 CallIC_ArrayStub stub(isolate(), state()); | 4579 CallIC_ArrayStub stub(isolate(), state()); |
4579 __ Jump(stub.GetCode(), RelocInfo::CODE_TARGET); | 4580 __ Jump(stub.GetCode(), RelocInfo::CODE_TARGET); |
4580 } | 4581 } |
4581 | 4582 |
4582 | 4583 |
| 4584 void VectorRawLoadStub::Generate(MacroAssembler* masm) { |
| 4585 GenerateImpl(masm, false); |
| 4586 } |
| 4587 |
| 4588 |
| 4589 void VectorRawLoadStub::GenerateForTrampoline(MacroAssembler* masm) { |
| 4590 GenerateImpl(masm, true); |
| 4591 } |
| 4592 |
| 4593 |
| 4594 static void HandleArrayCases(MacroAssembler* masm, Register receiver, |
| 4595 Register key, Register vector, Register slot, |
| 4596 Register feedback, Register scratch1, |
| 4597 Register scratch2, Register scratch3, |
| 4598 bool is_polymorphic, Label* miss) { |
| 4599 // feedback initially contains the feedback array |
| 4600 Label next_loop, prepare_next; |
| 4601 Label load_smi_map, compare_map; |
| 4602 Label start_polymorphic; |
| 4603 |
| 4604 Register receiver_map = scratch1; |
| 4605 Register cached_map = scratch2; |
| 4606 |
| 4607 // Receiver might not be a heap object. |
| 4608 __ JumpIfSmi(receiver, &load_smi_map); |
| 4609 __ lw(receiver_map, FieldMemOperand(receiver, HeapObject::kMapOffset)); |
| 4610 __ bind(&compare_map); |
| 4611 __ lw(cached_map, |
| 4612 FieldMemOperand(feedback, FixedArray::OffsetOfElementAt(0))); |
| 4613 __ lw(cached_map, FieldMemOperand(cached_map, WeakCell::kValueOffset)); |
| 4614 __ Branch(&start_polymorphic, ne, receiver_map, Operand(cached_map)); |
| 4615 // found, now call handler. |
| 4616 Register handler = feedback; |
| 4617 __ lw(handler, FieldMemOperand(feedback, FixedArray::OffsetOfElementAt(1))); |
| 4618 __ Addu(t9, handler, Operand(Code::kHeaderSize - kHeapObjectTag)); |
| 4619 __ Jump(t9); |
| 4620 |
| 4621 |
| 4622 Register length = scratch3; |
| 4623 __ bind(&start_polymorphic); |
| 4624 __ lw(length, FieldMemOperand(feedback, FixedArray::kLengthOffset)); |
| 4625 if (!is_polymorphic) { |
| 4626 // If the IC could be monomorphic we have to make sure we don't go past the |
| 4627 // end of the feedback array. |
| 4628 __ Branch(miss, eq, length, Operand(Smi::FromInt(2))); |
| 4629 } |
| 4630 |
| 4631 Register too_far = length; |
| 4632 Register pointer_reg = feedback; |
| 4633 |
| 4634 // +-----+------+------+-----+-----+ ... ----+ |
| 4635 // | map | len | wm0 | h0 | wm1 | hN | |
| 4636 // +-----+------+------+-----+-----+ ... ----+ |
| 4637 // 0 1 2 len-1 |
| 4638 // ^ ^ |
| 4639 // | | |
| 4640 // pointer_reg too_far |
| 4641 // aka feedback scratch3 |
| 4642 // also need receiver_map (aka scratch1) |
| 4643 // use cached_map (scratch2) to look in the weak map values. |
| 4644 __ sll(at, length, kPointerSizeLog2 - kSmiTagSize); |
| 4645 __ Addu(too_far, feedback, Operand(at)); |
| 4646 __ Addu(too_far, too_far, Operand(FixedArray::kHeaderSize - kHeapObjectTag)); |
| 4647 __ Addu(pointer_reg, feedback, |
| 4648 Operand(FixedArray::OffsetOfElementAt(2) - kHeapObjectTag)); |
| 4649 |
| 4650 __ bind(&next_loop); |
| 4651 __ lw(cached_map, MemOperand(pointer_reg)); |
| 4652 __ lw(cached_map, FieldMemOperand(cached_map, WeakCell::kValueOffset)); |
| 4653 __ Branch(&prepare_next, ne, receiver_map, Operand(cached_map)); |
| 4654 __ lw(handler, MemOperand(pointer_reg, kPointerSize)); |
| 4655 __ Addu(t9, handler, Operand(Code::kHeaderSize - kHeapObjectTag)); |
| 4656 __ Jump(t9); |
| 4657 |
| 4658 __ bind(&prepare_next); |
| 4659 __ Addu(pointer_reg, pointer_reg, Operand(kPointerSize * 2)); |
| 4660 __ Branch(&next_loop, lt, pointer_reg, Operand(too_far)); |
| 4661 |
| 4662 // We exhausted our array of map handler pairs. |
| 4663 __ jmp(miss); |
| 4664 |
| 4665 __ bind(&load_smi_map); |
| 4666 __ LoadRoot(receiver_map, Heap::kHeapNumberMapRootIndex); |
| 4667 __ jmp(&compare_map); |
| 4668 } |
| 4669 |
| 4670 |
| 4671 static void HandleMonomorphicCase(MacroAssembler* masm, Register receiver, |
| 4672 Register key, Register vector, Register slot, |
| 4673 Register weak_cell, Register scratch, |
| 4674 Label* miss) { |
| 4675 // feedback initially contains the feedback array |
| 4676 Label compare_smi_map; |
| 4677 Register receiver_map = scratch; |
| 4678 Register cached_map = weak_cell; |
| 4679 |
| 4680 // Move the weak map into the weak_cell register. |
| 4681 __ lw(cached_map, FieldMemOperand(weak_cell, WeakCell::kValueOffset)); |
| 4682 |
| 4683 // Receiver might not be a heap object. |
| 4684 __ JumpIfSmi(receiver, &compare_smi_map); |
| 4685 __ lw(receiver_map, FieldMemOperand(receiver, HeapObject::kMapOffset)); |
| 4686 __ Branch(miss, ne, cached_map, Operand(receiver_map)); |
| 4687 |
| 4688 Register handler = weak_cell; |
| 4689 __ sll(at, slot, kPointerSizeLog2 - kSmiTagSize); |
| 4690 __ Addu(handler, vector, Operand(at)); |
| 4691 __ lw(handler, |
| 4692 FieldMemOperand(handler, FixedArray::kHeaderSize + kPointerSize)); |
| 4693 __ Addu(t9, handler, Operand(Code::kHeaderSize - kHeapObjectTag)); |
| 4694 __ Jump(t9); |
| 4695 |
| 4696 // In microbenchmarks, it made sense to unroll this code so that the call to |
| 4697 // the handler is duplicated for a HeapObject receiver and a Smi receiver. |
| 4698 __ bind(&compare_smi_map); |
| 4699 __ LoadRoot(at, Heap::kHeapNumberMapRootIndex); |
| 4700 __ Branch(miss, ne, at, Operand(weak_cell)); |
| 4701 __ sll(at, slot, kPointerSizeLog2 - kSmiTagSize); |
| 4702 __ Addu(handler, vector, Operand(at)); |
| 4703 __ lw(handler, |
| 4704 FieldMemOperand(handler, FixedArray::kHeaderSize + kPointerSize)); |
| 4705 __ Addu(t9, handler, Operand(Code::kHeaderSize - kHeapObjectTag)); |
| 4706 __ Jump(t9); |
| 4707 } |
| 4708 |
| 4709 |
| 4710 void VectorRawLoadStub::GenerateImpl(MacroAssembler* masm, bool in_frame) { |
| 4711 Register receiver = VectorLoadICDescriptor::ReceiverRegister(); // a1 |
| 4712 Register name = VectorLoadICDescriptor::NameRegister(); // a2 |
| 4713 Register vector = VectorLoadICDescriptor::VectorRegister(); // a3 |
| 4714 Register slot = VectorLoadICDescriptor::SlotRegister(); // a0 |
| 4715 Register feedback = t0; |
| 4716 Register scratch1 = t1; |
| 4717 |
| 4718 __ sll(at, slot, kPointerSizeLog2 - kSmiTagSize); |
| 4719 __ Addu(feedback, vector, Operand(at)); |
| 4720 __ lw(feedback, FieldMemOperand(feedback, FixedArray::kHeaderSize)); |
| 4721 |
| 4722 // Is it a weak cell? |
| 4723 Label try_array; |
| 4724 Label not_array, smi_key, key_okay, miss; |
| 4725 __ lw(scratch1, FieldMemOperand(feedback, HeapObject::kMapOffset)); |
| 4726 __ LoadRoot(at, Heap::kWeakCellMapRootIndex); |
| 4727 __ Branch(&try_array, ne, at, Operand(scratch1)); |
| 4728 HandleMonomorphicCase(masm, receiver, name, vector, slot, feedback, scratch1, |
| 4729 &miss); |
| 4730 |
| 4731 // Is it a fixed array? |
| 4732 __ bind(&try_array); |
| 4733 __ LoadRoot(at, Heap::kFixedArrayMapRootIndex); |
| 4734 __ Branch(¬_array, ne, at, Operand(scratch1)); |
| 4735 HandleArrayCases(masm, receiver, name, vector, slot, feedback, scratch1, t4, |
| 4736 t5, true, &miss); |
| 4737 |
| 4738 __ bind(¬_array); |
| 4739 __ LoadRoot(at, Heap::kmegamorphic_symbolRootIndex); |
| 4740 __ Branch(&miss, ne, at, Operand(feedback)); |
| 4741 Code::Flags code_flags = Code::RemoveTypeAndHolderFromFlags( |
| 4742 Code::ComputeHandlerFlags(Code::LOAD_IC)); |
| 4743 masm->isolate()->stub_cache()->GenerateProbe(masm, Code::LOAD_IC, code_flags, |
| 4744 false, receiver, name, feedback, |
| 4745 scratch1, t4, t5); |
| 4746 |
| 4747 __ bind(&miss); |
| 4748 LoadIC::GenerateMiss(masm); |
| 4749 } |
| 4750 |
| 4751 |
| 4752 void VectorRawKeyedLoadStub::Generate(MacroAssembler* masm) { |
| 4753 GenerateImpl(masm, false); |
| 4754 } |
| 4755 |
| 4756 |
| 4757 void VectorRawKeyedLoadStub::GenerateForTrampoline(MacroAssembler* masm) { |
| 4758 GenerateImpl(masm, true); |
| 4759 } |
| 4760 |
| 4761 |
| 4762 void VectorRawKeyedLoadStub::GenerateImpl(MacroAssembler* masm, bool in_frame) { |
| 4763 Register receiver = VectorLoadICDescriptor::ReceiverRegister(); // a1 |
| 4764 Register key = VectorLoadICDescriptor::NameRegister(); // a2 |
| 4765 Register vector = VectorLoadICDescriptor::VectorRegister(); // a3 |
| 4766 Register slot = VectorLoadICDescriptor::SlotRegister(); // a0 |
| 4767 Register feedback = t0; |
| 4768 Register scratch1 = t1; |
| 4769 |
| 4770 __ sll(at, slot, kPointerSizeLog2 - kSmiTagSize); |
| 4771 __ Addu(feedback, vector, Operand(at)); |
| 4772 __ lw(feedback, FieldMemOperand(feedback, FixedArray::kHeaderSize)); |
| 4773 |
| 4774 // Is it a weak cell? |
| 4775 Label try_array; |
| 4776 Label not_array, smi_key, key_okay, miss; |
| 4777 __ lw(scratch1, FieldMemOperand(feedback, HeapObject::kMapOffset)); |
| 4778 __ LoadRoot(at, Heap::kWeakCellMapRootIndex); |
| 4779 __ Branch(&try_array, ne, at, Operand(scratch1)); |
| 4780 __ JumpIfNotSmi(key, &miss); |
| 4781 HandleMonomorphicCase(masm, receiver, key, vector, slot, feedback, scratch1, |
| 4782 &miss); |
| 4783 |
| 4784 __ bind(&try_array); |
| 4785 // Is it a fixed array? |
| 4786 __ LoadRoot(at, Heap::kFixedArrayMapRootIndex); |
| 4787 __ Branch(¬_array, ne, at, Operand(scratch1)); |
| 4788 // We have a polymorphic element handler. |
| 4789 __ JumpIfNotSmi(key, &miss); |
| 4790 |
| 4791 Label polymorphic, try_poly_name; |
| 4792 __ bind(&polymorphic); |
| 4793 HandleArrayCases(masm, receiver, key, vector, slot, feedback, scratch1, t4, |
| 4794 t5, true, &miss); |
| 4795 |
| 4796 __ bind(¬_array); |
| 4797 // Is it generic? |
| 4798 __ LoadRoot(at, Heap::kmegamorphic_symbolRootIndex); |
| 4799 __ Branch(&try_poly_name, ne, at, Operand(feedback)); |
| 4800 Handle<Code> megamorphic_stub = |
| 4801 KeyedLoadIC::ChooseMegamorphicStub(masm->isolate()); |
| 4802 __ Jump(megamorphic_stub, RelocInfo::CODE_TARGET); |
| 4803 |
| 4804 __ bind(&try_poly_name); |
| 4805 // We might have a name in feedback, and a fixed array in the next slot. |
| 4806 __ Branch(&miss, ne, key, Operand(feedback)); |
| 4807 // If the name comparison succeeded, we know we have a fixed array with |
| 4808 // at least one map/handler pair. |
| 4809 __ sll(at, slot, kPointerSizeLog2 - kSmiTagSize); |
| 4810 __ Addu(feedback, vector, Operand(at)); |
| 4811 __ lw(feedback, |
| 4812 FieldMemOperand(feedback, FixedArray::kHeaderSize + kPointerSize)); |
| 4813 HandleArrayCases(masm, receiver, key, vector, slot, feedback, scratch1, t4, |
| 4814 t5, false, &miss); |
| 4815 |
| 4816 __ bind(&miss); |
| 4817 KeyedLoadIC::GenerateMiss(masm); |
| 4818 } |
| 4819 |
| 4820 |
4583 void ProfileEntryHookStub::MaybeCallEntryHook(MacroAssembler* masm) { | 4821 void ProfileEntryHookStub::MaybeCallEntryHook(MacroAssembler* masm) { |
4584 if (masm->isolate()->function_entry_hook() != NULL) { | 4822 if (masm->isolate()->function_entry_hook() != NULL) { |
4585 ProfileEntryHookStub stub(masm->isolate()); | 4823 ProfileEntryHookStub stub(masm->isolate()); |
4586 __ push(ra); | 4824 __ push(ra); |
4587 __ CallStub(&stub); | 4825 __ CallStub(&stub); |
4588 __ pop(ra); | 4826 __ pop(ra); |
4589 } | 4827 } |
4590 } | 4828 } |
4591 | 4829 |
4592 | 4830 |
(...skipping 671 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5264 kStackUnwindSpace, kInvalidStackOffset, | 5502 kStackUnwindSpace, kInvalidStackOffset, |
5265 MemOperand(fp, 6 * kPointerSize), NULL); | 5503 MemOperand(fp, 6 * kPointerSize), NULL); |
5266 } | 5504 } |
5267 | 5505 |
5268 | 5506 |
5269 #undef __ | 5507 #undef __ |
5270 | 5508 |
5271 } } // namespace v8::internal | 5509 } } // namespace v8::internal |
5272 | 5510 |
5273 #endif // V8_TARGET_ARCH_MIPS | 5511 #endif // V8_TARGET_ARCH_MIPS |
OLD | NEW |