Runtime version of declarative native accessors.

src/objects.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 145 matching lines @@
                                              String* name,
                                              PropertyAttributes* attributes) {
   LookupResult result(name->GetIsolate());
   Lookup(name, &result);
   MaybeObject* value = GetProperty(receiver, &result, name, attributes);
   ASSERT(*attributes <= ABSENT);
   return value;
 }
 
 
+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) {
   Isolate* isolate = name->GetIsolate();
   // To accommodate both the old and the new api we switch on the
   // data structure used to store the callbacks.  Eventually foreign
   // callbacks should be phased out.
   if (structure->IsForeign()) {
     AccessorDescriptor* callback =
         reinterpret_cast<AccessorDescriptor*>(
             Foreign::cast(structure)->foreign_address());
     MaybeObject* value = (callback->getter)(receiver, callback->data);
     RETURN_IF_SCHEDULED_EXCEPTION(isolate);
     return value;
   }
 
   // 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 };
       Handle<Object> error =
           isolate->factory()->NewTypeError("incompatible_method_receiver",
                                            HandleVector(args,
                                                         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();
     HandleScope scope(isolate);
     JSObject* self = JSObject::cast(receiver);
     Handle<String> key(name);
     LOG(isolate, ApiNamedPropertyAccess("load", self, name));
     CustomArguments args(isolate, data->data(), self, this);
     v8::AccessorInfo info(args.end());
     v8::Handle<v8::Value> result;
@@ skipping 15 matching lines @@
   if (structure->IsAccessorPair()) {
     Object* getter = AccessorPair::cast(structure)->getter();
     if (getter->IsSpecFunction()) {
       // TODO(rossberg): nicer would be to cast to some JSCallable here...
       return GetPropertyWithDefinedGetter(receiver, JSReceiver::cast(getter));
     }
     // Getter is not a function.
     return isolate->heap()->undefined_value();
   }
 
-  // TODO(dcarney): Handle correctly.
-  if (structure->IsDeclaredAccessorInfo()) {
-    return isolate->heap()->undefined_value();
-  }
-
   UNREACHABLE();
   return NULL;
 }
 
 
 MaybeObject* JSProxy::GetPropertyWithHandler(Object* receiver_raw,
                                              String* name_raw) {
   Isolate* isolate = GetIsolate();
   HandleScope scope(isolate);
   Handle<Object> receiver(receiver_raw);
@@ skipping 9531 matching lines @@
     Object* getter = AccessorPair::cast(structure)->getter();
     if (getter->IsSpecFunction()) {
       // TODO(rossberg): nicer would be to cast to some JSCallable here...
       return GetPropertyWithDefinedGetter(receiver, JSReceiver::cast(getter));
     }
     // Getter is not a function.
     return isolate->heap()->undefined_value();
   }
 
   if (structure->IsDeclaredAccessorInfo()) {
-    // TODO(dcarney): Handle correctly.
-    return isolate->heap()->undefined_value();
+    return GetDeclaredAccessorProperty(receiver,
+                                       DeclaredAccessorInfo::cast(structure),
+                                       isolate);
   }
 
   UNREACHABLE();
   return NULL;
 }
 
 
 MaybeObject* JSObject::SetElementWithCallback(Object* structure,
                                               uint32_t index,
                                               Object* value,
@@ skipping 3742 matching lines @@
 }
 
 
 void ObjectHashTable::RemoveEntry(int entry) {
   set_the_hole(EntryToIndex(entry));
   set_the_hole(EntryToIndex(entry) + 1);
   ElementRemoved();
 }
 
 
+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) {
   // Get the break point info object for this code position.
   Object* break_point_info = GetBreakPointInfo(code_position);
 
   // If there is no break point info object or no break points in the break
   // point info object there is no break point at this code position.
   if (break_point_info->IsUndefined()) return false;
   return BreakPointInfo::cast(break_point_info)->GetBreakPointCount() > 0;
@@ skipping 363 matching lines @@
   set_year(Smi::FromInt(year), SKIP_WRITE_BARRIER);
   set_month(Smi::FromInt(month), SKIP_WRITE_BARRIER);
   set_day(Smi::FromInt(day), SKIP_WRITE_BARRIER);
   set_weekday(Smi::FromInt(weekday), SKIP_WRITE_BARRIER);
   set_hour(Smi::FromInt(hour), SKIP_WRITE_BARRIER);
   set_min(Smi::FromInt(min), SKIP_WRITE_BARRIER);
   set_sec(Smi::FromInt(sec), SKIP_WRITE_BARRIER);
 }
 
 } }  // namespace v8::internal