OLD | NEW |
1 // Copyright 2013 the V8 project authors. All rights reserved. | 1 // Copyright 2013 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_X64 | 7 #if V8_TARGET_ARCH_X64 |
8 | 8 |
9 #include "src/bootstrapper.h" | 9 #include "src/bootstrapper.h" |
10 #include "src/code-stubs.h" | 10 #include "src/code-stubs.h" |
11 #include "src/codegen.h" | 11 #include "src/codegen.h" |
12 #include "src/ic/handler-compiler.h" | 12 #include "src/ic/handler-compiler.h" |
13 #include "src/ic/ic.h" | 13 #include "src/ic/ic.h" |
| 14 #include "src/ic/stub-cache.h" |
14 #include "src/isolate.h" | 15 #include "src/isolate.h" |
15 #include "src/jsregexp.h" | 16 #include "src/jsregexp.h" |
16 #include "src/regexp-macro-assembler.h" | 17 #include "src/regexp-macro-assembler.h" |
17 #include "src/runtime/runtime.h" | 18 #include "src/runtime/runtime.h" |
18 | 19 |
19 namespace v8 { | 20 namespace v8 { |
20 namespace internal { | 21 namespace internal { |
21 | 22 |
22 | 23 |
23 static void InitializeArrayConstructorDescriptor( | 24 static void InitializeArrayConstructorDescriptor( |
(...skipping 4306 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4330 __ PopReturnAddressTo(rcx); | 4331 __ PopReturnAddressTo(rcx); |
4331 int additional_offset = | 4332 int additional_offset = |
4332 function_mode() == JS_FUNCTION_STUB_MODE ? kPointerSize : 0; | 4333 function_mode() == JS_FUNCTION_STUB_MODE ? kPointerSize : 0; |
4333 __ leap(rsp, MemOperand(rsp, rbx, times_pointer_size, additional_offset)); | 4334 __ leap(rsp, MemOperand(rsp, rbx, times_pointer_size, additional_offset)); |
4334 __ jmp(rcx); // Return to IC Miss stub, continuation still on stack. | 4335 __ jmp(rcx); // Return to IC Miss stub, continuation still on stack. |
4335 } | 4336 } |
4336 | 4337 |
4337 | 4338 |
4338 void LoadICTrampolineStub::Generate(MacroAssembler* masm) { | 4339 void LoadICTrampolineStub::Generate(MacroAssembler* masm) { |
4339 EmitLoadTypeFeedbackVector(masm, VectorLoadICDescriptor::VectorRegister()); | 4340 EmitLoadTypeFeedbackVector(masm, VectorLoadICDescriptor::VectorRegister()); |
4340 VectorLoadStub stub(isolate(), state()); | 4341 VectorRawLoadStub stub(isolate(), state()); |
4341 __ jmp(stub.GetCode(), RelocInfo::CODE_TARGET); | 4342 stub.GenerateForTrampoline(masm); |
4342 } | 4343 } |
4343 | 4344 |
4344 | 4345 |
4345 void KeyedLoadICTrampolineStub::Generate(MacroAssembler* masm) { | 4346 void KeyedLoadICTrampolineStub::Generate(MacroAssembler* masm) { |
4346 EmitLoadTypeFeedbackVector(masm, VectorLoadICDescriptor::VectorRegister()); | 4347 EmitLoadTypeFeedbackVector(masm, VectorLoadICDescriptor::VectorRegister()); |
4347 VectorKeyedLoadStub stub(isolate()); | 4348 VectorRawKeyedLoadStub stub(isolate()); |
4348 __ jmp(stub.GetCode(), RelocInfo::CODE_TARGET); | 4349 stub.GenerateForTrampoline(masm); |
4349 } | 4350 } |
4350 | 4351 |
4351 | 4352 |
| 4353 static void HandleArrayCases(MacroAssembler* masm, Register receiver, |
| 4354 Register key, Register vector, Register slot, |
| 4355 Register feedback, Register scratch1, |
| 4356 Register scratch2, Register scratch3, |
| 4357 Register scratch4, bool is_polymorphic, |
| 4358 Label* miss) { |
| 4359 // feedback initially contains the feedback array |
| 4360 Label next_loop, prepare_next; |
| 4361 Label load_smi_map, compare_map; |
| 4362 Label start_polymorphic; |
| 4363 |
| 4364 Register receiver_map = scratch1; |
| 4365 Register counter = scratch2; |
| 4366 Register length = scratch3; |
| 4367 Register cached_map = scratch4; |
| 4368 |
| 4369 // Receiver might not be a heap object. |
| 4370 __ JumpIfSmi(receiver, &load_smi_map); |
| 4371 __ movp(receiver_map, FieldOperand(receiver, 0)); |
| 4372 __ bind(&compare_map); |
| 4373 __ movp(cached_map, FieldOperand(feedback, FixedArray::OffsetOfElementAt(0))); |
| 4374 __ cmpp(receiver_map, FieldOperand(cached_map, WeakCell::kValueOffset)); |
| 4375 __ j(not_equal, &start_polymorphic); |
| 4376 |
| 4377 // found, now call handler. |
| 4378 Register handler = feedback; |
| 4379 __ movp(handler, FieldOperand(feedback, FixedArray::OffsetOfElementAt(1))); |
| 4380 __ leap(handler, FieldOperand(handler, Code::kHeaderSize)); |
| 4381 __ jmp(handler); |
| 4382 |
| 4383 // Polymorphic, we have to loop from 2 to N |
| 4384 __ bind(&start_polymorphic); |
| 4385 __ SmiToInteger32(length, FieldOperand(feedback, FixedArray::kLengthOffset)); |
| 4386 if (!is_polymorphic) { |
| 4387 // If the IC could be monomorphic we have to make sure we don't go past the |
| 4388 // end of the feedback array. |
| 4389 __ cmpl(length, Immediate(2)); |
| 4390 __ j(equal, miss); |
| 4391 } |
| 4392 __ movl(counter, Immediate(2)); |
| 4393 |
| 4394 __ bind(&next_loop); |
| 4395 __ movp(cached_map, FieldOperand(feedback, counter, times_pointer_size, |
| 4396 FixedArray::kHeaderSize)); |
| 4397 __ cmpp(receiver_map, FieldOperand(cached_map, WeakCell::kValueOffset)); |
| 4398 __ j(not_equal, &prepare_next); |
| 4399 __ movp(handler, FieldOperand(feedback, counter, times_pointer_size, |
| 4400 FixedArray::kHeaderSize + kPointerSize)); |
| 4401 __ leap(handler, FieldOperand(handler, Code::kHeaderSize)); |
| 4402 __ jmp(handler); |
| 4403 |
| 4404 __ bind(&prepare_next); |
| 4405 __ addl(counter, Immediate(2)); |
| 4406 __ cmpl(counter, length); |
| 4407 __ j(less, &next_loop); |
| 4408 |
| 4409 // We exhausted our array of map handler pairs. |
| 4410 __ jmp(miss); |
| 4411 |
| 4412 __ bind(&load_smi_map); |
| 4413 __ LoadRoot(receiver_map, Heap::kHeapNumberMapRootIndex); |
| 4414 __ jmp(&compare_map); |
| 4415 } |
| 4416 |
| 4417 |
| 4418 static void HandleMonomorphicCase(MacroAssembler* masm, Register receiver, |
| 4419 Register key, Register vector, Register slot, |
| 4420 Register weak_cell, Register integer_slot, |
| 4421 Label* miss) { |
| 4422 // feedback initially contains the feedback array |
| 4423 Label compare_smi_map; |
| 4424 |
| 4425 // Move the weak map into the weak_cell register. |
| 4426 Register ic_map = weak_cell; |
| 4427 __ movp(ic_map, FieldOperand(weak_cell, WeakCell::kValueOffset)); |
| 4428 |
| 4429 // Receiver might not be a heap object. |
| 4430 __ JumpIfSmi(receiver, &compare_smi_map); |
| 4431 __ cmpp(ic_map, FieldOperand(receiver, 0)); |
| 4432 __ j(not_equal, miss); |
| 4433 Register handler = weak_cell; |
| 4434 __ movp(handler, FieldOperand(vector, integer_slot, times_pointer_size, |
| 4435 FixedArray::kHeaderSize + kPointerSize)); |
| 4436 __ leap(handler, FieldOperand(handler, Code::kHeaderSize)); |
| 4437 __ jmp(handler); |
| 4438 |
| 4439 // In microbenchmarks, it made sense to unroll this code so that the call to |
| 4440 // the handler is duplicated for a HeapObject receiver and a Smi receiver. |
| 4441 __ bind(&compare_smi_map); |
| 4442 __ CompareRoot(ic_map, Heap::kHeapNumberMapRootIndex); |
| 4443 __ j(not_equal, miss); |
| 4444 __ movp(handler, FieldOperand(vector, integer_slot, times_pointer_size, |
| 4445 FixedArray::kHeaderSize + kPointerSize)); |
| 4446 __ leap(handler, FieldOperand(handler, Code::kHeaderSize)); |
| 4447 __ jmp(handler); |
| 4448 } |
| 4449 |
| 4450 |
| 4451 void VectorRawLoadStub::Generate(MacroAssembler* masm) { |
| 4452 GenerateImpl(masm, false); |
| 4453 } |
| 4454 |
| 4455 |
| 4456 void VectorRawLoadStub::GenerateForTrampoline(MacroAssembler* masm) { |
| 4457 GenerateImpl(masm, true); |
| 4458 } |
| 4459 |
| 4460 |
| 4461 void VectorRawLoadStub::GenerateImpl(MacroAssembler* masm, bool in_frame) { |
| 4462 Register receiver = VectorLoadICDescriptor::ReceiverRegister(); // rdx |
| 4463 Register name = VectorLoadICDescriptor::NameRegister(); // rcx |
| 4464 Register vector = VectorLoadICDescriptor::VectorRegister(); // rbx |
| 4465 Register slot = VectorLoadICDescriptor::SlotRegister(); // rax |
| 4466 Register feedback = rdi; |
| 4467 Register integer_slot = r8; |
| 4468 |
| 4469 __ SmiToInteger32(integer_slot, slot); |
| 4470 __ movp(feedback, FieldOperand(vector, integer_slot, times_pointer_size, |
| 4471 FixedArray::kHeaderSize)); |
| 4472 |
| 4473 // Is it a weak cell? |
| 4474 Label try_array; |
| 4475 Label not_array, smi_key, key_okay, miss; |
| 4476 __ CompareRoot(FieldOperand(feedback, 0), Heap::kWeakCellMapRootIndex); |
| 4477 __ j(not_equal, &try_array); |
| 4478 HandleMonomorphicCase(masm, receiver, name, vector, slot, feedback, |
| 4479 integer_slot, &miss); |
| 4480 |
| 4481 // Is it a fixed array? |
| 4482 __ bind(&try_array); |
| 4483 __ CompareRoot(FieldOperand(feedback, 0), Heap::kFixedArrayMapRootIndex); |
| 4484 __ j(not_equal, ¬_array); |
| 4485 HandleArrayCases(masm, receiver, name, vector, slot, feedback, integer_slot, |
| 4486 r9, r11, r15, true, &miss); |
| 4487 |
| 4488 __ bind(¬_array); |
| 4489 __ CompareRoot(feedback, Heap::kmegamorphic_symbolRootIndex); |
| 4490 __ j(not_equal, &miss); |
| 4491 Code::Flags code_flags = Code::RemoveTypeAndHolderFromFlags( |
| 4492 Code::ComputeHandlerFlags(Code::LOAD_IC)); |
| 4493 masm->isolate()->stub_cache()->GenerateProbe( |
| 4494 masm, Code::LOAD_IC, code_flags, false, receiver, name, feedback, no_reg); |
| 4495 |
| 4496 __ bind(&miss); |
| 4497 LoadIC::GenerateMiss(masm); |
| 4498 } |
| 4499 |
| 4500 |
| 4501 void VectorRawKeyedLoadStub::Generate(MacroAssembler* masm) { |
| 4502 GenerateImpl(masm, false); |
| 4503 } |
| 4504 |
| 4505 |
| 4506 void VectorRawKeyedLoadStub::GenerateForTrampoline(MacroAssembler* masm) { |
| 4507 GenerateImpl(masm, true); |
| 4508 } |
| 4509 |
| 4510 |
| 4511 void VectorRawKeyedLoadStub::GenerateImpl(MacroAssembler* masm, bool in_frame) { |
| 4512 Register receiver = VectorLoadICDescriptor::ReceiverRegister(); // rdx |
| 4513 Register key = VectorLoadICDescriptor::NameRegister(); // rcx |
| 4514 Register vector = VectorLoadICDescriptor::VectorRegister(); // rbx |
| 4515 Register slot = VectorLoadICDescriptor::SlotRegister(); // rax |
| 4516 Register feedback = rdi; |
| 4517 Register integer_slot = r8; |
| 4518 |
| 4519 __ SmiToInteger32(integer_slot, slot); |
| 4520 __ movp(feedback, FieldOperand(vector, integer_slot, times_pointer_size, |
| 4521 FixedArray::kHeaderSize)); |
| 4522 |
| 4523 // Is it a weak cell? |
| 4524 Label try_array; |
| 4525 Label not_array, smi_key, key_okay, miss; |
| 4526 __ CompareRoot(FieldOperand(feedback, 0), Heap::kWeakCellMapRootIndex); |
| 4527 __ j(not_equal, &try_array); |
| 4528 __ JumpIfNotSmi(key, &miss); |
| 4529 HandleMonomorphicCase(masm, receiver, key, vector, slot, feedback, |
| 4530 integer_slot, &miss); |
| 4531 |
| 4532 __ bind(&try_array); |
| 4533 // Is it a fixed array? |
| 4534 __ CompareRoot(FieldOperand(feedback, 0), Heap::kFixedArrayMapRootIndex); |
| 4535 __ j(not_equal, ¬_array); |
| 4536 // We have a polymorphic element handler. |
| 4537 __ JumpIfNotSmi(key, &miss); |
| 4538 |
| 4539 Label polymorphic, try_poly_name; |
| 4540 __ bind(&polymorphic); |
| 4541 HandleArrayCases(masm, receiver, key, vector, slot, feedback, integer_slot, |
| 4542 r9, r11, r15, true, &miss); |
| 4543 |
| 4544 __ bind(¬_array); |
| 4545 // Is it generic? |
| 4546 __ CompareRoot(feedback, Heap::kmegamorphic_symbolRootIndex); |
| 4547 __ j(not_equal, &try_poly_name); |
| 4548 Handle<Code> megamorphic_stub = |
| 4549 KeyedLoadIC::ChooseMegamorphicStub(masm->isolate()); |
| 4550 __ jmp(megamorphic_stub, RelocInfo::CODE_TARGET); |
| 4551 |
| 4552 __ bind(&try_poly_name); |
| 4553 // We might have a name in feedback, and a fixed array in the next slot. |
| 4554 __ cmpp(key, feedback); |
| 4555 __ j(not_equal, &miss); |
| 4556 // If the name comparison succeeded, we know we have a fixed array with |
| 4557 // at least one map/handler pair. |
| 4558 __ movp(feedback, FieldOperand(vector, integer_slot, times_pointer_size, |
| 4559 FixedArray::kHeaderSize + kPointerSize)); |
| 4560 HandleArrayCases(masm, receiver, key, vector, slot, feedback, integer_slot, |
| 4561 r9, r11, r15, false, &miss); |
| 4562 |
| 4563 __ bind(&miss); |
| 4564 KeyedLoadIC::GenerateMiss(masm); |
| 4565 } |
| 4566 |
| 4567 |
4352 void CallICTrampolineStub::Generate(MacroAssembler* masm) { | 4568 void CallICTrampolineStub::Generate(MacroAssembler* masm) { |
4353 EmitLoadTypeFeedbackVector(masm, rbx); | 4569 EmitLoadTypeFeedbackVector(masm, rbx); |
4354 CallICStub stub(isolate(), state()); | 4570 CallICStub stub(isolate(), state()); |
4355 __ jmp(stub.GetCode(), RelocInfo::CODE_TARGET); | 4571 __ jmp(stub.GetCode(), RelocInfo::CODE_TARGET); |
4356 } | 4572 } |
4357 | 4573 |
4358 | 4574 |
4359 void CallIC_ArrayTrampolineStub::Generate(MacroAssembler* masm) { | 4575 void CallIC_ArrayTrampolineStub::Generate(MacroAssembler* masm) { |
4360 EmitLoadTypeFeedbackVector(masm, rbx); | 4576 EmitLoadTypeFeedbackVector(masm, rbx); |
4361 CallIC_ArrayStub stub(isolate(), state()); | 4577 CallIC_ArrayStub stub(isolate(), state()); |
(...skipping 783 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5145 CallApiFunctionAndReturn(masm, api_function_address, thunk_ref, getter_arg, | 5361 CallApiFunctionAndReturn(masm, api_function_address, thunk_ref, getter_arg, |
5146 kStackSpace, nullptr, return_value_operand, NULL); | 5362 kStackSpace, nullptr, return_value_operand, NULL); |
5147 } | 5363 } |
5148 | 5364 |
5149 | 5365 |
5150 #undef __ | 5366 #undef __ |
5151 | 5367 |
5152 } } // namespace v8::internal | 5368 } } // namespace v8::internal |
5153 | 5369 |
5154 #endif // V8_TARGET_ARCH_X64 | 5370 #endif // V8_TARGET_ARCH_X64 |
OLD | NEW |