Implement immutable prototype chains

src/api-natives.cc

 // Copyright 2015 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 "src/api-natives.h"
 
 #include "src/api.h"
 #include "src/isolate-inl.h"
 #include "src/lookup.h"
 #include "src/messages.h"
@@ skipping 286 matching lines @@
                                         Handle<JSReceiver> new_target,
                                         bool is_hidden_prototype) {
   Handle<JSFunction> constructor;
   uint32_t serial_number =
       static_cast<uint32_t>(Smi::cast(info->serial_number())->value());
   if (!new_target.is_null()) {
     if (new_target->IsJSFunction() &&
         JSFunction::cast(*new_target)->shared()->function_data() ==
             info->constructor() &&
         JSFunction::cast(*new_target)->context()->native_context() ==
-            isolate->context()->native_context()) {
+            isolate->context()->native_context() &&
+        !info->immutable_proto()) {
       constructor = Handle<JSFunction>::cast(new_target);
     } else {
       // Disable caching for subclass instantiation.
       serial_number = 0;
     }
   }
   // Fast path.
   Handle<JSObject> result;
   if (serial_number) {
     // Probe cache.
@@ skipping 21 matching lines @@
 
     if (new_target.is_null()) new_target = constructor;
   }
 
   Handle<JSObject> object;
   ASSIGN_RETURN_ON_EXCEPTION(isolate, object,
                              JSObject::New(constructor, new_target), JSObject);
   ASSIGN_RETURN_ON_EXCEPTION(
       isolate, result,
       ConfigureInstance(isolate, object, info, is_hidden_prototype), JSObject);
+  if (info->immutable_proto()) {
+    MAYBE_RETURN(JSObject::SetImmutableProto(

[Toon Verwaest, 2016/06/30 15:35:33]

I don't think we need to walk the hidden prototype chain since we'll see the
JS_GLOBAL_OBJECT and JS_GLOBAL_PROXY individually; and you should set the flag
on both templates anyway (or we could propagate it at template level). Just make
SetImmutableProto super-simple (just copy the map for immutable proto and set
the map).

[Dan Ehrenberg, 2016/06/30 23:12:41]

Removed all that extra useless code.

+                     object, false, Object::ShouldThrow::THROW_ON_ERROR),
+                 MaybeHandle<JSObject>());
+  }
   // TODO(dcarney): is this necessary?
   JSObject::MigrateSlowToFast(result, 0, "ApiNatives::InstantiateObject");
 
   if (serial_number) {
     CacheTemplateInstantiation(isolate, serial_number, result);
     result = isolate->factory()->CopyJSObject(result);
   }
   return scope.CloseAndEscape(result);
 }
 
@@ skipping 206 matching lines @@
   } else {
     JSObject::AddProperty(Handle<JSObject>::cast(prototype),
                           isolate->factory()->constructor_string(), result,
                           DONT_ENUM);
   }
 
   int internal_field_count = 0;
   if (!obj->instance_template()->IsUndefined(isolate)) {
     Handle<ObjectTemplateInfo> instance_template = Handle<ObjectTemplateInfo>(
         ObjectTemplateInfo::cast(obj->instance_template()));
-    internal_field_count =
-        Smi::cast(instance_template->internal_field_count())->value();
+    internal_field_count = instance_template->internal_field_count();
   }
 
   // TODO(svenpanne) Kill ApiInstanceType and refactor things by generalizing
   // JSObject::GetHeaderSize.
   int instance_size = kPointerSize * internal_field_count;
   InstanceType type;
   switch (instance_type) {
     case JavaScriptObjectType:
       if (!obj->needs_access_check() &&
           obj->named_property_handler()->IsUndefined(isolate) &&
@@ skipping 44 matching lines @@
   if (!obj->instance_call_handler()->IsUndefined(isolate)) {
     map->set_is_callable();
     map->set_is_constructor(true);
   }
 
   return result;
 }
 
 }  // namespace internal
 }  // namespace v8