Populate PrototypeInfo with prototype_object value

src/objects.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <iomanip>
 #include <sstream>
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
@@ skipping 9887 matching lines @@
 // static
 void JSObject::OptimizeAsPrototype(Handle<JSObject> object,
                                    PrototypeOptimizationMode mode) {
   if (object->IsGlobalObject()) return;
   if (object->IsJSGlobalProxy()) return;
   if (mode == FAST_PROTOTYPE && PrototypeBenefitsFromNormalization(object)) {
     // First normalize to ensure all JSFunctions are DATA_CONSTANT.
     JSObject::NormalizeProperties(object, KEEP_INOBJECT_PROPERTIES, 0,
                                   "NormalizeAsPrototype");
   }
-  Handle<Map> previous_map(object->map());
+  Isolate* isolate = object->GetIsolate();
+  Handle<Map> previous_map(object->map(), isolate);
   if (!object->HasFastProperties()) {
     JSObject::MigrateSlowToFast(object, 0, "OptimizeAsPrototype");
   }
   if (!object->map()->is_prototype_map()) {
     if (object->map() == *previous_map) {
       Handle<Map> new_map = Map::Copy(handle(object->map()), "CopyAsPrototype");
       JSObject::MigrateToMap(object, new_map);
     }
     Object* maybe_constructor = object->map()->GetConstructor();
     if (maybe_constructor->IsJSFunction()) {
       JSFunction* constructor = JSFunction::cast(maybe_constructor);
       // Replace the pointer to the exact constructor with the Object function
       // from the same context if undetectable from JS. This is to avoid keeping
       // memory alive unnecessarily.
       if (!constructor->shared()->IsApiFunction() &&
-          object->class_name() ==
-              object->GetIsolate()->heap()->Object_string()) {
+          object->class_name() == isolate->heap()->Object_string()) {
         Context* context = constructor->context()->native_context();
         JSFunction* object_function = context->object_function();
         object->map()->SetConstructor(object_function);
       }
     }
     object->map()->set_is_prototype_map(true);
   }
+  Handle<Map> new_map(object->map(), isolate);
+  Map::SetPrototypeObject(new_map, object, isolate);
 }
 
 
 // static
 void JSObject::ReoptimizeIfPrototype(Handle<JSObject> object) {
   if (!object->map()->is_prototype_map()) return;
   OptimizeAsPrototype(object, FAST_PROTOTYPE);
 }
 
 
 // static
 void JSObject::RegisterPrototypeUser(Handle<JSObject> prototype,
                                      Handle<HeapObject> user) {
   DCHECK(FLAG_track_prototype_users);
   Isolate* isolate = prototype->GetIsolate();
   if (prototype->IsJSGlobalProxy()) {
     prototype = handle(JSObject::cast(prototype->map()->prototype()), isolate);
   }
-  Handle<PrototypeInfo> proto_info;
-  Object* maybe_proto_info = prototype->map()->prototype_info();
-  if (maybe_proto_info->IsPrototypeInfo()) {
-    proto_info = handle(PrototypeInfo::cast(maybe_proto_info), isolate);
-  } else {
-    proto_info = isolate->factory()->NewPrototypeInfo(prototype);
-    prototype->map()->set_prototype_info(*proto_info);
-  }
+  Handle<Map> proto_map(prototype->map(), isolate);
+  Handle<PrototypeInfo> proto_info =
+      Map::GetOrCreatePrototypeInfo(proto_map, isolate);
+  proto_info->set_prototype_object(*prototype);
   Handle<Object> maybe_registry(proto_info->prototype_users(), isolate);
   Handle<WeakFixedArray> new_array = WeakFixedArray::Add(maybe_registry, user);
   if (!maybe_registry.is_identical_to(new_array)) {
     proto_info->set_prototype_users(*new_array);
   }
 }
 
 
 // static
 void JSObject::UnregisterPrototypeUser(Handle<JSObject> prototype,
                                        Handle<HeapObject> user) {
   Isolate* isolate = prototype->GetIsolate();
   if (prototype->IsJSGlobalProxy()) {
     prototype = handle(JSObject::cast(prototype->map()->prototype()), isolate);
   }
   DCHECK(prototype->map()->is_prototype_map());
   Object* maybe_proto_info = prototype->map()->prototype_info();
   if (!maybe_proto_info->IsPrototypeInfo()) return;
   Handle<PrototypeInfo> proto_info(PrototypeInfo::cast(maybe_proto_info),
                                    isolate);
   Object* maybe_registry = proto_info->prototype_users();
   if (!maybe_registry->IsWeakFixedArray()) return;
   WeakFixedArray::cast(maybe_registry)->Remove(user);
 }
 
 
 // static
+Handle<PrototypeInfo> Map::GetOrCreatePrototypeInfo(Handle<Map> map,
+                                                    Isolate* isolate) {
+  Object* maybe_proto_info = map->prototype_info();
+  if (maybe_proto_info->IsPrototypeInfo()) {
+    return handle(PrototypeInfo::cast(maybe_proto_info), isolate);
+  }
+  Handle<PrototypeInfo> proto_info = isolate->factory()->NewPrototypeInfo();
+  map->set_prototype_info(*proto_info);
+  return proto_info;
+}
+
+
+// static
+void Map::SetPrototypeObject(Handle<Map> map, Handle<JSObject> prototype_obj,
+                             Isolate* isolate) {
+  if (!FLAG_track_prototype_users) return;
+  Handle<PrototypeInfo> proto_info = GetOrCreatePrototypeInfo(map, isolate);
+  proto_info->set_prototype_object(*prototype_obj);
+}
+
+
+Object* Map::GetPrototypeObject() {
+  DisallowHeapAllocation no_handlification_required;
+  if (!is_prototype_map()) return Smi::FromInt(0);
+  Object* maybe_prototype_info = prototype_info();
+  if (!maybe_prototype_info->IsPrototypeInfo()) return Smi::FromInt(0);
+  PrototypeInfo* proto_info = PrototypeInfo::cast(maybe_prototype_info);
+  Object* maybe_obj = proto_info->prototype_object();
+  if (maybe_obj->IsSmi()) return maybe_obj;
+  JSObject* object = JSObject::cast(maybe_obj);
+  if (object->map() != this) {
+    proto_info->set_prototype_object(Smi::FromInt(0));
+    return Smi::FromInt(0);
+  }
+  return object;
+}
+
+
+// static
 void Map::SetPrototype(Handle<Map> map, Handle<Object> prototype,
                        PrototypeOptimizationMode proto_mode) {
   if (map->prototype()->IsJSObject() && FLAG_track_prototype_users) {
     Handle<JSObject> old_prototype(JSObject::cast(map->prototype()));
     JSObject::UnregisterPrototypeUser(old_prototype, map);
   }
   if (prototype->IsJSObject()) {
     Handle<JSObject> prototype_jsobj = Handle<JSObject>::cast(prototype);
     if (ShouldRegisterAsPrototypeUser(map, prototype_jsobj)) {
       JSObject::RegisterPrototypeUser(prototype_jsobj, map);
@@ skipping 7123 matching lines @@
                                                CompilationInfo* info) {
   Handle<DependentCode> codes = DependentCode::InsertCompilationInfo(
       handle(cell->dependent_code(), info->isolate()),
       DependentCode::kPropertyCellChangedGroup, info->object_wrapper());
   if (*codes != cell->dependent_code()) cell->set_dependent_code(*codes);
   info->dependencies(DependentCode::kPropertyCellChangedGroup)->Add(
       cell, info->zone());
 }
 
 } }  // namespace v8::internal