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()) {

[aam, 2017/08/18 16:04:20]

Can this section be moved up to line 560?
IOTW, is the only way for `result.IsError()` to be true here when
`Dart_IsError(retval)` was true up at line 557?

[siva, 2017/08/18 17:17:51]

The reason it is outside is because we need to run come out of the
TransitionVMToNative scope so we are back in the VM mode from Native mode before
we start processing some of the errors and rollback stuff that has been done so
far.

+      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_) {

[aam, 2017/08/18 16:04:20]

Do we want to return when reload_finalized_ == true only if
isolate()->use_dart_frontend() ?

[siva, 2017/08/18 17:17:51]

It was asserting that reload_finalized_ should be false, so I felt it is ok to
just return if FinalizeLoading is being called multiple times even in the non
use_dart_frontend mode.

     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