1. Figure out the modified libraries from the specifeid kernel file during

runtime/vm/isolate_reload.cc

 // Copyright (c) 2016, 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/isolate_reload.h"
 
 #include "vm/become.h"
 #include "vm/bit_vector.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/hash_table.h"
 #include "vm/isolate.h"
+#include "vm/kernel_reader.h"
 #include "vm/log.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/runtime_entry.h"
 #include "vm/safepoint.h"
 #include "vm/service_event.h"
 #include "vm/stack_frame.h"
 #include "vm/thread.h"
 #include "vm/timeline.h"
@@ skipping 455 matching lines @@
 
  private:
   const Error& error_;
 
   RawError* ToError() { return error_.raw(); }
   RawString* ToString() {
     return String::NewFormatted("%s", error_.ToErrorCString());
   }
 };
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 static intptr_t CommonSuffixLength(const char* a, const char* b) {
   const intptr_t a_length = strlen(a);
   const intptr_t b_length = strlen(b);
   intptr_t a_cursor = a_length;
   intptr_t b_cursor = b_length;
 
   while ((a_cursor >= 0) && (b_cursor >= 0)) {
     if (a[a_cursor] != b[b_cursor]) {
       break;
     }
@@ skipping 28 matching lines @@
     const char* root_library_url_c = root_lib_url.ToCString();
     const intptr_t common_suffix_length =
         CommonSuffixLength(root_library_url_c, old_root_library_url_c);
     root_url_prefix_ = String::SubString(
         root_lib_url, 0, root_lib_url.Length() - common_suffix_length + 1);
     old_root_url_prefix_ =
         String::SubString(old_root_lib_url, 0,
                           old_root_lib_url.Length() - common_suffix_length + 1);
   }
 
-  // Check to see which libraries have been modified.
-  modified_libs_ = FindModifiedLibraries(force_reload);
+  Object& result = Object::Handle(thread->zone());
+  kernel::Program* kernel_program = NULL;
+  String& packages_url = String::Handle();
+  if (packages_url_ != NULL) {
+    packages_url = String::New(packages_url_);
+  }
+  if (isolate()->use_dart_frontend()) {
+    // Load the kernel program and figure out the modified libraries.
+    const GrowableObjectArray& libs =
+        GrowableObjectArray::Handle(object_store()->libraries());
+    intptr_t num_libs = libs.Length();
+    modified_libs_ = new (Z) BitVector(Z, num_libs);
+    TIR_Print("---- ENTERING TAG HANDLER\n");
+    {
+      TransitionVMToNative transition(thread);
+      Api::Scope api_scope(thread);
+      Dart_Handle retval = (I->library_tag_handler())(
+          Dart_kKernelTag, Api::NewHandle(thread, packages_url.raw()),
+          Api::NewHandle(thread, root_lib_url.raw()));
+      if (Dart_IsError(retval)) {
+        // Compilation of the new sources failed, abort reload and report
+        // error.
+        result = Api::UnwrapHandle(retval);
+      } else {
+        uint64_t data;
+        intptr_t data_len = 0;
+        Dart_TypedData_Type data_type;
+        ASSERT(Dart_IsTypedData(retval));
+        Dart_Handle val = Dart_TypedDataAcquireData(
+            retval, &data_type, reinterpret_cast<void**>(&data), &data_len);
+        ASSERT(!Dart_IsError(val));
+        ASSERT(data_type == Dart_TypedData_kUint64);
+        ASSERT(data_len == 1);
+        kernel_program = reinterpret_cast<kernel::Program*>(data);
+        Dart_TypedDataReleaseData(retval);
+        kernel::KernelReader reader(kernel_program);
+        reader.FindModifiedLibraries(I, modified_libs_, force_reload);
+      }
+    }
+    if (result.IsError()) {
+      TIR_Print("---- LOAD FAILED, ABORTING RELOAD\n");
+      AddReasonForCancelling(new Aborted(zone_, ApiError::Cast(result)));
+      ReportReasonsForCancelling();
+      CommonFinalizeTail();
+      return;
+    }
+    TIR_Print("---- EXITED TAG HANDLER\n");
+  } else {
+    // Check to see which libraries have been modified.
+    modified_libs_ = FindModifiedLibraries(force_reload);
+  }
   if (!modified_libs_->Contains(old_root_lib.index())) {
     ASSERT(modified_libs_->IsEmpty());
     reload_skipped_ = true;
     ReportOnJSON(js_);
     TIR_Print("---- SKIPPING RELOAD (No libraries were modified)\n");
     return;
   }
 
   TIR_Print("---- STARTING RELOAD\n");
 
@@ skipping 34 matching lines @@
   //      and we are temporarily back in control.
   //      This is where we validate the reload and commit or reject.
   //   5) Dart_FinalizeLoading invokes Dart code related to deferred libraries.
   //   6) The tag handler returns and we move on.
   //
   // Even after a successful reload the Dart code invoked in (5) can result
   // in an Unwind error or an UnhandledException error. This error will be
   // returned by the tag handler. The tag handler can return other errors,
   // for example, top level parse errors. We want to capture these errors while
   // propagating the UnwindError or an UnhandledException error.
-  Object& result = Object::Handle(thread->zone());
 
-  String& packages_url = String::Handle();
-  if (packages_url_ != NULL) {
-    packages_url = String::New(packages_url_);
-  }
-
-  TIR_Print("---- ENTERING TAG HANDLER\n");
-  {
+  if (isolate()->use_dart_frontend()) {
+    // Read the kernel program.
+    kernel::KernelReader reader(kernel_program);
+    const Object& tmp = reader.ReadProgram();
+    if (!tmp.IsError()) {
+      Library& lib = Library::Handle(thread->zone());
+      lib ^= tmp.raw();
+      isolate()->object_store()->set_root_library(lib);
+      FinalizeLoading();
+      result = Object::null();
+    } else {
+      result = tmp.raw();
+    }
+  } else {
+    TIR_Print("---- ENTERING TAG HANDLER\n");
     TransitionVMToNative transition(thread);
     Api::Scope api_scope(thread);
 
     Dart_Handle retval = (I->library_tag_handler())(
         Dart_kScriptTag, Api::NewHandle(thread, packages_url.raw()),
         Api::NewHandle(thread, root_lib_url.raw()));
     result = Api::UnwrapHandle(retval);
+    TIR_Print("---- EXITED TAG HANDLER\n");
   }
   //
   // WEIRD CONTROL FLOW ENDS.
-  TIR_Print("---- EXITED TAG HANDLER\n");
 
   // Re-enable the background compiler. Do this before propagating any errors.
   BackgroundCompiler::Enable();
 
   if (result.IsUnwindError()) {
     if (thread->top_exit_frame_info() == 0) {
       // We can only propagate errors when there are Dart frames on the stack.
       // In this case there are no Dart frames on the stack and we set the
       // thread's sticky error. This error will be returned to the message
       // handler.
       thread->set_sticky_error(Error::Cast(result));
     } else {
       // If the tag handler returns with an UnwindError error, propagate it and
       // give up.
       Exceptions::PropagateError(Error::Cast(result));
       UNREACHABLE();
     }
   }
 
   // Other errors (e.g. a parse error) are captured by the reload system.
   if (result.IsError()) {
     FinalizeFailedLoad(Error::Cast(result));
   }
 }
+#else
+// NOTE: This function returns *after* FinalizeLoading is called.
+void IsolateReloadContext::Reload(bool force_reload,
+                                  const char* root_script_url,
+                                  const char* packages_url_) {}
+#endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
 void IsolateReloadContext::RegisterClass(const Class& new_cls) {
   const Class& old_cls = Class::Handle(OldClassOrNull(new_cls));
   if (old_cls.IsNull()) {
     I->class_table()->Register(new_cls);
 
     if (FLAG_identity_reload) {
       TIR_Print("Could not find replacement class for %s\n",
                 new_cls.ToCString());
       UNREACHABLE();
@@ skipping 10 matching lines @@
     new_cls.CopyCanonicalConstants(old_cls);
   }
   new_cls.CopyCanonicalType(old_cls);
   AddBecomeMapping(old_cls, new_cls);
   AddClassMapping(new_cls, old_cls);
 }
 
 // FinalizeLoading will be called *before* Reload() returns but will not be
 // called if the embedder fails to load sources.
 void IsolateReloadContext::FinalizeLoading() {
-  if (reload_skipped_) {
+  if (reload_skipped_ || reload_finalized_) {
     return;
   }
-  ASSERT(!reload_finalized_);
   BuildLibraryMapping();
   TIR_Print("---- LOAD SUCCEEDED\n");
   if (ValidateReload()) {
     Commit();
     PostCommit();
     isolate()->set_last_reload_timestamp(reload_timestamp_);
   } else {
     ReportReasonsForCancelling();
     Rollback();
   }
@@ skipping 1145 matching lines @@
         ASSERT(!super_cls.IsNull());
         super_cls.AddDirectSubclass(cls);
       }
     }
   }
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart