Add a runtime flag to control availability of dart:mirrors.

runtime/vm/dart.cc

 // Copyright (c) 2013, 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/dart.h"
 
 #include "vm/code_observers.h"
 #include "vm/cpu.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
@@ skipping 28 matching lines @@
             "e.g: --old_gen_heap_size=1024 allows up to 1024MB old gen heap");
 DEFINE_FLAG(int, external_max_size, (kWordSize <= 4) ? 512 : 1024,
             "Max total size of external allocations in MB, or 0 for unlimited,"
             "e.g: --external_max_size=1024 allows up to 1024MB of externals");
 
 DEFINE_FLAG(bool, keep_code, false,
             "Keep deoptimized code for profiling.");
 
 DECLARE_FLAG(bool, print_class_table);
 DECLARE_FLAG(bool, trace_isolates);
+DECLARE_FLAG(bool, use_mirrors);
 
 Isolate* Dart::vm_isolate_ = NULL;
 ThreadPool* Dart::thread_pool_ = NULL;
 DebugInfo* Dart::pprof_symbol_generator_ = NULL;
 ReadOnlyHandles* Dart::predefined_handles_ = NULL;
 
 // Structure for managing read-only global handles allocation used for
 // creating global read-only handles that are pre created and initialized
 // for use across all isolates. Having these global pre created handles
 // stored in the vm isolate ensures that we don't constantly create and
@@ skipping 211 matching lines @@
       OS::Print("Size of isolate snapshot = %" Pd "\n", snapshot->length());
     }
     IsolateSnapshotReader reader(snapshot->content(),
                                  snapshot->length(),
                                  isolate,
                                  zone.GetZone());
     const Error& error = Error::Handle(reader.ReadFullSnapshot());
     if (!error.IsNull()) {
       return error.raw();
     }
+
+    if (!FLAG_use_mirrors) {
+      const Object& libmirrors =
+          Object::Handle(isolate->object_store()->mirrors_library());

[Ivan Posva, 2015/05/29 06:02:24]

Should we at this point set the value in the object store for the mirrors
library to null as well?

[rmacnak, 2015/06/13 00:11:09]

Actually, this is unsafe. We sometimes lookup libraries by id.

Updated to just be a check on imports. We'll really remove the library at build
time for precompilation.

+      if (!libmirrors.IsNull()) {
+        // Mirrors were enabled when the snapshot was taken. Retroactively
+        // remove them.
+        const GrowableObjectArray& old_libs =

[Ivan Posva, 2015/05/29 06:02:24]

Instead of creating a new array, you could find the index of the mirrors
library, overwrite it with the last entry and shrink they array.

+          GrowableObjectArray::Handle(isolate->object_store()->libraries());
+        const GrowableObjectArray& new_libs = GrowableObjectArray::Handle(
+            GrowableObjectArray::New(old_libs.Length(), Heap::kOld));
+        Object& lib = Object::Handle();
+        for (intptr_t i = 0; i < old_libs.Length(); i++) {
+          lib = old_libs.At(i);
+          if (lib.raw() != libmirrors.raw()) {
+            new_libs.Add(lib);
+          }
+        }
+        isolate->object_store()->set_libraries(new_libs);
+      }
+    }
+
     if (FLAG_trace_isolates) {
       isolate->heap()->PrintSizes();
       isolate->megamorphic_cache_table()->PrintSizes();
     }
   } else {
     // Populate the isolate's symbol table with all symbols from the
     // VM isolate. We do this so that when we generate a full snapshot
     // for the isolate we have a unified symbol table that we can then
     // read into the VM isolate.
     Symbols::AddPredefinedSymbolsToIsolate();
@@ skipping 60 matching lines @@
   return predefined_handles_->handles_.AllocateScopedHandle();
 }
 
 
 bool Dart::IsReadOnlyHandle(uword address) {
   ASSERT(predefined_handles_ != NULL);
   return predefined_handles_->handles_.IsValidScopedHandle(address);
 }
 
 }  // namespace dart