- Add the ability to protect VirtualMemory.

runtime/vm/object.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 410 matching lines @@
 
   ASSERT(class_class() != null_);
 
   // Pre-allocate the Array and OneByteString class in the vm isolate so that
   // we can create a symbol table and populate it with some frequently used
   // strings as symbols.
   cls = Class::New<Array>();
   isolate->object_store()->set_array_class(cls);
   cls = Class::New<OneByteString>();
   isolate->object_store()->set_one_byte_string_class(cls);
+
+  // TODO(asiva): Assign the names of shared classes instead of relying on the
+  // lookup switch in Object::GetSingletonClassName.
 }
 
 
 RawClass* Object::CreateAndRegisterInterface(const char* cname,
                                              const Script& script,
                                              const Library& lib) {
   const String& name = String::Handle(Symbols::New(cname));
   const Class& cls = Class::Handle(
       Class::NewInterface(name, script, Scanner::kDummyTokenIndex));
   lib.AddClass(cls);
@@ skipping 317 matching lines @@
 
   cls = CreateAndRegisterInterface("ByteArray", script, core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_byte_array_interface(type);
 
   // The classes 'Null' and 'void' are not registered in the class dictionary,
   // because their names are reserved keywords. Their names are not heap
   // allocated, because the classes reside in the VM isolate.
   // The corresponding types are stored in the object store.
-  cls = null_class_;
+  cls = null_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_null_type(type);
 
-  cls = void_class_;
+  cls = void_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_void_type(type);
 
   // The class 'Dynamic' is registered in the class dictionary because its name
   // is a built-in identifier, rather than a reserved keyword. Its name is not
   // heap allocated, because the class resides in the VM isolate.
   // The corresponding type, the "unknown type", is stored in the object store.
-  cls = dynamic_class_;
+  cls = dynamic_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_dynamic_type(type);
-  core_lib.AddClass(cls);
 
   // Allocate pre-initialized values.
   Bool& bool_value = Bool::Handle();
   bool_value = Bool::New(true);
   object_store->set_true_value(bool_value);
   bool_value = Bool::New(false);
   object_store->set_false_value(bool_value);
 
   // Setup some default native field classes which can be extended for
   // specifying native fields in dart classes.
@@ skipping 5250 matching lines @@
   isolate->object_store()->set_core_library(core_lib);
   const String& core_impl_lib_url =
       String::Handle(Symbols::New("dart:coreimpl"));
   const Library& core_impl_lib =
       Library::Handle(Library::NewLibraryHelper(core_impl_lib_url, false));
   isolate->object_store()->set_core_impl_library(core_impl_lib);
   core_impl_lib.Register();
   core_lib.AddImport(core_impl_lib);
   core_impl_lib.AddImport(core_lib);
   isolate->object_store()->set_root_library(Library::Handle());
+
+  // Hook up predefined classes without setting their library pointers. These
+  // classes are coming from the VM isolate, and are shared between multiple
+  // isolates so setting their library pointers would be wrong.
+  const Class& cls = Class::Handle(Object::dynamic_class());
+  core_lib.AddObject(cls, String::Handle(cls.Name()));
 }
 
 
 void Library::InitMathLibrary(Isolate* isolate) {
   const String& url = String::Handle(Symbols::New("dart:math"));
   const Library& lib = Library::Handle(Library::New(url));
   lib.Register();
   const Library& core_impl_lib = Library::Handle(Library::CoreImplLibrary());
   lib.AddImport(core_impl_lib);
   isolate->object_store()->set_math_library(lib);
@@ skipping 4782 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart