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

Side by Side Diff: src/mips/code-stubs-mips.cc

Issue 1050943004: Revert "MIPS: Vector-ICs - speed towards the monomorphic exit as quickly as possible." (Closed) Base URL: https://chromium.googlesource.com/v8/v8.git@master
Patch Set: Created 5 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
« no previous file with comments | « no previous file | src/mips64/code-stubs-mips64.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 // 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
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(&not_array, ne, at, Operand(scratch1)); 4743 __ Branch(&not_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(&not_array); 4747 __ bind(&not_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(&not_array, ne, at, Operand(scratch1)); 4796 __ Branch(&not_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(&not_array); 4805 __ bind(&not_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
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
OLDNEW
« no previous file with comments | « no previous file | src/mips64/code-stubs-mips64.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698