src/mips64/code-stubs-mips64.cc - Issue 1050943004: Revert "MIPS: Vector-ICs - speed towards the monomorphic exit as quickly as possible."

Unified Diff: src/mips64/code-stubs-mips64.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 side-by-side diff with in-line comments

Download patch

Index: src/mips64/code-stubs-mips64.cc

diff --git a/src/mips64/code-stubs-mips64.cc b/src/mips64/code-stubs-mips64.cc

index 02acdb0c4fbfc46c57a3a3319ab764e79f3b8da1..11234e1891b62a1e598e768ad3ea036d4c0e7726 100644

--- a/src/mips64/code-stubs-mips64.cc

+++ b/src/mips64/code-stubs-mips64.cc

@@ -4646,15 +4646,21 @@ void VectorRawLoadStub::GenerateForTrampoline(MacroAssembler* masm) {

static void HandleArrayCases(MacroAssembler* masm, Register receiver,

- Register feedback, Register receiver_map,

- Register scratch1, Register scratch2,

+ Register feedback, Register scratch1,

+ Register scratch2, Register scratch3,

bool is_polymorphic, Label* miss) {

// feedback initially contains the feedback array

Label next_loop, prepare_next;

+ Label load_smi_map, compare_map;

Label start_polymorphic;

- Register cached_map = scratch1;

+ Register receiver_map = scratch1;

+ Register cached_map = scratch2;

+ // Receiver might not be a heap object.

+ __ JumpIfSmi(receiver, &load_smi_map);

+ __ ld(receiver_map, FieldMemOperand(receiver, HeapObject::kMapOffset));

+ __ bind(&compare_map);

__ ld(cached_map,

FieldMemOperand(feedback, FixedArray::OffsetOfElementAt(0)));

__ ld(cached_map, FieldMemOperand(cached_map, WeakCell::kValueOffset));

@@ -4665,7 +4671,7 @@ static void HandleArrayCases(MacroAssembler* masm, Register receiver,

__ Daddu(t9, handler, Operand(Code::kHeaderSize - kHeapObjectTag));

__ Jump(t9);

- Register length = scratch2;

+ Register length = scratch3;

__ bind(&start_polymorphic);

__ ld(length, FieldMemOperand(feedback, FixedArray::kLengthOffset));

if (!is_polymorphic) {

@@ -4684,9 +4690,9 @@ static void HandleArrayCases(MacroAssembler* masm, Register receiver,

// ^ ^

// | |

// pointer_reg too_far

- // aka feedback scratch2

- // also need receiver_map

- // use cached_map (scratch1) to look in the weak map values.

+ // aka feedback scratch3

+ // also need receiver_map (aka scratch1)

+ // use cached_map (scratch2) to look in the weak map values.

__ SmiScale(too_far, length, kPointerSizeLog2);

__ Daddu(too_far, feedback, Operand(too_far));

__ Daddu(too_far, too_far, Operand(FixedArray::kHeaderSize - kHeapObjectTag));

@@ -4707,22 +4713,44 @@ static void HandleArrayCases(MacroAssembler* masm, Register receiver,

// We exhausted our array of map handler pairs.

__ Branch(miss);

+ __ bind(&load_smi_map);

+ __ LoadRoot(receiver_map, Heap::kHeapNumberMapRootIndex);

+ __ Branch(&compare_map);

}

static void HandleMonomorphicCase(MacroAssembler* masm, Register receiver,

- Register receiver_map, Register feedback,

- Register vector, Register slot,

- Register scratch, Label* compare_map,

- Label* load_smi_map, Label* try_array) {

- __ JumpIfSmi(receiver, load_smi_map);

- __ ld(receiver_map, FieldMemOperand(receiver, HeapObject::kMapOffset));

- __ bind(compare_map);

- Register cached_map = scratch;

+ Register key, Register vector, Register slot,

+ Register weak_cell, Register scratch,

+ Label* miss) {

+ // feedback initially contains the feedback array

+ Label compare_smi_map;

+ Register receiver_map = scratch;

+ Register cached_map = weak_cell;

// Move the weak map into the weak_cell register.

- __ ld(cached_map, FieldMemOperand(feedback, WeakCell::kValueOffset));

- __ Branch(try_array, ne, cached_map, Operand(receiver_map));

- Register handler = feedback;

+ __ ld(cached_map, FieldMemOperand(weak_cell, WeakCell::kValueOffset));

+ // Receiver might not be a heap object.

+ __ JumpIfSmi(receiver, &compare_smi_map);

+ __ ld(receiver_map, FieldMemOperand(receiver, HeapObject::kMapOffset));

+ __ Branch(miss, ne, cached_map, Operand(receiver_map));

+ Register handler = weak_cell;

+ __ SmiScale(handler, slot, kPointerSizeLog2);

+ __ Daddu(handler, vector, Operand(handler));

+ __ ld(handler,

+ FieldMemOperand(handler, FixedArray::kHeaderSize + kPointerSize));

+ __ Daddu(t9, handler, Code::kHeaderSize - kHeapObjectTag);

+ __ Jump(t9);

+ // In microbenchmarks, it made sense to unroll this code so that the call to

+ // the handler is duplicated for a HeapObject receiver and a Smi receiver.

+ // TODO(mvstanton): does this hold on ARM?

+ __ bind(&compare_smi_map);

+ __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);

+ __ Branch(miss, ne, weak_cell, Operand(at));

__ SmiScale(handler, slot, kPointerSizeLog2);

__ Daddu(handler, vector, Operand(handler));

__ ld(handler,

@@ -4738,28 +4766,27 @@ void VectorRawLoadStub::GenerateImpl(MacroAssembler* masm, bool in_frame) {

- Register receiver_map = a5;

- Register scratch1 = a6;

+ Register scratch1 = a5;

__ SmiScale(feedback, slot, kPointerSizeLog2);

__ Daddu(feedback, vector, Operand(feedback));

__ ld(feedback, FieldMemOperand(feedback, FixedArray::kHeaderSize));

- // Try to quickly handle the monomorphic case without knowing for sure

- // if we have a weak cell in feedback. We do know it's safe to look

- // at WeakCell::kValueOffset.

- Label try_array, load_smi_map, compare_map;

- Label not_array, miss;

- HandleMonomorphicCase(masm, receiver, receiver_map, feedback, vector, slot,

- scratch1, &compare_map, &load_smi_map, &try_array);

+ // Is it a weak cell?

+ Label try_array;

+ Label not_array, smi_key, key_okay, miss;

+ __ ld(scratch1, FieldMemOperand(feedback, HeapObject::kMapOffset));

+ __ LoadRoot(at, Heap::kWeakCellMapRootIndex);

+ __ Branch(&try_array, ne, scratch1, Operand(at));

+ HandleMonomorphicCase(masm, receiver, name, vector, slot, feedback, scratch1,

+ &miss);

// Is it a fixed array?

__ bind(&try_array);

- __ ld(scratch1, FieldMemOperand(feedback, HeapObject::kMapOffset));

__ LoadRoot(at, Heap::kFixedArrayMapRootIndex);

__ Branch(&not_array, ne, scratch1, Operand(at));

- HandleArrayCases(masm, receiver, name, vector, slot, feedback, receiver_map,

- scratch1, a7, true, &miss);

+ HandleArrayCases(masm, receiver, name, vector, slot, feedback, scratch1, a6,

+ a7, true, &miss);

__ bind(&not_array);

__ LoadRoot(at, Heap::kmegamorphic_symbolRootIndex);

@@ -4768,14 +4795,10 @@ void VectorRawLoadStub::GenerateImpl(MacroAssembler* masm, bool in_frame) {

Code::ComputeHandlerFlags(Code::LOAD_IC));

masm->isolate()->stub_cache()->GenerateProbe(masm, Code::LOAD_IC, code_flags,

false, receiver, name, feedback,

- receiver_map, scratch1, a7);

+ scratch1, a6, a7);

__ bind(&miss);

LoadIC::GenerateMiss(masm);

- __ bind(&load_smi_map);

- __ LoadRoot(receiver_map, Heap::kHeapNumberMapRootIndex);

- __ Branch(&compare_map);

}

@@ -4795,24 +4818,24 @@ void VectorRawKeyedLoadStub::GenerateImpl(MacroAssembler* masm, bool in_frame) {

- Register receiver_map = a5;

- Register scratch1 = a6;

+ Register scratch1 = a5;

__ SmiScale(feedback, slot, kPointerSizeLog2);

__ Daddu(feedback, vector, Operand(feedback));

__ ld(feedback, FieldMemOperand(feedback, FixedArray::kHeaderSize));

- // Try to quickly handle the monomorphic case without knowing for sure

- // if we have a weak cell in feedback. We do know it's safe to look

- // at WeakCell::kValueOffset.

- Label try_array, load_smi_map, compare_map;

- Label not_array, miss;

- HandleMonomorphicCase(masm, receiver, receiver_map, feedback, vector, slot,

- scratch1, &compare_map, &load_smi_map, &try_array);

+ // Is it a weak cell?

+ Label try_array;

+ Label not_array, smi_key, key_okay, miss;

+ __ ld(scratch1, FieldMemOperand(feedback, HeapObject::kMapOffset));

+ __ LoadRoot(at, Heap::kWeakCellMapRootIndex);

+ __ Branch(&try_array, ne, scratch1, Operand(at));

+ __ JumpIfNotSmi(key, &miss);

+ HandleMonomorphicCase(masm, receiver, key, vector, slot, feedback, scratch1,

+ &miss);

__ bind(&try_array);

// Is it a fixed array?

- __ ld(scratch1, FieldMemOperand(feedback, HeapObject::kMapOffset));

__ LoadRoot(at, Heap::kFixedArrayMapRootIndex);

__ Branch(&not_array, ne, scratch1, Operand(at));

// We have a polymorphic element handler.

@@ -4820,8 +4843,8 @@ void VectorRawKeyedLoadStub::GenerateImpl(MacroAssembler* masm, bool in_frame) {

Label polymorphic, try_poly_name;

__ bind(&polymorphic);

- HandleArrayCases(masm, receiver, key, vector, slot, feedback, receiver_map,

- scratch1, a7, true, &miss);

+ HandleArrayCases(masm, receiver, key, vector, slot, feedback, scratch1, a6,

+ a7, true, &miss);

__ bind(&not_array);

// Is it generic?

@@ -4840,15 +4863,11 @@ void VectorRawKeyedLoadStub::GenerateImpl(MacroAssembler* masm, bool in_frame) {

__ Daddu(feedback, vector, Operand(feedback));

__ ld(feedback,

FieldMemOperand(feedback, FixedArray::kHeaderSize + kPointerSize));

- HandleArrayCases(masm, receiver, key, vector, slot, feedback, receiver_map,

- scratch1, a7, false, &miss);

+ HandleArrayCases(masm, receiver, key, vector, slot, feedback, scratch1, a6,

+ a7, false, &miss);

__ bind(&miss);

KeyedLoadIC::GenerateMiss(masm);

- __ bind(&load_smi_map);

- __ LoadRoot(receiver_map, Heap::kHeapNumberMapRootIndex);

- __ Branch(&compare_map);

}

« no previous file with comments | « src/mips/code-stubs-mips.cc ('k') | no next file » | no next file with comments »