Runtime version of declarative native accessors.

src/objects-inl.h

 // 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 4095 matching lines @@
 ACCESSORS(GlobalObject, global_context, Context, kGlobalContextOffset)
 ACCESSORS(GlobalObject, global_receiver, JSObject, kGlobalReceiverOffset)
 
 ACCESSORS(JSGlobalProxy, native_context, Object, kNativeContextOffset)
 
 ACCESSORS(AccessorInfo, name, Object, kNameOffset)
 ACCESSORS_TO_SMI(AccessorInfo, flag, kFlagOffset)
 ACCESSORS(AccessorInfo, expected_receiver_type, Object,
           kExpectedReceiverTypeOffset)
 
-ACCESSORS(DeclaredAccessorDescriptor, internal_field, Smi, kInternalFieldOffset)
+ACCESSORS(DeclaredAccessorDescriptor, serialized_descriptor, ByteArray,
+          kSerializedDescriptorOffset)
 
 ACCESSORS(DeclaredAccessorInfo, descriptor, DeclaredAccessorDescriptor,
           kDescriptorOffset)
 
 ACCESSORS(ExecutableAccessorInfo, getter, Object, kGetterOffset)
 ACCESSORS(ExecutableAccessorInfo, setter, Object, kSetterOffset)
 ACCESSORS(ExecutableAccessorInfo, data, Object, kDataOffset)
 
 ACCESSORS(AccessorPair, getter, Object, kGetterOffset)
 ACCESSORS(AccessorPair, setter, Object, kSetterOffset)
@@ skipping 1367 matching lines @@
 }
 
 
 bool AccessorInfo::IsCompatibleReceiver(Object* receiver) {
   Object* function_template = expected_receiver_type();
   if (!function_template->IsFunctionTemplateInfo()) return true;
   return receiver->IsInstanceOf(FunctionTemplateInfo::cast(function_template));
 }
 
 
+template<int size>

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

I'm again not sure if we need this massive machinery. And even if we need it,
the header doesn't feel like the right place.

+struct AccessorDescriptorSerializationHelper {
+};
+template<>
+struct AccessorDescriptorSerializationHelper<1> {
+  typedef uint8_t UType;
+};
+template<>
+struct AccessorDescriptorSerializationHelper<2> {
+  typedef uint16_t UType;
+};
+template<>
+struct AccessorDescriptorSerializationHelper<4> {
+  typedef uint32_t UType;
+};
+template<>
+struct AccessorDescriptorSerializationHelper<8> {
+  typedef uint64_t UType;
+};
+
+
+template<typename Value>
+struct AccessorDescriptorSerialization {
+  static const int kArraySize = sizeof(Value);
+  typedef AccessorDescriptorSerializationHelper<kArraySize> Helper;
+  typedef typename Helper::UType UType;
+  static inline UType ToUType(Value value) {
+    return static_cast<UType>(value);
+  }
+  static inline Value FromUType(UType utype) {
+    return static_cast<Value>(utype);
+  }
+  static inline void Serialize(Value value, uint8_t array[kArraySize]) {
+    UType u_type = ToUType(value);
+    for (int i = 0; i < kArraySize; i++) {
+      array[i] = static_cast<uint8_t>(u_type >> (8 * i));
+    }
+  }
+  static inline Value Deserialize(uint8_t array[kArraySize]) {
+    UType temp = 0;
+    for (int i = 0; i < kArraySize; i++) {
+      temp |= static_cast<UType>(array[i]) << (8 * i);
+    }
+    return FromUType(temp);
+  }
+};
+
+
+template<>
+inline AccessorDescriptorSerialization<void*>::UType
+    AccessorDescriptorSerialization<void*>::ToUType(void* value) {
+  return reinterpret_cast<UType>(value);
+}
+
+
+template<>
+inline void* AccessorDescriptorSerialization<void*>::FromUType(
+    AccessorDescriptorSerialization<void*>::UType utype) {
+  return reinterpret_cast<void*>(utype);
+}
+
+
+AccessorDescriptorDeserializer::AccessorDescriptorDeserializer(
+    uint16_t length, uint8_t* storage) :
+    AccessorDescriptorSerializerBase(length, storage), visited_(true) {
+}
+
+
+void AccessorDescriptorDeserializer::Next(v8::AccessorDescriptor* descriptor) {
+  ASSERT(!Complete());
+  descriptor->derefence_descriptor = NULL;
+  visited_ = false;
+  v8::DescriptorVisitorHelper::VisitDescriptor(descriptor, this);
+}
+
+
+template<typename T>
+bool AccessorDescriptorDeserializer::ShouldVisit(T* descriptor) {
+  ASSERT(descriptor != NULL);
+  return true;
+}
+
+
+bool AccessorDescriptorDeserializer::ShouldVisit(
+    v8::AccessorDescriptor* descriptor) {
+  if (visited_) {
+    ASSERT(descriptor == NULL);
+    return false;
+  }
+  ASSERT(descriptor != NULL);
+  visited_ = true;
+  return true;
+}
+
+
+template<typename T>
+void AccessorDescriptorDeserializer::Visit(T* member) {
+  typedef AccessorDescriptorSerialization<T> Ser;
+  ASSERT(offset_ + Ser::kArraySize <= length_);
+  *member = Ser::Deserialize(&storage_[offset_]);
+  offset_ += Ser::kArraySize;
+}
+
+
 template<typename Shape, typename Key>
 void Dictionary<Shape, Key>::SetEntry(int entry,
                                       Object* key,
                                       Object* value) {
   SetEntry(entry, key, value, PropertyDetails(Smi::FromInt(0)));
 }
 
 
 template<typename Shape, typename Key>
 void Dictionary<Shape, Key>::SetEntry(int entry,
@@ skipping 388 matching lines @@
 #undef WRITE_UINT32_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_