ulan@chromium.org | 750145a | 2013-03-07 15:14:13 +0000 | [diff] [blame] | 1 | // Copyright 2013 the V8 project authors. All rights reserved. |
| 2 | // Redistribution and use in source and binary forms, with or without |
| 3 | // modification, are permitted provided that the following conditions are |
| 4 | // met: |
| 5 | // |
| 6 | // * Redistributions of source code must retain the above copyright |
| 7 | // notice, this list of conditions and the following disclaimer. |
| 8 | // * Redistributions in binary form must reproduce the above |
| 9 | // copyright notice, this list of conditions and the following |
| 10 | // disclaimer in the documentation and/or other materials provided |
| 11 | // with the distribution. |
| 12 | // * Neither the name of Google Inc. nor the names of its |
| 13 | // contributors may be used to endorse or promote products derived |
| 14 | // from this software without specific prior written permission. |
| 15 | // |
| 16 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 17 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 18 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 19 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 20 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 21 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 22 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 23 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 24 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 25 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 26 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 27 | |
| 28 | #include <stdlib.h> |
| 29 | |
| 30 | #include "v8.h" |
| 31 | |
| 32 | #include "cctest.h" |
| 33 | |
| 34 | using namespace v8::internal; |
| 35 | |
| 36 | |
| 37 | class HandleArray : public Malloced { |
| 38 | public: |
| 39 | static const unsigned kArraySize = 200; |
| 40 | explicit HandleArray() {} |
| 41 | ~HandleArray() { Reset(v8::Isolate::GetCurrent()); } |
| 42 | void Reset(v8::Isolate* isolate) { |
| 43 | for (unsigned i = 0; i < kArraySize; i++) { |
| 44 | if (handles_[i].IsEmpty()) continue; |
| 45 | handles_[i].Dispose(isolate); |
| 46 | handles_[i].Clear(); |
| 47 | } |
| 48 | } |
| 49 | v8::Persistent<v8::Value> handles_[kArraySize]; |
| 50 | private: |
| 51 | DISALLOW_COPY_AND_ASSIGN(HandleArray); |
| 52 | }; |
| 53 | |
| 54 | |
| 55 | // An aligned character array of size 1024. |
| 56 | class AlignedArray : public Malloced { |
| 57 | public: |
| 58 | static const unsigned kArraySize = 1024/sizeof(uint64_t); |
| 59 | AlignedArray() { Reset(); } |
| 60 | |
| 61 | void Reset() { |
| 62 | for (unsigned i = 0; i < kArraySize; i++) { |
| 63 | data_[i] = 0; |
| 64 | } |
| 65 | } |
| 66 | |
| 67 | template<typename T> |
| 68 | T As() { return reinterpret_cast<T>(data_); } |
| 69 | |
| 70 | private: |
| 71 | uint64_t data_[kArraySize]; |
| 72 | DISALLOW_COPY_AND_ASSIGN(AlignedArray); |
| 73 | }; |
| 74 | |
| 75 | |
| 76 | class DescriptorTestHelper { |
| 77 | public: |
| 78 | DescriptorTestHelper() : |
| 79 | isolate_(NULL), array_(new AlignedArray), handle_array_(new HandleArray) { |
| 80 | v8::V8::Initialize(); |
| 81 | isolate_ = v8::Isolate::GetCurrent(); |
| 82 | } |
| 83 | v8::Isolate* isolate_; |
| 84 | // Data objects. |
| 85 | SmartPointer<AlignedArray> array_; |
| 86 | SmartPointer<HandleArray> handle_array_; |
| 87 | private: |
| 88 | DISALLOW_COPY_AND_ASSIGN(DescriptorTestHelper); |
| 89 | }; |
| 90 | |
| 91 | |
| 92 | static v8::Local<v8::ObjectTemplate> CreateConstructor( |
| 93 | v8::Handle<v8::Context> context, |
| 94 | const char* class_name, |
| 95 | int internal_field, |
| 96 | const char* descriptor_name = NULL, |
| 97 | v8::Handle<v8::DeclaredAccessorDescriptor> descriptor = |
| 98 | v8::Handle<v8::DeclaredAccessorDescriptor>()) { |
| 99 | v8::Local<v8::FunctionTemplate> constructor = v8::FunctionTemplate::New(); |
| 100 | v8::Local<v8::ObjectTemplate> obj_template = constructor->InstanceTemplate(); |
| 101 | // Setup object template. |
| 102 | if (descriptor_name != NULL && !descriptor.IsEmpty()) { |
| 103 | bool added_accessor = |
| 104 | obj_template->SetAccessor(v8_str(descriptor_name), descriptor); |
| 105 | CHECK(added_accessor); |
| 106 | } |
| 107 | obj_template->SetInternalFieldCount((internal_field+1)*2 + 7); |
| 108 | context->Global()->Set(v8_str(class_name), constructor->GetFunction()); |
| 109 | return obj_template; |
| 110 | } |
| 111 | |
| 112 | |
| 113 | static void VerifyRead(v8::Handle<v8::DeclaredAccessorDescriptor> descriptor, |
| 114 | int internal_field, |
| 115 | void* internal_object, |
| 116 | v8::Handle<v8::Value> expected_value) { |
ulan@chromium.org | 750145a | 2013-03-07 15:14:13 +0000 | [diff] [blame] | 117 | LocalContext local_context; |
svenpanne@chromium.org | 2bda543 | 2013-03-15 12:39:50 +0000 | [diff] [blame] | 118 | v8::HandleScope scope(local_context->GetIsolate()); |
ulan@chromium.org | 750145a | 2013-03-07 15:14:13 +0000 | [diff] [blame] | 119 | v8::Handle<v8::Context> context = local_context.local(); |
| 120 | CreateConstructor(context, "Accessible", internal_field, "x", descriptor); |
| 121 | // Setup object. |
| 122 | CompileRun("var accessible = new Accessible();"); |
| 123 | v8::Local<v8::Object> obj( |
| 124 | v8::Object::Cast(*context->Global()->Get(v8_str("accessible")))); |
| 125 | obj->SetAlignedPointerInInternalField(internal_field, internal_object); |
| 126 | bool added_accessor; |
| 127 | added_accessor = obj->SetAccessor(v8_str("y"), descriptor); |
| 128 | CHECK(added_accessor); |
| 129 | added_accessor = obj->SetAccessor(v8_str("13"), descriptor); |
| 130 | CHECK(added_accessor); |
| 131 | // Test access from template getter. |
| 132 | v8::Local<v8::Value> value; |
| 133 | value = CompileRun("accessible.x;"); |
| 134 | CHECK_EQ(expected_value, value); |
| 135 | value = CompileRun("accessible['x'];"); |
| 136 | CHECK_EQ(expected_value, value); |
| 137 | // Test access from object getter. |
| 138 | value = CompileRun("accessible.y;"); |
| 139 | CHECK_EQ(expected_value, value); |
| 140 | value = CompileRun("accessible['y'];"); |
| 141 | CHECK_EQ(expected_value, value); |
| 142 | value = CompileRun("accessible[13];"); |
| 143 | CHECK_EQ(expected_value, value); |
| 144 | value = CompileRun("accessible['13'];"); |
| 145 | CHECK_EQ(expected_value, value); |
| 146 | } |
| 147 | |
| 148 | |
| 149 | static v8::Handle<v8::Value> Convert(int32_t value, v8::Isolate* isolate) { |
| 150 | return v8::Integer::New(value, isolate); |
| 151 | } |
| 152 | |
| 153 | |
| 154 | static v8::Handle<v8::Value> Convert(float value, v8::Isolate*) { |
| 155 | return v8::Number::New(value); |
| 156 | } |
| 157 | |
| 158 | |
| 159 | static v8::Handle<v8::Value> Convert(double value, v8::Isolate*) { |
| 160 | return v8::Number::New(value); |
| 161 | } |
| 162 | |
| 163 | |
| 164 | typedef v8::ObjectOperationDescriptor OOD; |
| 165 | |
| 166 | template<typename T> |
| 167 | static void TestPrimitiveValue( |
| 168 | T value, |
| 169 | v8::DeclaredAccessorDescriptorDataType data_type, |
| 170 | DescriptorTestHelper* helper) { |
svenpanne@chromium.org | 2bda543 | 2013-03-15 12:39:50 +0000 | [diff] [blame] | 171 | v8::HandleScope handle_scope(helper->isolate_); |
ulan@chromium.org | 750145a | 2013-03-07 15:14:13 +0000 | [diff] [blame] | 172 | int index = 17; |
| 173 | int internal_field = 6; |
| 174 | v8::Handle<v8::DeclaredAccessorDescriptor> descriptor = |
| 175 | OOD::NewInternalFieldDereference(helper->isolate_, internal_field) |
| 176 | ->NewRawShift(helper->isolate_, static_cast<uint16_t>(index*sizeof(T))) |
| 177 | ->NewPrimitiveValue(helper->isolate_, data_type, 0); |
| 178 | v8::Handle<v8::Value> expected = Convert(value, helper->isolate_); |
| 179 | helper->array_->Reset(); |
| 180 | helper->array_->As<T*>()[index] = value; |
| 181 | VerifyRead(descriptor, internal_field, *helper->array_, expected); |
| 182 | } |
| 183 | |
| 184 | |
| 185 | TEST(PrimitiveValueRead) { |
| 186 | DescriptorTestHelper helper; |
| 187 | TestPrimitiveValue<int32_t>(203, v8::kDescriptorInt32Type, &helper); |
| 188 | TestPrimitiveValue<float>(23.7f, v8::kDescriptorFloatType, &helper); |
| 189 | TestPrimitiveValue<double>(23.7, v8::kDescriptorDoubleType, &helper); |
| 190 | } |
| 191 | |
| 192 | |
| 193 | template<typename T> |
| 194 | static void TestBitmaskCompare(T bitmask, |
| 195 | T compare_value, |
| 196 | DescriptorTestHelper* helper) { |
svenpanne@chromium.org | 2bda543 | 2013-03-15 12:39:50 +0000 | [diff] [blame] | 197 | v8::HandleScope handle_scope(helper->isolate_); |
ulan@chromium.org | 750145a | 2013-03-07 15:14:13 +0000 | [diff] [blame] | 198 | int index = 13; |
| 199 | int internal_field = 4; |
| 200 | v8::Handle<v8::RawOperationDescriptor> raw_descriptor = |
| 201 | OOD::NewInternalFieldDereference(helper->isolate_, internal_field) |
| 202 | ->NewRawShift(helper->isolate_, static_cast<uint16_t>(index*sizeof(T))); |
| 203 | v8::Handle<v8::DeclaredAccessorDescriptor> descriptor; |
| 204 | switch (sizeof(T)) { |
| 205 | case 1: |
| 206 | descriptor = raw_descriptor->NewBitmaskCompare8( |
| 207 | helper->isolate_, |
| 208 | static_cast<uint8_t>(bitmask), |
| 209 | static_cast<uint8_t>(compare_value)); |
| 210 | break; |
| 211 | case 2: |
| 212 | descriptor = raw_descriptor->NewBitmaskCompare16( |
| 213 | helper->isolate_, |
| 214 | static_cast<uint16_t>(bitmask), |
| 215 | static_cast<uint16_t>(compare_value)); |
| 216 | break; |
| 217 | case 4: |
| 218 | descriptor = raw_descriptor->NewBitmaskCompare32( |
| 219 | helper->isolate_, |
| 220 | static_cast<uint32_t>(bitmask), |
| 221 | static_cast<uint32_t>(compare_value)); |
| 222 | break; |
| 223 | default: |
| 224 | CHECK(false); |
| 225 | break; |
| 226 | } |
| 227 | AlignedArray* array = *helper->array_; |
| 228 | array->Reset(); |
| 229 | VerifyRead(descriptor, internal_field, array, v8::False(helper->isolate_)); |
| 230 | array->As<T*>()[index] = compare_value; |
| 231 | VerifyRead(descriptor, internal_field, array, v8::True(helper->isolate_)); |
| 232 | helper->array_->As<T*>()[index] = compare_value & bitmask; |
| 233 | VerifyRead(descriptor, internal_field, array, v8::True(helper->isolate_)); |
| 234 | } |
| 235 | |
| 236 | |
| 237 | TEST(BitmaskCompareRead) { |
| 238 | DescriptorTestHelper helper; |
| 239 | TestBitmaskCompare<uint8_t>(0xf3, 0xa8, &helper); |
| 240 | TestBitmaskCompare<uint16_t>(0xfefe, 0x7d42, &helper); |
| 241 | TestBitmaskCompare<uint32_t>(0xfefeab18, 0x1234fdec, &helper); |
| 242 | } |
| 243 | |
| 244 | |
| 245 | TEST(PointerCompareRead) { |
| 246 | DescriptorTestHelper helper; |
svenpanne@chromium.org | 2bda543 | 2013-03-15 12:39:50 +0000 | [diff] [blame] | 247 | v8::HandleScope handle_scope(helper.isolate_); |
ulan@chromium.org | 750145a | 2013-03-07 15:14:13 +0000 | [diff] [blame] | 248 | int index = 35; |
| 249 | int internal_field = 3; |
| 250 | void* ptr = helper.isolate_; |
| 251 | v8::Handle<v8::DeclaredAccessorDescriptor> descriptor = |
| 252 | OOD::NewInternalFieldDereference(helper.isolate_, internal_field) |
| 253 | ->NewRawShift(helper.isolate_, static_cast<uint16_t>(index*sizeof(ptr))) |
| 254 | ->NewPointerCompare(helper.isolate_, ptr); |
| 255 | AlignedArray* array = *helper.array_; |
| 256 | VerifyRead(descriptor, internal_field, array, v8::False(helper.isolate_)); |
| 257 | array->As<uintptr_t*>()[index] = reinterpret_cast<uintptr_t>(ptr); |
| 258 | VerifyRead(descriptor, internal_field, array, v8::True(helper.isolate_)); |
| 259 | } |
| 260 | |
| 261 | |
| 262 | TEST(PointerDereferenceRead) { |
| 263 | DescriptorTestHelper helper; |
svenpanne@chromium.org | 2bda543 | 2013-03-15 12:39:50 +0000 | [diff] [blame] | 264 | v8::HandleScope handle_scope(helper.isolate_); |
ulan@chromium.org | 750145a | 2013-03-07 15:14:13 +0000 | [diff] [blame] | 265 | int first_index = 13; |
| 266 | int internal_field = 7; |
| 267 | int second_index = 11; |
| 268 | int pointed_to_index = 75; |
| 269 | uint16_t expected = 0x1425; |
| 270 | v8::Handle<v8::DeclaredAccessorDescriptor> descriptor = |
| 271 | OOD::NewInternalFieldDereference(helper.isolate_, internal_field) |
| 272 | ->NewRawShift(helper.isolate_, first_index*kPointerSize) |
| 273 | ->NewRawDereference(helper.isolate_) |
| 274 | ->NewRawShift(helper.isolate_, |
| 275 | static_cast<uint16_t>(second_index*sizeof(int16_t))) |
| 276 | ->NewPrimitiveValue(helper.isolate_, v8::kDescriptorInt16Type, 0); |
| 277 | AlignedArray* array = *helper.array_; |
| 278 | array->As<uintptr_t**>()[first_index] = |
| 279 | &array->As<uintptr_t*>()[pointed_to_index]; |
| 280 | VerifyRead(descriptor, internal_field, array, v8::Integer::New(0)); |
| 281 | second_index += pointed_to_index*sizeof(uintptr_t)/sizeof(uint16_t); |
| 282 | array->As<uint16_t*>()[second_index] = expected; |
| 283 | VerifyRead(descriptor, internal_field, array, v8::Integer::New(expected)); |
| 284 | } |
| 285 | |
| 286 | |
| 287 | TEST(HandleDereferenceRead) { |
| 288 | DescriptorTestHelper helper; |
svenpanne@chromium.org | 2bda543 | 2013-03-15 12:39:50 +0000 | [diff] [blame] | 289 | v8::HandleScope handle_scope(helper.isolate_); |
ulan@chromium.org | 750145a | 2013-03-07 15:14:13 +0000 | [diff] [blame] | 290 | int index = 13; |
| 291 | int internal_field = 0; |
| 292 | v8::Handle<v8::DeclaredAccessorDescriptor> descriptor = |
| 293 | OOD::NewInternalFieldDereference(helper.isolate_, internal_field) |
| 294 | ->NewRawShift(helper.isolate_, index*kPointerSize) |
| 295 | ->NewHandleDereference(helper.isolate_); |
| 296 | HandleArray* array = *helper.handle_array_; |
| 297 | v8::Handle<v8::String> expected = v8_str("whatever"); |
| 298 | array->handles_[index] = v8::Persistent<v8::Value>::New(helper.isolate_, |
| 299 | expected); |
| 300 | VerifyRead(descriptor, internal_field, array, expected); |
| 301 | } |