OLD | NEW |
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 the V8 project authors. All rights reserved. |
2 // Redistribution and use in source and binary forms, with or without | 2 // Redistribution and use in source and binary forms, with or without |
3 // modification, are permitted provided that the following conditions are | 3 // modification, are permitted provided that the following conditions are |
4 // met: | 4 // met: |
5 // | 5 // |
6 // * Redistributions of source code must retain the above copyright | 6 // * Redistributions of source code must retain the above copyright |
7 // notice, this list of conditions and the following disclaimer. | 7 // notice, this list of conditions and the following disclaimer. |
8 // * Redistributions in binary form must reproduce the above | 8 // * Redistributions in binary form must reproduce the above |
9 // copyright notice, this list of conditions and the following | 9 // copyright notice, this list of conditions and the following |
10 // disclaimer in the documentation and/or other materials provided | 10 // disclaimer in the documentation and/or other materials provided |
(...skipping 2485 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2496 DeoptimizeIf(below_equal, instr->environment()); | 2496 DeoptimizeIf(below_equal, instr->environment()); |
2497 | 2497 |
2498 // There are two words between the frame pointer and the last argument. | 2498 // There are two words between the frame pointer and the last argument. |
2499 // Subtracting from length accounts for one of them add one more. | 2499 // Subtracting from length accounts for one of them add one more. |
2500 __ movq(result, Operand(arguments, length, times_pointer_size, kPointerSize)); | 2500 __ movq(result, Operand(arguments, length, times_pointer_size, kPointerSize)); |
2501 } | 2501 } |
2502 | 2502 |
2503 | 2503 |
2504 void LCodeGen::DoLoadKeyedFastElement(LLoadKeyedFastElement* instr) { | 2504 void LCodeGen::DoLoadKeyedFastElement(LLoadKeyedFastElement* instr) { |
2505 Register result = ToRegister(instr->result()); | 2505 Register result = ToRegister(instr->result()); |
2506 | 2506 LOperand* key = instr->key(); |
2507 if (instr->hydrogen()->IsDehoisted() && !instr->key()->IsConstantOperand()) { | 2507 if (!key->IsConstantOperand()) { |
2508 // Sign extend key because it could be a 32 bit negative value | 2508 Register key_reg = ToRegister(key); |
2509 // and the dehoisted address computation happens in 64 bits. | 2509 if (instr->hydrogen()->key()->representation().IsTagged()) { |
2510 Register key_reg = ToRegister(instr->key()); | 2510 __ SmiToInteger64(key_reg, key_reg); |
2511 __ movsxlq(key_reg, key_reg); | 2511 } else if (instr->hydrogen()->IsDehoisted()) { |
| 2512 // Sign extend key because it could be a 32 bit negative value |
| 2513 // and the dehoisted address computation happens in 64 bits |
| 2514 __ movsxlq(key_reg, key_reg); |
| 2515 } |
2512 } | 2516 } |
2513 | 2517 |
2514 // Load the result. | 2518 // Load the result. |
2515 __ movq(result, | 2519 __ movq(result, |
2516 BuildFastArrayOperand(instr->elements(), | 2520 BuildFastArrayOperand(instr->elements(), |
2517 instr->key(), | 2521 key, |
2518 FAST_ELEMENTS, | 2522 FAST_ELEMENTS, |
2519 FixedArray::kHeaderSize - kHeapObjectTag, | 2523 FixedArray::kHeaderSize - kHeapObjectTag, |
2520 instr->additional_index())); | 2524 instr->additional_index())); |
2521 | 2525 |
2522 // Check for the hole value. | 2526 // Check for the hole value. |
2523 if (instr->hydrogen()->RequiresHoleCheck()) { | 2527 if (instr->hydrogen()->RequiresHoleCheck()) { |
2524 if (IsFastSmiElementsKind(instr->hydrogen()->elements_kind())) { | 2528 if (IsFastSmiElementsKind(instr->hydrogen()->elements_kind())) { |
2525 Condition smi = __ CheckSmi(result); | 2529 Condition smi = __ CheckSmi(result); |
2526 DeoptimizeIf(NegateCondition(smi), instr->environment()); | 2530 DeoptimizeIf(NegateCondition(smi), instr->environment()); |
2527 } else { | 2531 } else { |
2528 __ CompareRoot(result, Heap::kTheHoleValueRootIndex); | 2532 __ CompareRoot(result, Heap::kTheHoleValueRootIndex); |
2529 DeoptimizeIf(equal, instr->environment()); | 2533 DeoptimizeIf(equal, instr->environment()); |
2530 } | 2534 } |
2531 } | 2535 } |
2532 } | 2536 } |
2533 | 2537 |
2534 | 2538 |
2535 void LCodeGen::DoLoadKeyedFastDoubleElement( | 2539 void LCodeGen::DoLoadKeyedFastDoubleElement( |
2536 LLoadKeyedFastDoubleElement* instr) { | 2540 LLoadKeyedFastDoubleElement* instr) { |
2537 XMMRegister result(ToDoubleRegister(instr->result())); | 2541 XMMRegister result(ToDoubleRegister(instr->result())); |
2538 | 2542 LOperand* key = instr->key(); |
2539 if (instr->hydrogen()->IsDehoisted() && !instr->key()->IsConstantOperand()) { | 2543 if (!key->IsConstantOperand()) { |
2540 // Sign extend key because it could be a 32 bit negative value | 2544 Register key_reg = ToRegister(key); |
2541 // and the dehoisted address computation happens in 64 bits | 2545 if (instr->hydrogen()->key()->representation().IsTagged()) { |
2542 Register key_reg = ToRegister(instr->key()); | 2546 __ SmiToInteger64(key_reg, key_reg); |
2543 __ movsxlq(key_reg, key_reg); | 2547 } else if (instr->hydrogen()->IsDehoisted()) { |
| 2548 // Sign extend key because it could be a 32 bit negative value |
| 2549 // and the dehoisted address computation happens in 64 bits |
| 2550 __ movsxlq(key_reg, key_reg); |
| 2551 } |
2544 } | 2552 } |
2545 | 2553 |
2546 if (instr->hydrogen()->RequiresHoleCheck()) { | 2554 if (instr->hydrogen()->RequiresHoleCheck()) { |
2547 int offset = FixedDoubleArray::kHeaderSize - kHeapObjectTag + | 2555 int offset = FixedDoubleArray::kHeaderSize - kHeapObjectTag + |
2548 sizeof(kHoleNanLower32); | 2556 sizeof(kHoleNanLower32); |
2549 Operand hole_check_operand = BuildFastArrayOperand( | 2557 Operand hole_check_operand = BuildFastArrayOperand( |
2550 instr->elements(), | 2558 instr->elements(), |
2551 instr->key(), | 2559 key, |
2552 FAST_DOUBLE_ELEMENTS, | 2560 FAST_DOUBLE_ELEMENTS, |
2553 offset, | 2561 offset, |
2554 instr->additional_index()); | 2562 instr->additional_index()); |
2555 __ cmpl(hole_check_operand, Immediate(kHoleNanUpper32)); | 2563 __ cmpl(hole_check_operand, Immediate(kHoleNanUpper32)); |
2556 DeoptimizeIf(equal, instr->environment()); | 2564 DeoptimizeIf(equal, instr->environment()); |
2557 } | 2565 } |
2558 | 2566 |
2559 Operand double_load_operand = BuildFastArrayOperand( | 2567 Operand double_load_operand = BuildFastArrayOperand( |
2560 instr->elements(), | 2568 instr->elements(), |
2561 instr->key(), | 2569 key, |
2562 FAST_DOUBLE_ELEMENTS, | 2570 FAST_DOUBLE_ELEMENTS, |
2563 FixedDoubleArray::kHeaderSize - kHeapObjectTag, | 2571 FixedDoubleArray::kHeaderSize - kHeapObjectTag, |
2564 instr->additional_index()); | 2572 instr->additional_index()); |
2565 __ movsd(result, double_load_operand); | 2573 __ movsd(result, double_load_operand); |
2566 } | 2574 } |
2567 | 2575 |
2568 | 2576 |
2569 Operand LCodeGen::BuildFastArrayOperand( | 2577 Operand LCodeGen::BuildFastArrayOperand( |
2570 LOperand* elements_pointer, | 2578 LOperand* elements_pointer, |
2571 LOperand* key, | 2579 LOperand* key, |
(...skipping 16 matching lines...) Expand all Loading... |
2588 ToRegister(key), | 2596 ToRegister(key), |
2589 scale_factor, | 2597 scale_factor, |
2590 offset + (additional_index << shift_size)); | 2598 offset + (additional_index << shift_size)); |
2591 } | 2599 } |
2592 } | 2600 } |
2593 | 2601 |
2594 | 2602 |
2595 void LCodeGen::DoLoadKeyedSpecializedArrayElement( | 2603 void LCodeGen::DoLoadKeyedSpecializedArrayElement( |
2596 LLoadKeyedSpecializedArrayElement* instr) { | 2604 LLoadKeyedSpecializedArrayElement* instr) { |
2597 ElementsKind elements_kind = instr->elements_kind(); | 2605 ElementsKind elements_kind = instr->elements_kind(); |
2598 Operand operand(BuildFastArrayOperand(instr->external_pointer(), | 2606 LOperand* key = instr->key(); |
2599 instr->key(), | 2607 if (!key->IsConstantOperand()) { |
2600 elements_kind, | 2608 Register key_reg = ToRegister(key); |
2601 0, | 2609 if (instr->hydrogen()->key()->representation().IsTagged()) { |
2602 instr->additional_index())); | 2610 __ SmiToInteger64(key_reg, key_reg); |
2603 if (instr->hydrogen()->IsDehoisted() && !instr->key()->IsConstantOperand()) { | 2611 } else if (instr->hydrogen()->IsDehoisted()) { |
2604 // Sign extend key because it could be a 32 bit negative value | 2612 // Sign extend key because it could be a 32 bit negative value |
2605 // and the dehoisted address computation happens in 64 bits | 2613 // and the dehoisted address computation happens in 64 bits |
2606 Register key_reg = ToRegister(instr->key()); | 2614 __ movsxlq(key_reg, key_reg); |
2607 __ movsxlq(key_reg, key_reg); | 2615 } |
2608 } | 2616 } |
| 2617 Operand operand(BuildFastArrayOperand( |
| 2618 instr->external_pointer(), |
| 2619 key, |
| 2620 elements_kind, |
| 2621 0, |
| 2622 instr->additional_index())); |
2609 | 2623 |
2610 if (elements_kind == EXTERNAL_FLOAT_ELEMENTS) { | 2624 if (elements_kind == EXTERNAL_FLOAT_ELEMENTS) { |
2611 XMMRegister result(ToDoubleRegister(instr->result())); | 2625 XMMRegister result(ToDoubleRegister(instr->result())); |
2612 __ movss(result, operand); | 2626 __ movss(result, operand); |
2613 __ cvtss2sd(result, result); | 2627 __ cvtss2sd(result, result); |
2614 } else if (elements_kind == EXTERNAL_DOUBLE_ELEMENTS) { | 2628 } else if (elements_kind == EXTERNAL_DOUBLE_ELEMENTS) { |
2615 __ movsd(ToDoubleRegister(instr->result()), operand); | 2629 __ movsd(ToDoubleRegister(instr->result()), operand); |
2616 } else { | 2630 } else { |
2617 Register result(ToRegister(instr->result())); | 2631 Register result(ToRegister(instr->result())); |
2618 switch (elements_kind) { | 2632 switch (elements_kind) { |
(...skipping 912 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3531 Handle<Code> ic = (instr->strict_mode_flag() == kStrictMode) | 3545 Handle<Code> ic = (instr->strict_mode_flag() == kStrictMode) |
3532 ? isolate()->builtins()->StoreIC_Initialize_Strict() | 3546 ? isolate()->builtins()->StoreIC_Initialize_Strict() |
3533 : isolate()->builtins()->StoreIC_Initialize(); | 3547 : isolate()->builtins()->StoreIC_Initialize(); |
3534 CallCode(ic, RelocInfo::CODE_TARGET, instr); | 3548 CallCode(ic, RelocInfo::CODE_TARGET, instr); |
3535 } | 3549 } |
3536 | 3550 |
3537 | 3551 |
3538 void LCodeGen::DoStoreKeyedSpecializedArrayElement( | 3552 void LCodeGen::DoStoreKeyedSpecializedArrayElement( |
3539 LStoreKeyedSpecializedArrayElement* instr) { | 3553 LStoreKeyedSpecializedArrayElement* instr) { |
3540 ElementsKind elements_kind = instr->elements_kind(); | 3554 ElementsKind elements_kind = instr->elements_kind(); |
3541 Operand operand(BuildFastArrayOperand(instr->external_pointer(), | 3555 LOperand* key = instr->key(); |
3542 instr->key(), | 3556 if (!key->IsConstantOperand()) { |
3543 elements_kind, | 3557 Register key_reg = ToRegister(key); |
3544 0, | 3558 if (instr->hydrogen()->key()->representation().IsTagged()) { |
3545 instr->additional_index())); | 3559 __ SmiToInteger64(key_reg, key_reg); |
3546 | 3560 } else if (instr->hydrogen()->IsDehoisted()) { |
3547 if (instr->hydrogen()->IsDehoisted() && !instr->key()->IsConstantOperand()) { | 3561 // Sign extend key because it could be a 32 bit negative value |
3548 // Sign extend key because it could be a 32 bit negative value | 3562 // and the dehoisted address computation happens in 64 bits |
3549 // and the dehoisted address computation happens in 64 bits | 3563 __ movsxlq(key_reg, key_reg); |
3550 Register key_reg = ToRegister(instr->key()); | 3564 } |
3551 __ movsxlq(key_reg, key_reg); | |
3552 } | 3565 } |
| 3566 Operand operand(BuildFastArrayOperand( |
| 3567 instr->external_pointer(), |
| 3568 key, |
| 3569 elements_kind, |
| 3570 0, |
| 3571 instr->additional_index())); |
3553 | 3572 |
3554 if (elements_kind == EXTERNAL_FLOAT_ELEMENTS) { | 3573 if (elements_kind == EXTERNAL_FLOAT_ELEMENTS) { |
3555 XMMRegister value(ToDoubleRegister(instr->value())); | 3574 XMMRegister value(ToDoubleRegister(instr->value())); |
3556 __ cvtsd2ss(value, value); | 3575 __ cvtsd2ss(value, value); |
3557 __ movss(operand, value); | 3576 __ movss(operand, value); |
3558 } else if (elements_kind == EXTERNAL_DOUBLE_ELEMENTS) { | 3577 } else if (elements_kind == EXTERNAL_DOUBLE_ELEMENTS) { |
3559 __ movsd(operand, ToDoubleRegister(instr->value())); | 3578 __ movsd(operand, ToDoubleRegister(instr->value())); |
3560 } else { | 3579 } else { |
3561 Register value(ToRegister(instr->value())); | 3580 Register value(ToRegister(instr->value())); |
3562 switch (elements_kind) { | 3581 switch (elements_kind) { |
(...skipping 23 matching lines...) Expand all Loading... |
3586 UNREACHABLE(); | 3605 UNREACHABLE(); |
3587 break; | 3606 break; |
3588 } | 3607 } |
3589 } | 3608 } |
3590 } | 3609 } |
3591 | 3610 |
3592 | 3611 |
3593 void LCodeGen::DoBoundsCheck(LBoundsCheck* instr) { | 3612 void LCodeGen::DoBoundsCheck(LBoundsCheck* instr) { |
3594 if (instr->length()->IsRegister()) { | 3613 if (instr->length()->IsRegister()) { |
3595 Register reg = ToRegister(instr->length()); | 3614 Register reg = ToRegister(instr->length()); |
3596 if (FLAG_debug_code) { | 3615 if (FLAG_debug_code && |
| 3616 !instr->hydrogen()->index()->representation().IsTagged()) { |
3597 __ AbortIfNotZeroExtended(reg); | 3617 __ AbortIfNotZeroExtended(reg); |
3598 } | 3618 } |
3599 if (instr->index()->IsConstantOperand()) { | 3619 if (instr->index()->IsConstantOperand()) { |
3600 __ cmpq(reg, | 3620 __ cmpq(reg, |
3601 Immediate(ToInteger32(LConstantOperand::cast(instr->index())))); | 3621 Immediate(ToInteger32(LConstantOperand::cast(instr->index())))); |
3602 } else { | 3622 } else { |
3603 Register reg2 = ToRegister(instr->index()); | 3623 Register reg2 = ToRegister(instr->index()); |
3604 if (FLAG_debug_code) { | 3624 if (FLAG_debug_code && |
| 3625 !instr->hydrogen()->index()->representation().IsTagged()) { |
3605 __ AbortIfNotZeroExtended(reg2); | 3626 __ AbortIfNotZeroExtended(reg2); |
3606 } | 3627 } |
3607 __ cmpq(reg, reg2); | 3628 __ cmpq(reg, reg2); |
3608 } | 3629 } |
3609 } else { | 3630 } else { |
3610 if (instr->index()->IsConstantOperand()) { | 3631 if (instr->index()->IsConstantOperand()) { |
3611 __ cmpq(ToOperand(instr->length()), | 3632 __ cmpq(ToOperand(instr->length()), |
3612 Immediate(ToInteger32(LConstantOperand::cast(instr->index())))); | 3633 Immediate(ToInteger32(LConstantOperand::cast(instr->index())))); |
3613 } else { | 3634 } else { |
3614 __ cmpq(ToOperand(instr->length()), ToRegister(instr->index())); | 3635 __ cmpq(ToOperand(instr->length()), ToRegister(instr->index())); |
3615 } | 3636 } |
3616 } | 3637 } |
3617 DeoptimizeIf(below_equal, instr->environment()); | 3638 DeoptimizeIf(below_equal, instr->environment()); |
3618 } | 3639 } |
3619 | 3640 |
3620 | 3641 |
3621 void LCodeGen::DoStoreKeyedFastElement(LStoreKeyedFastElement* instr) { | 3642 void LCodeGen::DoStoreKeyedFastElement(LStoreKeyedFastElement* instr) { |
3622 Register value = ToRegister(instr->value()); | 3643 Register value = ToRegister(instr->value()); |
3623 Register elements = ToRegister(instr->object()); | 3644 Register elements = ToRegister(instr->object()); |
3624 Register key = instr->key()->IsRegister() ? ToRegister(instr->key()) : no_reg; | 3645 LOperand* key = instr->key(); |
| 3646 if (!key->IsConstantOperand()) { |
| 3647 Register key_reg = ToRegister(key); |
| 3648 if (instr->hydrogen()->key()->representation().IsTagged()) { |
| 3649 __ SmiToInteger64(key_reg, key_reg); |
| 3650 } else if (instr->hydrogen()->IsDehoisted()) { |
| 3651 // Sign extend key because it could be a 32 bit negative value |
| 3652 // and the dehoisted address computation happens in 64 bits |
| 3653 __ movsxlq(key_reg, key_reg); |
| 3654 } |
| 3655 } |
3625 | 3656 |
3626 Operand operand = | 3657 Operand operand = |
3627 BuildFastArrayOperand(instr->object(), | 3658 BuildFastArrayOperand(instr->object(), |
3628 instr->key(), | 3659 key, |
3629 FAST_ELEMENTS, | 3660 FAST_ELEMENTS, |
3630 FixedArray::kHeaderSize - kHeapObjectTag, | 3661 FixedArray::kHeaderSize - kHeapObjectTag, |
3631 instr->additional_index()); | 3662 instr->additional_index()); |
3632 | 3663 |
3633 if (instr->hydrogen()->IsDehoisted() && !instr->key()->IsConstantOperand()) { | |
3634 // Sign extend key because it could be a 32 bit negative value | |
3635 // and the dehoisted address computation happens in 64 bits | |
3636 Register key_reg = ToRegister(instr->key()); | |
3637 __ movsxlq(key_reg, key_reg); | |
3638 } | |
3639 | |
3640 __ movq(operand, value); | |
3641 | |
3642 if (instr->hydrogen()->NeedsWriteBarrier()) { | 3664 if (instr->hydrogen()->NeedsWriteBarrier()) { |
3643 ASSERT(!instr->key()->IsConstantOperand()); | 3665 ASSERT(!instr->key()->IsConstantOperand()); |
3644 HType type = instr->hydrogen()->value()->type(); | 3666 HType type = instr->hydrogen()->value()->type(); |
3645 SmiCheck check_needed = | 3667 SmiCheck check_needed = |
3646 type.IsHeapObject() ? OMIT_SMI_CHECK : INLINE_SMI_CHECK; | 3668 type.IsHeapObject() ? OMIT_SMI_CHECK : INLINE_SMI_CHECK; |
3647 // Compute address of modified element and store it into key register. | 3669 // Compute address of modified element and store it into key register. |
3648 __ lea(key, operand); | 3670 Register key_reg(ToRegister(key)); |
| 3671 __ lea(key_reg, operand); |
| 3672 __ movq(Operand(key_reg, 0), value); |
3649 __ RecordWrite(elements, | 3673 __ RecordWrite(elements, |
3650 key, | 3674 key_reg, |
3651 value, | 3675 value, |
3652 kSaveFPRegs, | 3676 kSaveFPRegs, |
3653 EMIT_REMEMBERED_SET, | 3677 EMIT_REMEMBERED_SET, |
3654 check_needed); | 3678 check_needed); |
| 3679 } else { |
| 3680 __ movq(operand, value); |
3655 } | 3681 } |
3656 } | 3682 } |
3657 | 3683 |
3658 | 3684 |
3659 void LCodeGen::DoStoreKeyedFastDoubleElement( | 3685 void LCodeGen::DoStoreKeyedFastDoubleElement( |
3660 LStoreKeyedFastDoubleElement* instr) { | 3686 LStoreKeyedFastDoubleElement* instr) { |
3661 XMMRegister value = ToDoubleRegister(instr->value()); | 3687 XMMRegister value = ToDoubleRegister(instr->value()); |
| 3688 LOperand* key = instr->key(); |
| 3689 if (!key->IsConstantOperand()) { |
| 3690 Register key_reg = ToRegister(key); |
| 3691 if (instr->hydrogen()->key()->representation().IsTagged()) { |
| 3692 __ SmiToInteger64(key_reg, key_reg); |
| 3693 } else if (instr->hydrogen()->IsDehoisted()) { |
| 3694 // Sign extend key because it could be a 32 bit negative value |
| 3695 // and the dehoisted address computation happens in 64 bits |
| 3696 __ movsxlq(key_reg, key_reg); |
| 3697 } |
| 3698 } |
3662 | 3699 |
3663 if (instr->NeedsCanonicalization()) { | 3700 if (instr->NeedsCanonicalization()) { |
3664 Label have_value; | 3701 Label have_value; |
3665 | 3702 |
3666 __ ucomisd(value, value); | 3703 __ ucomisd(value, value); |
3667 __ j(parity_odd, &have_value); // NaN. | 3704 __ j(parity_odd, &have_value); // NaN. |
3668 | 3705 |
3669 __ Set(kScratchRegister, BitCast<uint64_t>( | 3706 __ Set(kScratchRegister, BitCast<uint64_t>( |
3670 FixedDoubleArray::canonical_not_the_hole_nan_as_double())); | 3707 FixedDoubleArray::canonical_not_the_hole_nan_as_double())); |
3671 __ movq(value, kScratchRegister); | 3708 __ movq(value, kScratchRegister); |
3672 | 3709 |
3673 __ bind(&have_value); | 3710 __ bind(&have_value); |
3674 } | 3711 } |
3675 | 3712 |
3676 Operand double_store_operand = BuildFastArrayOperand( | 3713 Operand double_store_operand = BuildFastArrayOperand( |
3677 instr->elements(), | 3714 instr->elements(), |
3678 instr->key(), | 3715 key, |
3679 FAST_DOUBLE_ELEMENTS, | 3716 FAST_DOUBLE_ELEMENTS, |
3680 FixedDoubleArray::kHeaderSize - kHeapObjectTag, | 3717 FixedDoubleArray::kHeaderSize - kHeapObjectTag, |
3681 instr->additional_index()); | 3718 instr->additional_index()); |
3682 | 3719 |
3683 if (instr->hydrogen()->IsDehoisted() && !instr->key()->IsConstantOperand()) { | |
3684 // Sign extend key because it could be a 32 bit negative value | |
3685 // and the dehoisted address computation happens in 64 bits | |
3686 Register key_reg = ToRegister(instr->key()); | |
3687 __ movsxlq(key_reg, key_reg); | |
3688 } | |
3689 | |
3690 __ movsd(double_store_operand, value); | 3720 __ movsd(double_store_operand, value); |
3691 } | 3721 } |
3692 | 3722 |
3693 void LCodeGen::DoStoreKeyedGeneric(LStoreKeyedGeneric* instr) { | 3723 void LCodeGen::DoStoreKeyedGeneric(LStoreKeyedGeneric* instr) { |
3694 ASSERT(ToRegister(instr->object()).is(rdx)); | 3724 ASSERT(ToRegister(instr->object()).is(rdx)); |
3695 ASSERT(ToRegister(instr->key()).is(rcx)); | 3725 ASSERT(ToRegister(instr->key()).is(rcx)); |
3696 ASSERT(ToRegister(instr->value()).is(rax)); | 3726 ASSERT(ToRegister(instr->value()).is(rax)); |
3697 | 3727 |
3698 Handle<Code> ic = (instr->strict_mode_flag() == kStrictMode) | 3728 Handle<Code> ic = (instr->strict_mode_flag() == kStrictMode) |
3699 ? isolate()->builtins()->KeyedStoreIC_Initialize_Strict() | 3729 ? isolate()->builtins()->KeyedStoreIC_Initialize_Strict() |
(...skipping 1347 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5047 FixedArray::kHeaderSize - kPointerSize)); | 5077 FixedArray::kHeaderSize - kPointerSize)); |
5048 __ bind(&done); | 5078 __ bind(&done); |
5049 } | 5079 } |
5050 | 5080 |
5051 | 5081 |
5052 #undef __ | 5082 #undef __ |
5053 | 5083 |
5054 } } // namespace v8::internal | 5084 } } // namespace v8::internal |
5055 | 5085 |
5056 #endif // V8_TARGET_ARCH_X64 | 5086 #endif // V8_TARGET_ARCH_X64 |
OLD | NEW |