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 2204 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2215 return result; | 2215 return result; |
2216 } | 2216 } |
2217 | 2217 |
2218 int64_t FixedDoubleArray::get_representation(int index) { | 2218 int64_t FixedDoubleArray::get_representation(int index) { |
2219 ASSERT(map() != GetHeap()->fixed_cow_array_map() && | 2219 ASSERT(map() != GetHeap()->fixed_cow_array_map() && |
2220 map() != GetHeap()->fixed_array_map()); | 2220 map() != GetHeap()->fixed_array_map()); |
2221 ASSERT(index >= 0 && index < this->length()); | 2221 ASSERT(index >= 0 && index < this->length()); |
2222 return READ_INT64_FIELD(this, kHeaderSize + index * kDoubleSize); | 2222 return READ_INT64_FIELD(this, kHeaderSize + index * kDoubleSize); |
2223 } | 2223 } |
2224 | 2224 |
2225 MaybeObject* FixedDoubleArray::get(int index) { | |
2226 if (is_the_hole(index)) { | |
2227 return GetHeap()->the_hole_value(); | |
2228 } else { | |
2229 return GetHeap()->NumberFromDouble(get_scalar(index)); | |
2230 } | |
2231 } | |
2232 | |
2233 | 2225 |
2234 Handle<Object> FixedDoubleArray::get(Handle<FixedDoubleArray> array, | 2226 Handle<Object> FixedDoubleArray::get(Handle<FixedDoubleArray> array, |
2235 int index) { | 2227 int index) { |
2236 if (array->is_the_hole(index)) { | 2228 if (array->is_the_hole(index)) { |
2237 return array->GetIsolate()->factory()->the_hole_value(); | 2229 return array->GetIsolate()->factory()->the_hole_value(); |
2238 } else { | 2230 } else { |
2239 return array->GetIsolate()->factory()->NewNumber(array->get_scalar(index)); | 2231 return array->GetIsolate()->factory()->NewNumber(array->get_scalar(index)); |
2240 } | 2232 } |
2241 } | 2233 } |
2242 | 2234 |
(...skipping 1386 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3629 } | 3621 } |
3630 | 3622 |
3631 | 3623 |
3632 uint8_t ExternalUint8ClampedArray::get_scalar(int index) { | 3624 uint8_t ExternalUint8ClampedArray::get_scalar(int index) { |
3633 ASSERT((index >= 0) && (index < this->length())); | 3625 ASSERT((index >= 0) && (index < this->length())); |
3634 uint8_t* ptr = external_uint8_clamped_pointer(); | 3626 uint8_t* ptr = external_uint8_clamped_pointer(); |
3635 return ptr[index]; | 3627 return ptr[index]; |
3636 } | 3628 } |
3637 | 3629 |
3638 | 3630 |
3639 Object* ExternalUint8ClampedArray::get(int index) { | |
3640 return Smi::FromInt(static_cast<int>(get_scalar(index))); | |
3641 } | |
3642 | |
3643 | |
3644 Handle<Object> ExternalUint8ClampedArray::get( | 3631 Handle<Object> ExternalUint8ClampedArray::get( |
3645 Handle<ExternalUint8ClampedArray> array, | 3632 Handle<ExternalUint8ClampedArray> array, |
3646 int index) { | 3633 int index) { |
3647 return handle(array->get(index), array->GetIsolate()); | 3634 return Handle<Smi>(Smi::FromInt(array->get_scalar(index)), |
| 3635 array->GetIsolate()); |
3648 } | 3636 } |
3649 | 3637 |
3650 | 3638 |
3651 void ExternalUint8ClampedArray::set(int index, uint8_t value) { | 3639 void ExternalUint8ClampedArray::set(int index, uint8_t value) { |
3652 ASSERT((index >= 0) && (index < this->length())); | 3640 ASSERT((index >= 0) && (index < this->length())); |
3653 uint8_t* ptr = external_uint8_clamped_pointer(); | 3641 uint8_t* ptr = external_uint8_clamped_pointer(); |
3654 ptr[index] = value; | 3642 ptr[index] = value; |
3655 } | 3643 } |
3656 | 3644 |
3657 | 3645 |
3658 void* ExternalArray::external_pointer() { | 3646 void* ExternalArray::external_pointer() { |
3659 intptr_t ptr = READ_INTPTR_FIELD(this, kExternalPointerOffset); | 3647 intptr_t ptr = READ_INTPTR_FIELD(this, kExternalPointerOffset); |
3660 return reinterpret_cast<void*>(ptr); | 3648 return reinterpret_cast<void*>(ptr); |
3661 } | 3649 } |
3662 | 3650 |
3663 | 3651 |
3664 void ExternalArray::set_external_pointer(void* value, WriteBarrierMode mode) { | 3652 void ExternalArray::set_external_pointer(void* value, WriteBarrierMode mode) { |
3665 intptr_t ptr = reinterpret_cast<intptr_t>(value); | 3653 intptr_t ptr = reinterpret_cast<intptr_t>(value); |
3666 WRITE_INTPTR_FIELD(this, kExternalPointerOffset, ptr); | 3654 WRITE_INTPTR_FIELD(this, kExternalPointerOffset, ptr); |
3667 } | 3655 } |
3668 | 3656 |
3669 | 3657 |
3670 int8_t ExternalInt8Array::get_scalar(int index) { | 3658 int8_t ExternalInt8Array::get_scalar(int index) { |
3671 ASSERT((index >= 0) && (index < this->length())); | 3659 ASSERT((index >= 0) && (index < this->length())); |
3672 int8_t* ptr = static_cast<int8_t*>(external_pointer()); | 3660 int8_t* ptr = static_cast<int8_t*>(external_pointer()); |
3673 return ptr[index]; | 3661 return ptr[index]; |
3674 } | 3662 } |
3675 | 3663 |
3676 | 3664 |
3677 Object* ExternalInt8Array::get(int index) { | |
3678 return Smi::FromInt(static_cast<int>(get_scalar(index))); | |
3679 } | |
3680 | |
3681 | |
3682 Handle<Object> ExternalInt8Array::get(Handle<ExternalInt8Array> array, | 3665 Handle<Object> ExternalInt8Array::get(Handle<ExternalInt8Array> array, |
3683 int index) { | 3666 int index) { |
3684 return handle(array->get(index), array->GetIsolate()); | 3667 return Handle<Smi>(Smi::FromInt(array->get_scalar(index)), |
| 3668 array->GetIsolate()); |
3685 } | 3669 } |
3686 | 3670 |
3687 | 3671 |
3688 void ExternalInt8Array::set(int index, int8_t value) { | 3672 void ExternalInt8Array::set(int index, int8_t value) { |
3689 ASSERT((index >= 0) && (index < this->length())); | 3673 ASSERT((index >= 0) && (index < this->length())); |
3690 int8_t* ptr = static_cast<int8_t*>(external_pointer()); | 3674 int8_t* ptr = static_cast<int8_t*>(external_pointer()); |
3691 ptr[index] = value; | 3675 ptr[index] = value; |
3692 } | 3676 } |
3693 | 3677 |
3694 | 3678 |
3695 uint8_t ExternalUint8Array::get_scalar(int index) { | 3679 uint8_t ExternalUint8Array::get_scalar(int index) { |
3696 ASSERT((index >= 0) && (index < this->length())); | 3680 ASSERT((index >= 0) && (index < this->length())); |
3697 uint8_t* ptr = static_cast<uint8_t*>(external_pointer()); | 3681 uint8_t* ptr = static_cast<uint8_t*>(external_pointer()); |
3698 return ptr[index]; | 3682 return ptr[index]; |
3699 } | 3683 } |
3700 | 3684 |
3701 | 3685 |
3702 Object* ExternalUint8Array::get(int index) { | |
3703 return Smi::FromInt(static_cast<int>(get_scalar(index))); | |
3704 } | |
3705 | |
3706 | |
3707 Handle<Object> ExternalUint8Array::get(Handle<ExternalUint8Array> array, | 3686 Handle<Object> ExternalUint8Array::get(Handle<ExternalUint8Array> array, |
3708 int index) { | 3687 int index) { |
3709 return handle(array->get(index), array->GetIsolate()); | 3688 return Handle<Smi>(Smi::FromInt(array->get_scalar(index)), |
| 3689 array->GetIsolate()); |
3710 } | 3690 } |
3711 | 3691 |
3712 | 3692 |
3713 void ExternalUint8Array::set(int index, uint8_t value) { | 3693 void ExternalUint8Array::set(int index, uint8_t value) { |
3714 ASSERT((index >= 0) && (index < this->length())); | 3694 ASSERT((index >= 0) && (index < this->length())); |
3715 uint8_t* ptr = static_cast<uint8_t*>(external_pointer()); | 3695 uint8_t* ptr = static_cast<uint8_t*>(external_pointer()); |
3716 ptr[index] = value; | 3696 ptr[index] = value; |
3717 } | 3697 } |
3718 | 3698 |
3719 | 3699 |
3720 int16_t ExternalInt16Array::get_scalar(int index) { | 3700 int16_t ExternalInt16Array::get_scalar(int index) { |
3721 ASSERT((index >= 0) && (index < this->length())); | 3701 ASSERT((index >= 0) && (index < this->length())); |
3722 int16_t* ptr = static_cast<int16_t*>(external_pointer()); | 3702 int16_t* ptr = static_cast<int16_t*>(external_pointer()); |
3723 return ptr[index]; | 3703 return ptr[index]; |
3724 } | 3704 } |
3725 | 3705 |
3726 | 3706 |
3727 Object* ExternalInt16Array::get(int index) { | |
3728 return Smi::FromInt(static_cast<int>(get_scalar(index))); | |
3729 } | |
3730 | |
3731 | |
3732 Handle<Object> ExternalInt16Array::get(Handle<ExternalInt16Array> array, | 3707 Handle<Object> ExternalInt16Array::get(Handle<ExternalInt16Array> array, |
3733 int index) { | 3708 int index) { |
3734 return handle(array->get(index), array->GetIsolate()); | 3709 return Handle<Smi>(Smi::FromInt(array->get_scalar(index)), |
| 3710 array->GetIsolate()); |
3735 } | 3711 } |
3736 | 3712 |
3737 | 3713 |
3738 void ExternalInt16Array::set(int index, int16_t value) { | 3714 void ExternalInt16Array::set(int index, int16_t value) { |
3739 ASSERT((index >= 0) && (index < this->length())); | 3715 ASSERT((index >= 0) && (index < this->length())); |
3740 int16_t* ptr = static_cast<int16_t*>(external_pointer()); | 3716 int16_t* ptr = static_cast<int16_t*>(external_pointer()); |
3741 ptr[index] = value; | 3717 ptr[index] = value; |
3742 } | 3718 } |
3743 | 3719 |
3744 | 3720 |
3745 uint16_t ExternalUint16Array::get_scalar(int index) { | 3721 uint16_t ExternalUint16Array::get_scalar(int index) { |
3746 ASSERT((index >= 0) && (index < this->length())); | 3722 ASSERT((index >= 0) && (index < this->length())); |
3747 uint16_t* ptr = static_cast<uint16_t*>(external_pointer()); | 3723 uint16_t* ptr = static_cast<uint16_t*>(external_pointer()); |
3748 return ptr[index]; | 3724 return ptr[index]; |
3749 } | 3725 } |
3750 | 3726 |
3751 | 3727 |
3752 Object* ExternalUint16Array::get(int index) { | |
3753 return Smi::FromInt(static_cast<int>(get_scalar(index))); | |
3754 } | |
3755 | |
3756 | |
3757 Handle<Object> ExternalUint16Array::get(Handle<ExternalUint16Array> array, | 3728 Handle<Object> ExternalUint16Array::get(Handle<ExternalUint16Array> array, |
3758 int index) { | 3729 int index) { |
3759 return handle(array->get(index), array->GetIsolate()); | 3730 return Handle<Smi>(Smi::FromInt(array->get_scalar(index)), |
| 3731 array->GetIsolate()); |
3760 } | 3732 } |
3761 | 3733 |
3762 | 3734 |
3763 void ExternalUint16Array::set(int index, uint16_t value) { | 3735 void ExternalUint16Array::set(int index, uint16_t value) { |
3764 ASSERT((index >= 0) && (index < this->length())); | 3736 ASSERT((index >= 0) && (index < this->length())); |
3765 uint16_t* ptr = static_cast<uint16_t*>(external_pointer()); | 3737 uint16_t* ptr = static_cast<uint16_t*>(external_pointer()); |
3766 ptr[index] = value; | 3738 ptr[index] = value; |
3767 } | 3739 } |
3768 | 3740 |
3769 | 3741 |
3770 int32_t ExternalInt32Array::get_scalar(int index) { | 3742 int32_t ExternalInt32Array::get_scalar(int index) { |
3771 ASSERT((index >= 0) && (index < this->length())); | 3743 ASSERT((index >= 0) && (index < this->length())); |
3772 int32_t* ptr = static_cast<int32_t*>(external_pointer()); | 3744 int32_t* ptr = static_cast<int32_t*>(external_pointer()); |
3773 return ptr[index]; | 3745 return ptr[index]; |
3774 } | 3746 } |
3775 | 3747 |
3776 | 3748 |
3777 MaybeObject* ExternalInt32Array::get(int index) { | |
3778 return GetHeap()->NumberFromInt32(get_scalar(index)); | |
3779 } | |
3780 | |
3781 | |
3782 Handle<Object> ExternalInt32Array::get(Handle<ExternalInt32Array> array, | 3749 Handle<Object> ExternalInt32Array::get(Handle<ExternalInt32Array> array, |
3783 int index) { | 3750 int index) { |
3784 return array->GetIsolate()->factory()-> | 3751 return array->GetIsolate()->factory()-> |
3785 NewNumberFromInt(array->get_scalar(index)); | 3752 NewNumberFromInt(array->get_scalar(index)); |
3786 } | 3753 } |
3787 | 3754 |
3788 | 3755 |
3789 void ExternalInt32Array::set(int index, int32_t value) { | 3756 void ExternalInt32Array::set(int index, int32_t value) { |
3790 ASSERT((index >= 0) && (index < this->length())); | 3757 ASSERT((index >= 0) && (index < this->length())); |
3791 int32_t* ptr = static_cast<int32_t*>(external_pointer()); | 3758 int32_t* ptr = static_cast<int32_t*>(external_pointer()); |
3792 ptr[index] = value; | 3759 ptr[index] = value; |
3793 } | 3760 } |
3794 | 3761 |
3795 | 3762 |
3796 uint32_t ExternalUint32Array::get_scalar(int index) { | 3763 uint32_t ExternalUint32Array::get_scalar(int index) { |
3797 ASSERT((index >= 0) && (index < this->length())); | 3764 ASSERT((index >= 0) && (index < this->length())); |
3798 uint32_t* ptr = static_cast<uint32_t*>(external_pointer()); | 3765 uint32_t* ptr = static_cast<uint32_t*>(external_pointer()); |
3799 return ptr[index]; | 3766 return ptr[index]; |
3800 } | 3767 } |
3801 | 3768 |
3802 | 3769 |
3803 MaybeObject* ExternalUint32Array::get(int index) { | |
3804 return GetHeap()->NumberFromUint32(get_scalar(index)); | |
3805 } | |
3806 | |
3807 | |
3808 Handle<Object> ExternalUint32Array::get(Handle<ExternalUint32Array> array, | 3770 Handle<Object> ExternalUint32Array::get(Handle<ExternalUint32Array> array, |
3809 int index) { | 3771 int index) { |
3810 return array->GetIsolate()->factory()-> | 3772 return array->GetIsolate()->factory()-> |
3811 NewNumberFromUint(array->get_scalar(index)); | 3773 NewNumberFromUint(array->get_scalar(index)); |
3812 } | 3774 } |
3813 | 3775 |
3814 | 3776 |
3815 void ExternalUint32Array::set(int index, uint32_t value) { | 3777 void ExternalUint32Array::set(int index, uint32_t value) { |
3816 ASSERT((index >= 0) && (index < this->length())); | 3778 ASSERT((index >= 0) && (index < this->length())); |
3817 uint32_t* ptr = static_cast<uint32_t*>(external_pointer()); | 3779 uint32_t* ptr = static_cast<uint32_t*>(external_pointer()); |
3818 ptr[index] = value; | 3780 ptr[index] = value; |
3819 } | 3781 } |
3820 | 3782 |
3821 | 3783 |
3822 float ExternalFloat32Array::get_scalar(int index) { | 3784 float ExternalFloat32Array::get_scalar(int index) { |
3823 ASSERT((index >= 0) && (index < this->length())); | 3785 ASSERT((index >= 0) && (index < this->length())); |
3824 float* ptr = static_cast<float*>(external_pointer()); | 3786 float* ptr = static_cast<float*>(external_pointer()); |
3825 return ptr[index]; | 3787 return ptr[index]; |
3826 } | 3788 } |
3827 | 3789 |
3828 | 3790 |
3829 MaybeObject* ExternalFloat32Array::get(int index) { | |
3830 return GetHeap()->NumberFromDouble(get_scalar(index)); | |
3831 } | |
3832 | |
3833 | |
3834 Handle<Object> ExternalFloat32Array::get(Handle<ExternalFloat32Array> array, | 3791 Handle<Object> ExternalFloat32Array::get(Handle<ExternalFloat32Array> array, |
3835 int index) { | 3792 int index) { |
3836 return array->GetIsolate()->factory()->NewNumber(array->get_scalar(index)); | 3793 return array->GetIsolate()->factory()->NewNumber(array->get_scalar(index)); |
3837 } | 3794 } |
3838 | 3795 |
3839 | 3796 |
3840 void ExternalFloat32Array::set(int index, float value) { | 3797 void ExternalFloat32Array::set(int index, float value) { |
3841 ASSERT((index >= 0) && (index < this->length())); | 3798 ASSERT((index >= 0) && (index < this->length())); |
3842 float* ptr = static_cast<float*>(external_pointer()); | 3799 float* ptr = static_cast<float*>(external_pointer()); |
3843 ptr[index] = value; | 3800 ptr[index] = value; |
3844 } | 3801 } |
3845 | 3802 |
3846 | 3803 |
3847 double ExternalFloat64Array::get_scalar(int index) { | 3804 double ExternalFloat64Array::get_scalar(int index) { |
3848 ASSERT((index >= 0) && (index < this->length())); | 3805 ASSERT((index >= 0) && (index < this->length())); |
3849 double* ptr = static_cast<double*>(external_pointer()); | 3806 double* ptr = static_cast<double*>(external_pointer()); |
3850 return ptr[index]; | 3807 return ptr[index]; |
3851 } | 3808 } |
3852 | 3809 |
3853 | 3810 |
3854 MaybeObject* ExternalFloat64Array::get(int index) { | |
3855 return GetHeap()->NumberFromDouble(get_scalar(index)); | |
3856 } | |
3857 | |
3858 | |
3859 Handle<Object> ExternalFloat64Array::get(Handle<ExternalFloat64Array> array, | 3811 Handle<Object> ExternalFloat64Array::get(Handle<ExternalFloat64Array> array, |
3860 int index) { | 3812 int index) { |
3861 return array->GetIsolate()->factory()->NewNumber(array->get_scalar(index)); | 3813 return array->GetIsolate()->factory()->NewNumber(array->get_scalar(index)); |
3862 } | 3814 } |
3863 | 3815 |
3864 | 3816 |
3865 void ExternalFloat64Array::set(int index, double value) { | 3817 void ExternalFloat64Array::set(int index, double value) { |
3866 ASSERT((index >= 0) && (index < this->length())); | 3818 ASSERT((index >= 0) && (index < this->length())); |
3867 double* ptr = static_cast<double*>(external_pointer()); | 3819 double* ptr = static_cast<double*>(external_pointer()); |
3868 ptr[index] = value; | 3820 ptr[index] = value; |
(...skipping 127 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3996 } | 3948 } |
3997 | 3949 |
3998 | 3950 |
3999 template<> inline | 3951 template<> inline |
4000 double FixedTypedArray<Float64ArrayTraits>::from_double(double value) { | 3952 double FixedTypedArray<Float64ArrayTraits>::from_double(double value) { |
4001 return value; | 3953 return value; |
4002 } | 3954 } |
4003 | 3955 |
4004 | 3956 |
4005 template <class Traits> | 3957 template <class Traits> |
4006 MaybeObject* FixedTypedArray<Traits>::get(int index) { | |
4007 return Traits::ToObject(GetHeap(), get_scalar(index)); | |
4008 } | |
4009 | |
4010 template <class Traits> | |
4011 Handle<Object> FixedTypedArray<Traits>::get( | 3958 Handle<Object> FixedTypedArray<Traits>::get( |
4012 Handle<FixedTypedArray<Traits> > array, | 3959 Handle<FixedTypedArray<Traits> > array, |
4013 int index) { | 3960 int index) { |
4014 return Traits::ToHandle(array->GetIsolate(), array->get_scalar(index)); | 3961 return Traits::ToHandle(array->GetIsolate(), array->get_scalar(index)); |
4015 } | 3962 } |
4016 | 3963 |
| 3964 |
4017 template <class Traits> | 3965 template <class Traits> |
4018 MaybeObject* FixedTypedArray<Traits>::SetValue(uint32_t index, Object* value) { | 3966 Handle<Object> FixedTypedArray<Traits>::SetValue( |
| 3967 Handle<FixedTypedArray<Traits> > array, |
| 3968 uint32_t index, |
| 3969 Handle<Object> value) { |
4019 ElementType cast_value = Traits::defaultValue(); | 3970 ElementType cast_value = Traits::defaultValue(); |
4020 if (index < static_cast<uint32_t>(length())) { | 3971 if (index < static_cast<uint32_t>(array->length())) { |
4021 if (value->IsSmi()) { | 3972 if (value->IsSmi()) { |
4022 int int_value = Smi::cast(value)->value(); | 3973 int int_value = Handle<Smi>::cast(value)->value(); |
4023 cast_value = from_int(int_value); | 3974 cast_value = from_int(int_value); |
4024 } else if (value->IsHeapNumber()) { | 3975 } else if (value->IsHeapNumber()) { |
4025 double double_value = HeapNumber::cast(value)->value(); | 3976 double double_value = Handle<HeapNumber>::cast(value)->value(); |
4026 cast_value = from_double(double_value); | 3977 cast_value = from_double(double_value); |
4027 } else { | 3978 } else { |
4028 // Clamp undefined to the default value. All other types have been | 3979 // Clamp undefined to the default value. All other types have been |
4029 // converted to a number type further up in the call chain. | 3980 // converted to a number type further up in the call chain. |
4030 ASSERT(value->IsUndefined()); | 3981 ASSERT(value->IsUndefined()); |
4031 } | 3982 } |
4032 set(index, cast_value); | 3983 array->set(index, cast_value); |
4033 } | 3984 } |
4034 return Traits::ToObject(GetHeap(), cast_value); | 3985 return Traits::ToHandle(array->GetIsolate(), cast_value); |
4035 } | |
4036 | |
4037 template <class Traits> | |
4038 Handle<Object> FixedTypedArray<Traits>::SetValue( | |
4039 Handle<FixedTypedArray<Traits> > array, | |
4040 uint32_t index, | |
4041 Handle<Object> value) { | |
4042 CALL_HEAP_FUNCTION(array->GetIsolate(), | |
4043 array->SetValue(index, *value), | |
4044 Object); | |
4045 } | 3986 } |
4046 | 3987 |
4047 | 3988 |
4048 MaybeObject* Uint8ArrayTraits::ToObject(Heap*, uint8_t scalar) { | |
4049 return Smi::FromInt(scalar); | |
4050 } | |
4051 | |
4052 | |
4053 Handle<Object> Uint8ArrayTraits::ToHandle(Isolate* isolate, uint8_t scalar) { | 3989 Handle<Object> Uint8ArrayTraits::ToHandle(Isolate* isolate, uint8_t scalar) { |
4054 return handle(Smi::FromInt(scalar), isolate); | 3990 return handle(Smi::FromInt(scalar), isolate); |
4055 } | 3991 } |
4056 | 3992 |
4057 | 3993 |
4058 MaybeObject* Uint8ClampedArrayTraits::ToObject(Heap*, uint8_t scalar) { | |
4059 return Smi::FromInt(scalar); | |
4060 } | |
4061 | |
4062 | |
4063 Handle<Object> Uint8ClampedArrayTraits::ToHandle(Isolate* isolate, | 3994 Handle<Object> Uint8ClampedArrayTraits::ToHandle(Isolate* isolate, |
4064 uint8_t scalar) { | 3995 uint8_t scalar) { |
4065 return handle(Smi::FromInt(scalar), isolate); | 3996 return handle(Smi::FromInt(scalar), isolate); |
4066 } | 3997 } |
4067 | 3998 |
4068 | 3999 |
4069 MaybeObject* Int8ArrayTraits::ToObject(Heap*, int8_t scalar) { | |
4070 return Smi::FromInt(scalar); | |
4071 } | |
4072 | |
4073 | |
4074 Handle<Object> Int8ArrayTraits::ToHandle(Isolate* isolate, int8_t scalar) { | 4000 Handle<Object> Int8ArrayTraits::ToHandle(Isolate* isolate, int8_t scalar) { |
4075 return handle(Smi::FromInt(scalar), isolate); | 4001 return handle(Smi::FromInt(scalar), isolate); |
4076 } | 4002 } |
4077 | 4003 |
4078 | 4004 |
4079 MaybeObject* Uint16ArrayTraits::ToObject(Heap*, uint16_t scalar) { | |
4080 return Smi::FromInt(scalar); | |
4081 } | |
4082 | |
4083 | |
4084 Handle<Object> Uint16ArrayTraits::ToHandle(Isolate* isolate, uint16_t scalar) { | 4005 Handle<Object> Uint16ArrayTraits::ToHandle(Isolate* isolate, uint16_t scalar) { |
4085 return handle(Smi::FromInt(scalar), isolate); | 4006 return handle(Smi::FromInt(scalar), isolate); |
4086 } | 4007 } |
4087 | 4008 |
4088 | 4009 |
4089 MaybeObject* Int16ArrayTraits::ToObject(Heap*, int16_t scalar) { | |
4090 return Smi::FromInt(scalar); | |
4091 } | |
4092 | |
4093 | |
4094 Handle<Object> Int16ArrayTraits::ToHandle(Isolate* isolate, int16_t scalar) { | 4010 Handle<Object> Int16ArrayTraits::ToHandle(Isolate* isolate, int16_t scalar) { |
4095 return handle(Smi::FromInt(scalar), isolate); | 4011 return handle(Smi::FromInt(scalar), isolate); |
4096 } | 4012 } |
4097 | 4013 |
4098 | 4014 |
4099 MaybeObject* Uint32ArrayTraits::ToObject(Heap* heap, uint32_t scalar) { | |
4100 return heap->NumberFromUint32(scalar); | |
4101 } | |
4102 | |
4103 | |
4104 Handle<Object> Uint32ArrayTraits::ToHandle(Isolate* isolate, uint32_t scalar) { | 4015 Handle<Object> Uint32ArrayTraits::ToHandle(Isolate* isolate, uint32_t scalar) { |
4105 return isolate->factory()->NewNumberFromUint(scalar); | 4016 return isolate->factory()->NewNumberFromUint(scalar); |
4106 } | 4017 } |
4107 | 4018 |
4108 | 4019 |
4109 MaybeObject* Int32ArrayTraits::ToObject(Heap* heap, int32_t scalar) { | |
4110 return heap->NumberFromInt32(scalar); | |
4111 } | |
4112 | |
4113 | |
4114 Handle<Object> Int32ArrayTraits::ToHandle(Isolate* isolate, int32_t scalar) { | 4020 Handle<Object> Int32ArrayTraits::ToHandle(Isolate* isolate, int32_t scalar) { |
4115 return isolate->factory()->NewNumberFromInt(scalar); | 4021 return isolate->factory()->NewNumberFromInt(scalar); |
4116 } | 4022 } |
4117 | 4023 |
4118 | 4024 |
4119 MaybeObject* Float32ArrayTraits::ToObject(Heap* heap, float scalar) { | |
4120 return heap->NumberFromDouble(scalar); | |
4121 } | |
4122 | |
4123 | |
4124 Handle<Object> Float32ArrayTraits::ToHandle(Isolate* isolate, float scalar) { | 4025 Handle<Object> Float32ArrayTraits::ToHandle(Isolate* isolate, float scalar) { |
4125 return isolate->factory()->NewNumber(scalar); | 4026 return isolate->factory()->NewNumber(scalar); |
4126 } | 4027 } |
4127 | 4028 |
4128 | 4029 |
4129 MaybeObject* Float64ArrayTraits::ToObject(Heap* heap, double scalar) { | |
4130 return heap->NumberFromDouble(scalar); | |
4131 } | |
4132 | |
4133 | |
4134 Handle<Object> Float64ArrayTraits::ToHandle(Isolate* isolate, double scalar) { | 4030 Handle<Object> Float64ArrayTraits::ToHandle(Isolate* isolate, double scalar) { |
4135 return isolate->factory()->NewNumber(scalar); | 4031 return isolate->factory()->NewNumber(scalar); |
4136 } | 4032 } |
4137 | 4033 |
4138 | 4034 |
4139 int Map::visitor_id() { | 4035 int Map::visitor_id() { |
4140 return READ_BYTE_FIELD(this, kVisitorIdOffset); | 4036 return READ_BYTE_FIELD(this, kVisitorIdOffset); |
4141 } | 4037 } |
4142 | 4038 |
4143 | 4039 |
(...skipping 2949 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7093 #undef READ_SHORT_FIELD | 6989 #undef READ_SHORT_FIELD |
7094 #undef WRITE_SHORT_FIELD | 6990 #undef WRITE_SHORT_FIELD |
7095 #undef READ_BYTE_FIELD | 6991 #undef READ_BYTE_FIELD |
7096 #undef WRITE_BYTE_FIELD | 6992 #undef WRITE_BYTE_FIELD |
7097 #undef NOBARRIER_READ_BYTE_FIELD | 6993 #undef NOBARRIER_READ_BYTE_FIELD |
7098 #undef NOBARRIER_WRITE_BYTE_FIELD | 6994 #undef NOBARRIER_WRITE_BYTE_FIELD |
7099 | 6995 |
7100 } } // namespace v8::internal | 6996 } } // namespace v8::internal |
7101 | 6997 |
7102 #endif // V8_OBJECTS_INL_H_ | 6998 #endif // V8_OBJECTS_INL_H_ |
OLD | NEW |