| Index: src/s390/code-stubs-s390.cc
|
| diff --git a/src/s390/code-stubs-s390.cc b/src/s390/code-stubs-s390.cc
|
| index 553d6d8ce4cac546e4447226a8c09fcce6ad843a..2f8d10badb622da1a935ab7b123c78338f9b6040 100644
|
| --- a/src/s390/code-stubs-s390.cc
|
| +++ b/src/s390/code-stubs-s390.cc
|
| @@ -3145,240 +3145,6 @@ void CallICTrampolineStub::Generate(MacroAssembler* masm) {
|
| __ Jump(stub.GetCode(), RelocInfo::CODE_TARGET);
|
| }
|
|
|
| -static void HandleArrayCases(MacroAssembler* masm, Register feedback,
|
| - Register receiver_map, Register scratch1,
|
| - Register scratch2, bool is_polymorphic,
|
| - Label* miss) {
|
| - // feedback initially contains the feedback array
|
| - Label next_loop, prepare_next;
|
| - Label start_polymorphic;
|
| -
|
| - Register cached_map = scratch1;
|
| -
|
| - __ LoadP(cached_map,
|
| - FieldMemOperand(feedback, FixedArray::OffsetOfElementAt(0)));
|
| - __ LoadP(cached_map, FieldMemOperand(cached_map, WeakCell::kValueOffset));
|
| - __ CmpP(receiver_map, cached_map);
|
| - __ bne(&start_polymorphic, Label::kNear);
|
| - // found, now call handler.
|
| - Register handler = feedback;
|
| - __ LoadP(handler,
|
| - FieldMemOperand(feedback, FixedArray::OffsetOfElementAt(1)));
|
| - __ AddP(ip, handler, Operand(Code::kHeaderSize - kHeapObjectTag));
|
| - __ Jump(ip);
|
| -
|
| - Register length = scratch2;
|
| - __ bind(&start_polymorphic);
|
| - __ LoadP(length, FieldMemOperand(feedback, FixedArray::kLengthOffset));
|
| - if (!is_polymorphic) {
|
| - // If the IC could be monomorphic we have to make sure we don't go past the
|
| - // end of the feedback array.
|
| - __ CmpSmiLiteral(length, Smi::FromInt(2), r0);
|
| - __ beq(miss);
|
| - }
|
| -
|
| - Register too_far = length;
|
| - Register pointer_reg = feedback;
|
| -
|
| - // +-----+------+------+-----+-----+ ... ----+
|
| - // | map | len | wm0 | h0 | wm1 | hN |
|
| - // +-----+------+------+-----+-----+ ... ----+
|
| - // 0 1 2 len-1
|
| - // ^ ^
|
| - // | |
|
| - // pointer_reg too_far
|
| - // aka feedback scratch2
|
| - // also need receiver_map
|
| - // use cached_map (scratch1) to look in the weak map values.
|
| - __ SmiToPtrArrayOffset(r0, length);
|
| - __ AddP(too_far, feedback, r0);
|
| - __ AddP(too_far, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
|
| - __ AddP(pointer_reg, feedback,
|
| - Operand(FixedArray::OffsetOfElementAt(2) - kHeapObjectTag));
|
| -
|
| - __ bind(&next_loop);
|
| - __ LoadP(cached_map, MemOperand(pointer_reg));
|
| - __ LoadP(cached_map, FieldMemOperand(cached_map, WeakCell::kValueOffset));
|
| - __ CmpP(receiver_map, cached_map);
|
| - __ bne(&prepare_next, Label::kNear);
|
| - __ LoadP(handler, MemOperand(pointer_reg, kPointerSize));
|
| - __ AddP(ip, handler, Operand(Code::kHeaderSize - kHeapObjectTag));
|
| - __ Jump(ip);
|
| -
|
| - __ bind(&prepare_next);
|
| - __ AddP(pointer_reg, Operand(kPointerSize * 2));
|
| - __ CmpP(pointer_reg, too_far);
|
| - __ blt(&next_loop, Label::kNear);
|
| -
|
| - // We exhausted our array of map handler pairs.
|
| - __ b(miss);
|
| -}
|
| -
|
| -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);
|
| - __ LoadP(receiver_map, FieldMemOperand(receiver, HeapObject::kMapOffset));
|
| - __ bind(compare_map);
|
| - Register cached_map = scratch;
|
| - // Move the weak map into the weak_cell register.
|
| - __ LoadP(cached_map, FieldMemOperand(feedback, WeakCell::kValueOffset));
|
| - __ CmpP(cached_map, receiver_map);
|
| - __ bne(try_array);
|
| - Register handler = feedback;
|
| - __ SmiToPtrArrayOffset(r1, slot);
|
| - __ LoadP(handler,
|
| - FieldMemOperand(r1, vector, FixedArray::kHeaderSize + kPointerSize));
|
| - __ AddP(ip, handler, Operand(Code::kHeaderSize - kHeapObjectTag));
|
| - __ Jump(ip);
|
| -}
|
| -
|
| -void KeyedStoreICTrampolineStub::Generate(MacroAssembler* masm) {
|
| - __ EmitLoadTypeFeedbackVector(StoreWithVectorDescriptor::VectorRegister());
|
| - KeyedStoreICStub stub(isolate(), state());
|
| - stub.GenerateForTrampoline(masm);
|
| -}
|
| -
|
| -void KeyedStoreICStub::Generate(MacroAssembler* masm) {
|
| - GenerateImpl(masm, false);
|
| -}
|
| -
|
| -void KeyedStoreICStub::GenerateForTrampoline(MacroAssembler* masm) {
|
| - GenerateImpl(masm, true);
|
| -}
|
| -
|
| -static void HandlePolymorphicStoreCase(MacroAssembler* masm, Register feedback,
|
| - Register receiver_map, Register scratch1,
|
| - Register scratch2, Label* miss) {
|
| - // feedback initially contains the feedback array
|
| - Label next_loop, prepare_next;
|
| - Label start_polymorphic;
|
| - Label transition_call;
|
| -
|
| - Register cached_map = scratch1;
|
| - Register too_far = scratch2;
|
| - Register pointer_reg = feedback;
|
| - __ LoadP(too_far, FieldMemOperand(feedback, FixedArray::kLengthOffset));
|
| -
|
| - // +-----+------+------+-----+-----+-----+ ... ----+
|
| - // | map | len | wm0 | wt0 | h0 | wm1 | hN |
|
| - // +-----+------+------+-----+-----+ ----+ ... ----+
|
| - // 0 1 2 len-1
|
| - // ^ ^
|
| - // | |
|
| - // pointer_reg too_far
|
| - // aka feedback scratch2
|
| - // also need receiver_map
|
| - // use cached_map (scratch1) to look in the weak map values.
|
| - __ SmiToPtrArrayOffset(r0, too_far);
|
| - __ AddP(too_far, feedback, r0);
|
| - __ AddP(too_far, too_far, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
|
| - __ AddP(pointer_reg, feedback,
|
| - Operand(FixedArray::OffsetOfElementAt(0) - kHeapObjectTag));
|
| -
|
| - __ bind(&next_loop);
|
| - __ LoadP(cached_map, MemOperand(pointer_reg));
|
| - __ LoadP(cached_map, FieldMemOperand(cached_map, WeakCell::kValueOffset));
|
| - __ CmpP(receiver_map, cached_map);
|
| - __ bne(&prepare_next);
|
| - // Is it a transitioning store?
|
| - __ LoadP(too_far, MemOperand(pointer_reg, kPointerSize));
|
| - __ CompareRoot(too_far, Heap::kUndefinedValueRootIndex);
|
| - __ bne(&transition_call);
|
| - __ LoadP(pointer_reg, MemOperand(pointer_reg, kPointerSize * 2));
|
| - __ AddP(ip, pointer_reg, Operand(Code::kHeaderSize - kHeapObjectTag));
|
| - __ Jump(ip);
|
| -
|
| - __ bind(&transition_call);
|
| - __ LoadP(too_far, FieldMemOperand(too_far, WeakCell::kValueOffset));
|
| - __ JumpIfSmi(too_far, miss);
|
| -
|
| - __ LoadP(receiver_map, MemOperand(pointer_reg, kPointerSize * 2));
|
| -
|
| - // Load the map into the correct register.
|
| - DCHECK(feedback.is(StoreTransitionDescriptor::MapRegister()));
|
| - __ LoadRR(feedback, too_far);
|
| -
|
| - __ AddP(ip, receiver_map, Operand(Code::kHeaderSize - kHeapObjectTag));
|
| - __ Jump(ip);
|
| -
|
| - __ bind(&prepare_next);
|
| - __ AddP(pointer_reg, pointer_reg, Operand(kPointerSize * 3));
|
| - __ CmpLogicalP(pointer_reg, too_far);
|
| - __ blt(&next_loop);
|
| -
|
| - // We exhausted our array of map handler pairs.
|
| - __ b(miss);
|
| -}
|
| -
|
| -void KeyedStoreICStub::GenerateImpl(MacroAssembler* masm, bool in_frame) {
|
| - Register receiver = StoreWithVectorDescriptor::ReceiverRegister(); // r3
|
| - Register key = StoreWithVectorDescriptor::NameRegister(); // r4
|
| - Register vector = StoreWithVectorDescriptor::VectorRegister(); // r5
|
| - Register slot = StoreWithVectorDescriptor::SlotRegister(); // r6
|
| - DCHECK(StoreWithVectorDescriptor::ValueRegister().is(r2)); // r2
|
| - Register feedback = r7;
|
| - Register receiver_map = r8;
|
| - Register scratch1 = r9;
|
| -
|
| - __ SmiToPtrArrayOffset(r0, slot);
|
| - __ AddP(feedback, vector, r0);
|
| - __ LoadP(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);
|
| -
|
| - __ bind(&try_array);
|
| - // Is it a fixed array?
|
| - __ LoadP(scratch1, FieldMemOperand(feedback, HeapObject::kMapOffset));
|
| - __ CompareRoot(scratch1, Heap::kFixedArrayMapRootIndex);
|
| - __ bne(¬_array);
|
| -
|
| - // We have a polymorphic element handler.
|
| - Label polymorphic, try_poly_name;
|
| - __ bind(&polymorphic);
|
| -
|
| - Register scratch2 = ip;
|
| -
|
| - HandlePolymorphicStoreCase(masm, feedback, receiver_map, scratch1, scratch2,
|
| - &miss);
|
| -
|
| - __ bind(¬_array);
|
| - // Is it generic?
|
| - __ CompareRoot(feedback, Heap::kmegamorphic_symbolRootIndex);
|
| - __ bne(&try_poly_name);
|
| - Handle<Code> megamorphic_stub =
|
| - KeyedStoreIC::ChooseMegamorphicStub(masm->isolate(), GetExtraICState());
|
| - __ Jump(megamorphic_stub, RelocInfo::CODE_TARGET);
|
| -
|
| - __ bind(&try_poly_name);
|
| - // We might have a name in feedback, and a fixed array in the next slot.
|
| - __ CmpP(key, feedback);
|
| - __ bne(&miss);
|
| - // If the name comparison succeeded, we know we have a fixed array with
|
| - // at least one map/handler pair.
|
| - __ SmiToPtrArrayOffset(r0, slot);
|
| - __ AddP(feedback, vector, r0);
|
| - __ LoadP(feedback,
|
| - FieldMemOperand(feedback, FixedArray::kHeaderSize + kPointerSize));
|
| - HandleArrayCases(masm, feedback, receiver_map, scratch1, scratch2, false,
|
| - &miss);
|
| -
|
| - __ bind(&miss);
|
| - KeyedStoreIC::GenerateMiss(masm);
|
| -
|
| - __ bind(&load_smi_map);
|
| - __ LoadRoot(receiver_map, Heap::kHeapNumberMapRootIndex);
|
| - __ b(&compare_map);
|
| -}
|
| -
|
| void ProfileEntryHookStub::MaybeCallEntryHook(MacroAssembler* masm) {
|
| if (masm->isolate()->function_entry_hook() != NULL) {
|
| PredictableCodeSizeScope predictable(masm,
|
|
|