Runtime version of declarative native accessors.

src/objects.cc

Index: src/objects.cc
diff --git a/src/objects.cc b/src/objects.cc
index 7d00a561c549eb06eed1ba95f3e78ba180cbff47..2a352c752bbc3876a999d552b14e714aa10476d7 100644
--- a/src/objects.cc
+++ b/src/objects.cc
@@ -163,6 +163,182 @@ MaybeObject* Object::GetPropertyWithReceiver(Object* receiver,
 }
 
 
+template<typename To>
+static inline To* CheckedCast(void *from) {
+  uintptr_t temp = reinterpret_cast<uintptr_t>(from);
+  ASSERT(temp % sizeof(To) == 0);
+  return reinterpret_cast<To*>(temp);
+}
+
+
+static MaybeObject* PerformCompare(const BitmaskCompareDescriptor& descriptor,
+                                   char* ptr,
+                                   Isolate* isolate) {
+  uint32_t bitmask = descriptor.bitmask;
+  uint32_t compare_value = descriptor.compare_value;
+  uint32_t value;
+  switch (descriptor.size) {
+    case 1:
+      value = static_cast<uint32_t>(*CheckedCast<uint8_t>(ptr));
+      compare_value &= 0xff;
+      bitmask &= 0xff;
+      break;
+    case 2:
+      value = static_cast<uint32_t>(*CheckedCast<uint16_t>(ptr));
+      compare_value &= 0xffff;
+      bitmask &= 0xffff;
+      break;
+    case 4:
+      value = *CheckedCast<uint32_t>(ptr);
+      break;
+    default:
+      UNREACHABLE();
+      return NULL;
+  }
+  bool result = (bitmask & value) == (bitmask & compare_value);
+  return result ? isolate->heap()->true_value()
+                : isolate->heap()->false_value();
+}
+
+
+static MaybeObject* PerformCompare(const PointerCompareDescriptor& descriptor,
+                                   char* ptr,
+                                   Isolate* isolate) {
+  uintptr_t compare_value =
+      reinterpret_cast<uintptr_t>(descriptor.compare_value);
+  uintptr_t value = *CheckedCast<uintptr_t>(ptr);
+  bool result = compare_value == value;
+  return result ? isolate->heap()->true_value()
+                : isolate->heap()->false_value();
+}
+
+
+static MaybeObject* GetPrimitiveValue(
+    const PrimitiveValueDescriptor& descriptor,
+    char* ptr,
+    Isolate* isolate) {
+  int32_t int32_value;
+  switch (descriptor.data_type) {
+    case kDescriptorInt8Type:
+      int32_value = *CheckedCast<int8_t>(ptr);
+      break;
+    case kDescriptorUint8Type:
+      int32_value = *CheckedCast<uint8_t>(ptr);
+      break;
+    case kDescriptorInt16Type:
+      int32_value = *CheckedCast<int16_t>(ptr);
+      break;
+    case kDescriptorUint16Type:
+      int32_value = *CheckedCast<uint16_t>(ptr);
+      break;
+    case kDescriptorInt32Type:
+      int32_value = *CheckedCast<int32_t>(ptr);
+      break;
+    case kDescriptorUint32Type: {
+      uint32_t value = *CheckedCast<uint32_t>(ptr);
+      return *isolate->factory()->NewNumberFromUint(value);

[Sven Panne, 2013/02/19 08:41:16]

Using Handles in non-handlified code is not GC safe, so you can never use any
handlified factory methods from MaybeObject-land.

+    }
+    case kDescriptorBoolType: {
+      uint8_t byte = *CheckedCast<uint8_t>(ptr);
+      bool result = byte & (0x1 << descriptor.bool_offset);
+      return result ? isolate->heap()->true_value()
+                    : isolate->heap()->false_value();
+    }
+    case kDescriptorFloatType: {
+      float value = *CheckedCast<float>(ptr);
+      return *isolate->factory()->NewNumber(value);

[Sven Panne, 2013/02/19 08:41:16]

Same here...

+    }
+    case kDescriptorDoubleType: {
+      double value = *CheckedCast<double>(ptr);
+      return *isolate->factory()->NewNumber(value);

[Sven Panne, 2013/02/19 08:41:16]

Same here...

+    }
+    default:
+      UNREACHABLE();
+      return NULL;
+  }
+  return *isolate->factory()->NewNumberFromInt(int32_value);

[Sven Panne, 2013/02/19 08:41:16]

Same here...

+}
+
+
+static MaybeObject* GetDeclaredAccessorProperty(Object* receiver,
+                                                DeclaredAccessorInfo* info,
+                                                Isolate* isolate) {
+  v8::AccessorDescriptor descriptor;
+  // Simulate a handle.
+  char* current = NULL;  // This will be set in the first loop iteration.
+  // Dereference through the chain.
+  {
+    AssertNoAllocation no_allocation;
+    ByteArray* byte_array = info->descriptor()->serialized_descriptor();
+    int length = byte_array->length();
+    uint8_t* bytes = byte_array->GetDataStartAddress();
+    AccessorDescriptorDeserializer deserializer(length, bytes);
+    bool current_is_object = true;
+    bool first = true;
+    bool complete;
+    do {
+      ASSERT(!deserializer.Complete());
+      deserializer.Next(&descriptor);
+      if (!current_is_object) {
+        // Dereference pointer.
+        current = *reinterpret_cast<char**>(current);
+      } else {
+        // Open handle and get internal field value.
+        Object* object;
+        if (first) {
+          object = receiver;
+          first = false;
+        } else {
+          current = *reinterpret_cast<char**>(current);
+          object = *CheckedCast<Object*>(current);
+        }
+        Object* smi = JSObject::cast(object)->GetInternalField(descriptor.internal_field);
+        ASSERT(smi->IsSmi());
+        current = reinterpret_cast<char*>(smi);
+      }
+      current += descriptor.byte_offset;
+      complete = deserializer.Complete();
+      switch (descriptor.type) {
+        case kDescriptorPointerDereference:
+          if (complete) {
+            return *CheckedCast<Object*>(current);
+          }
+          current_is_object = false;
+          break;
+        case kDescriptorInternalFieldDereference:
+          if (complete) {
+            return *CheckedCast<Object*>(current);
+          }
+          current_is_object = true;
+          break;
+        default:

[Sven Panne, 2013/02/19 08:41:16]

No default cases, explicitly handle all cases.

+          ASSERT(complete);
+          break;
+      }
+    } while (!complete);
+  }
+  // Can now process instructions requiring allocation.
+  switch (descriptor.type) {
+    case kDescriptorBitmaskCompare:
+      return PerformCompare(descriptor.bitmask_compare_descriptor,
+                            current,
+                            isolate);
+    case kDescriptorPointerCompare:
+      return PerformCompare(descriptor.pointer_compare_descriptor,
+                            current,
+                            isolate);
+    case kDescriptorPrimitiveValue:
+      return GetPrimitiveValue(descriptor.primitive_value_descriptor,
+                               current,
+                               isolate);
+    default:

[Sven Panne, 2013/02/19 08:41:16]

No default cases, explicitly handle all cases.

+      break;
+  }
+  UNREACHABLE();
+  return NULL;
+}
+
+
 MaybeObject* JSObject::GetPropertyWithCallback(Object* receiver,
                                                Object* structure,
                                                String* name) {
@@ -180,9 +356,8 @@ MaybeObject* JSObject::GetPropertyWithCallback(Object* receiver,
   }
 
   // api style callbacks.
-  if (structure->IsExecutableAccessorInfo()) {
-    ExecutableAccessorInfo* data = ExecutableAccessorInfo::cast(structure);
-    if (!data->IsCompatibleReceiver(receiver)) {
+  if (structure->IsAccessorInfo()) {
+    if (!AccessorInfo::cast(structure)->IsCompatibleReceiver(receiver)) {
       Handle<Object> name_handle(name);
       Handle<Object> receiver_handle(receiver);
       Handle<Object> args[2] = { name_handle, receiver_handle };
@@ -192,6 +367,12 @@ MaybeObject* JSObject::GetPropertyWithCallback(Object* receiver,
                                                         ARRAY_SIZE(args)));
       return isolate->Throw(*error);
     }
+    if (structure->IsDeclaredAccessorInfo()) {
+      return GetDeclaredAccessorProperty(receiver,
+                                         DeclaredAccessorInfo::cast(structure),
+                                         isolate);
+    }
+    ExecutableAccessorInfo* data = ExecutableAccessorInfo::cast(structure);
     Object* fun_obj = data->getter();
     v8::AccessorGetter call_fun = v8::ToCData<v8::AccessorGetter>(fun_obj);
     if (call_fun == NULL) return isolate->heap()->undefined_value();
@@ -227,11 +408,6 @@ MaybeObject* JSObject::GetPropertyWithCallback(Object* receiver,
     return isolate->heap()->undefined_value();
   }
 
-  // TODO(dcarney): Handle correctly.
-  if (structure->IsDeclaredAccessorInfo()) {
-    return isolate->heap()->undefined_value();
-  }
-
   UNREACHABLE();
   return NULL;
 }
@@ -9783,8 +9959,9 @@ MaybeObject* JSObject::GetElementWithCallback(Object* receiver,
   }
 
   if (structure->IsDeclaredAccessorInfo()) {
-    // TODO(dcarney): Handle correctly.
-    return isolate->heap()->undefined_value();
+    return GetDeclaredAccessorProperty(receiver,
+                                       DeclaredAccessorInfo::cast(structure),
+                                       isolate);
   }
 
   UNREACHABLE();
@@ -13547,6 +13724,118 @@ void ObjectHashTable::RemoveEntry(int entry) {
 }
 
 
+class AccessorDescriptorLengthCounter {

[Sven Panne, 2013/02/19 08:41:16]

Very unclear what this does and why it is needed...

+ public:
+  AccessorDescriptorLengthCounter() : length_(0), error_(false), depth_(0) {}
+
+  template<typename T>
+  bool ShouldVisit(T* descriptor) {
+    return !error_ && descriptor != NULL;
+  }
+
+  bool ShouldVisit(v8::AccessorDescriptor* descriptor) {
+    if (descriptor == NULL) return false;
+    // TODO(dcarney): Move this limit to v8.h
+    if (depth_ > 5) error_ = true;
+    depth_++;
+    return !error_;
+  }
+
+  bool ShouldVisit(v8::PrimitiveValueDescriptor* descriptor) {
+    ASSERT(descriptor != NULL);
+    if (descriptor->data_type == kDescriptorInt8Type &&
+        descriptor->bool_offset >= 8) {
+      error_ = true;
+    }
+    return !error_;
+  }
+
+  bool ShouldVisit(v8::BitmaskCompareDescriptor* descriptor) {
+    ASSERT(descriptor != NULL);
+    switch (descriptor->size) {
+      case 1:
+      case 2:
+      case 4:
+        break;
+      default:
+        error_ = true;
+        break;
+    }
+    return !error_;
+  }
+
+  template<typename T>
+  void Visit(T* member) {
+    length_ += AccessorDescriptorSerialization<T>::kArraySize;
+  }
+
+  void VisitError() { error_ = true; }
+
+  uint16_t Length() { return error_ ? -1 : length_; }
+
+ private:
+  uint16_t length_;
+  bool error_;
+  uint8_t depth_;
+  DISALLOW_COPY_AND_ASSIGN(AccessorDescriptorLengthCounter);
+};
+
+
+class AccessorDescriptorSerializer : public AccessorDescriptorSerializerBase {
+ public:
+  AccessorDescriptorSerializer(uint16_t length, uint8_t* storage) :
+    AccessorDescriptorSerializerBase(length, storage) {
+  }
+
+  template<typename T>
+  bool ShouldVisit(T* descriptor) {
+    return descriptor != NULL;
+  }
+
+  template<typename T>
+  void Visit(T* member) {
+    typedef AccessorDescriptorSerialization<T> Ser;
+    CHECK(offset_ + Ser::kArraySize <= length_);
+    Ser::Serialize(*member, &storage_[offset_]);
+    offset_ += Ser::kArraySize;
+  }
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(AccessorDescriptorSerializer);
+};
+
+
+int DeclaredAccessorDescriptor::SerializedLength(
+    const v8::AccessorDescriptor* descriptor) {
+  AccessorDescriptorLengthCounter length_counter;
+  v8::DescriptorVisitorHelper::VisitDescriptor(
+      const_cast<v8::AccessorDescriptor*>(descriptor), &length_counter);
+  return length_counter.Length();
+}
+
+
+Handle<DeclaredAccessorDescriptor> DeclaredAccessorDescriptor::Create(
+    const v8::AccessorDescriptor* descriptor,
+    Isolate* isolate) {
+  int length = SerializedLength(descriptor);
+  if (length <= 0) return Handle<DeclaredAccessorDescriptor>();
+  Handle<ByteArray> data = isolate->factory()->NewByteArray(length);
+  {
+    AssertNoAllocation no_allocation;
+    uint8_t* storage = data->GetDataStartAddress();
+    AccessorDescriptorSerializer serializer(length, storage);
+    v8::DescriptorVisitorHelper::VisitDescriptor(
+        const_cast<v8::AccessorDescriptor*>(descriptor), &serializer);
+    CHECK(serializer.Complete());
+  }
+  Handle<DeclaredAccessorDescriptor> value =
+      isolate->factory()->NewDeclaredAccessorDescriptor();
+  value->set_serialized_descriptor(*data);
+  // TODO(dcarney): Insert into global hash set.
+  return value;
+}
+
+
 #ifdef ENABLE_DEBUGGER_SUPPORT
 // Check if there is a break point at this code position.
 bool DebugInfo::HasBreakPoint(int code_position) {