VM: Support bootstrapping core libraries from Kernel binaries instead of source.

runtime/vm/object_store.h

 // 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.
 
 #ifndef RUNTIME_VM_OBJECT_STORE_H_
 #define RUNTIME_VM_OBJECT_STORE_H_
 
 #include "vm/object.h"
 
 namespace dart {
 
 // Forward declarations.
 class Isolate;
 class ObjectPointerVisitor;
 
+// A list of the bootstrap libraries including CamelName and hacker_name.
+//
+// These are listed in the order that they are compiled (see vm/bootstrap.cc).
+#define FOR_EACH_PRODUCT_LIBRARY(M)                                            \

[hausner, 2016/11/09 00:42:49]

Similar to Florian's comment, I would prefer to have refactoring done in
separate CLs.

[Vyacheslav Egorov (Google), 2016/11/09 14:43:16]

It's in separate CL now: https://codereview.chromium.org/2493473002/

+  M(Core, core)                                                                \
+  M(Async, async)                                                              \
+  M(Collection, collection)                                                    \
+  M(Convert, convert)                                                          \
+  M(Developer, developer)                                                      \
+  M(Internal, _internal)                                                       \
+  M(Isolate, isolate)                                                          \
+  M(Math, math)                                                                \
+  M(Profiler, profiler)                                                        \
+  M(TypedData, typed_data)                                                     \
+  M(VMService, _vmservice)
+
+#ifdef PRODUCT
+#define FOR_EACH_BOOTSTRAP_LIBRARY(M) FOR_EACH_PRODUCT_LIBRARY(M)
+
+#else
+#define FOR_EACH_BOOTSTRAP_LIBRARY(M)                                          \
+  FOR_EACH_PRODUCT_LIBRARY(M)                                                  \
+  M(Mirrors, mirrors)
+
+#endif
+
 // The object store is a per isolate instance which stores references to
 // objects used by the VM.
 // TODO(iposva): Move the actual store into the object heap for quick handling
 // by snapshots eventually.
 class ObjectStore {
  public:
   enum BootstrapLibraryId {
-    kNone = 0,
-    kAsync,
-    kCore,
-    kCollection,
-    kConvert,
-    kDeveloper,
-    kInternal,
-    kIsolate,
-    kMath,
-    kMirrors,
-    kProfiler,
-    kTypedData,
-    kVMService,
+#define MAKE_ID(Name, _) k##Name,
+
+    FOR_EACH_BOOTSTRAP_LIBRARY(MAKE_ID)
+#undef MAKE_ID
   };
 
   ~ObjectStore();
 
   RawClass* object_class() const {
     ASSERT(object_class_ != Object::null());
     return object_class_;
   }
   void set_object_class(const Class& value) { object_class_ = value.raw(); }
   static intptr_t object_class_offset() {
@@ skipping 223 matching lines @@
     canonical_types_ = value.raw();
   }
 
   RawArray* canonical_type_arguments() const {
     return canonical_type_arguments_;
   }
   void set_canonical_type_arguments(const Array& value) {
     canonical_type_arguments_ = value.raw();
   }
 
-  RawLibrary* async_library() const { return async_library_; }
-  RawLibrary* builtin_library() const { return builtin_library_; }
-  RawLibrary* core_library() const { return core_library_; }
-  RawLibrary* collection_library() const { return collection_library_; }
-  RawLibrary* convert_library() const { return convert_library_; }
-  RawLibrary* developer_library() const { return developer_library_; }
-  RawLibrary* internal_library() const { return internal_library_; }
-  RawLibrary* isolate_library() const { return isolate_library_; }
-  RawLibrary* math_library() const { return math_library_; }
-  RawLibrary* mirrors_library() const { return mirrors_library_; }
-  RawLibrary* profiler_library() const { return profiler_library_; }
-  RawLibrary* typed_data_library() const { return typed_data_library_; }
-  RawLibrary* vmservice_library() const { return vmservice_library_; }
+#define MAKE_GETTER(_, name)                                                   \
+  RawLibrary* name##_library() const { return name##_library_; }
+
+  FOR_EACH_BOOTSTRAP_LIBRARY(MAKE_GETTER)
+#undef MAKE_GETTER
+
+  RawLibrary* bootstrap_library(BootstrapLibraryId index) {
+    switch (index) {
+#define MAKE_CASE(CamelName, hacker_name)                                      \
+      case k##CamelName:                                                       \
+          return hacker_name##_library_;
+
+      FOR_EACH_BOOTSTRAP_LIBRARY(MAKE_CASE)
+#undef MAKE_CASE
+
+      default:
+        UNREACHABLE();
+        return Library::null();
+    }
+  }
 
   void set_bootstrap_library(BootstrapLibraryId index, const Library& value) {
     switch (index) {
-      case kAsync:
-        async_library_ = value.raw();
-        break;
-      case kCore:
-        core_library_ = value.raw();
-        break;
-      case kCollection:
-        collection_library_ = value.raw();
-        break;
-      case kConvert:
-        convert_library_ = value.raw();
-        break;
-      case kDeveloper:
-        developer_library_ = value.raw();
-        break;
-      case kInternal:
-        internal_library_ = value.raw();
-        break;
-      case kIsolate:
-        isolate_library_ = value.raw();
-        break;
-      case kMath:
-        math_library_ = value.raw();
-        break;
-      case kMirrors:
-        mirrors_library_ = value.raw();
-        break;
-      case kProfiler:
-        profiler_library_ = value.raw();
-        break;
-      case kTypedData:
-        typed_data_library_ = value.raw();
-        break;
-      case kVMService:
-        vmservice_library_ = value.raw();
-        break;
+#define MAKE_CASE(CamelName, hacker_name)                                      \
+      case k##CamelName:                                                       \
+          hacker_name##_library_ = value.raw();                                \
+          break;
+
+      FOR_EACH_BOOTSTRAP_LIBRARY(MAKE_CASE)
+#undef MAKE_CASE
       default:
         UNREACHABLE();
     }
   }
 
   void set_builtin_library(const Library& value) {
     builtin_library_ = value.raw();
   }
 
   RawLibrary* native_wrappers_library() const {
@@ skipping 229 matching lines @@
   V(RawClass*, weak_property_class_)                                           \
   V(RawArray*, symbol_table_)                                                  \
   V(RawArray*, canonical_types_)                                               \
   V(RawArray*, canonical_type_arguments_)                                      \
   V(RawLibrary*, async_library_)                                               \
   V(RawLibrary*, builtin_library_)                                             \
   V(RawLibrary*, core_library_)                                                \
   V(RawLibrary*, collection_library_)                                          \
   V(RawLibrary*, convert_library_)                                             \
   V(RawLibrary*, developer_library_)                                           \
-  V(RawLibrary*, internal_library_)                                            \
+  V(RawLibrary*, _internal_library_)                                           \
   V(RawLibrary*, isolate_library_)                                             \
   V(RawLibrary*, math_library_)                                                \
   V(RawLibrary*, mirrors_library_)                                             \
   V(RawLibrary*, native_wrappers_library_)                                     \
   V(RawLibrary*, profiler_library_)                                            \
   V(RawLibrary*, root_library_)                                                \
   V(RawLibrary*, typed_data_library_)                                          \
-  V(RawLibrary*, vmservice_library_)                                           \
+  V(RawLibrary*, _vmservice_library_)                                          \
   V(RawGrowableObjectArray*, libraries_)                                       \
   V(RawArray*, libraries_map_)                                                 \
   V(RawGrowableObjectArray*, closure_functions_)                               \
   V(RawGrowableObjectArray*, pending_classes_)                                 \
   V(RawGrowableObjectArray*, pending_deferred_loads_)                          \
   V(RawGrowableObjectArray*, resume_capabilities_)                             \
   V(RawGrowableObjectArray*, exit_listeners_)                                  \
   V(RawGrowableObjectArray*, error_listeners_)                                 \
   V(RawContext*, empty_context_)                                               \
   V(RawInstance*, stack_overflow_)                                             \
@@ skipping 42 matching lines @@
 
   friend class Serializer;
   friend class Deserializer;
 
   DISALLOW_COPY_AND_ASSIGN(ObjectStore);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_OBJECT_STORE_H_