Precompilation: Eagerly bind all the static calls after compiling and drop the static call table.

runtime/vm/precompiler.cc

 // Copyright (c) 2015, 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/precompiler.h"
 
+#include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/resolver.h"
 #include "vm/symbols.h"
 
 namespace dart {
@@ skipping 304 matching lines @@
   }
 }
 
 
 void Precompiler::CleanUp() {
   I->set_collected_closures(GrowableObjectArray::Handle(Z));
 
   DropUncompiledFunctions();
 
   // TODO(rmacnak): DropEmptyClasses();
+
+  BindStaticCalls();
 }
 
 
 void Precompiler::ProcessFunction(const Function& function) {
   if (!function.HasCode()) {
     function_count_++;
 
     if (FLAG_trace_precompiler) {
       THR_Print("Precompiling %" Pd " %s (%" Pd ", %s)\n",
                 function_count_,
@@ skipping 343 matching lines @@
       if (!closures.IsNull()) {
         for (intptr_t j = 0; j < closures.Length(); j++) {
           function ^= closures.At(j);
           ASSERT(function.HasCode());
         }
       }
     }
   }
 }
 
+
+void Precompiler::BindStaticCalls() {
+  Library& lib = Library::Handle(Z);
+  Class& cls = Class::Handle(Z);
+  Array& functions = Array::Handle(Z);
+  Function& function = Function::Handle(Z);
+  GrowableObjectArray& retained_functions = GrowableObjectArray::Handle(Z);
+  GrowableObjectArray& closures = GrowableObjectArray::Handle(Z);
+
+  for (intptr_t i = 0; i < libraries_.Length(); i++) {
+    lib ^= libraries_.At(i);
+    ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
+    while (it.HasNext()) {
+      cls = it.GetNextClass();
+      if (cls.IsDynamicClass()) {
+        continue;  // class 'dynamic' is in the read-only VM isolate.
+      }
+
+      functions = cls.functions();
+      retained_functions = GrowableObjectArray::New();

[Ivan Posva, 2015/10/03 00:07:31]

What purpose does this allocation serve?

[rmacnak, 2015/10/05 17:54:03]

From copied iteration code. Removed.

+      for (intptr_t j = 0; j < functions.Length(); j++) {
+        function ^= functions.At(j);
+        BindStaticCalls(function);
+      }
+
+      closures = cls.closures();
+      if (!closures.IsNull()) {
+        for (intptr_t j = 0; j < closures.Length(); j++) {
+          function ^= closures.At(j);
+          BindStaticCalls(function);
+        }
+      }
+    }
+  }
+}
+
+
+void Precompiler::BindStaticCalls(const Function& function) {
+  ASSERT(function.HasCode());
+
+  const Code& code = Code::Handle(Z, function.CurrentCode());
+
+  const Array& table = Array::Handle(Z, code.static_calls_target_table());
+  Smi& pc_offset = Smi::Handle(Z);
+  Function& target = Function::Handle(Z);
+  Code& target_code = Code::Handle(Z);
+
+  for (intptr_t i = 0; i < table.Length(); i += Code::kSCallTableEntryLength) {
+    pc_offset ^= table.At(i + Code::kSCallTableOffsetEntry);
+    target ^= table.At(i + Code::kSCallTableFunctionEntry);
+    if (target.IsNull()) {
+      target_code ^= table.At(i + Code::kSCallTableCodeEntry);
+      ASSERT(!target_code.IsNull());
+      ASSERT(!target_code.IsFunctionCode());
+      // Allocation stub or AllocateContext or AllocateArray or ...
+    } else {
+      ASSERT(target.HasCode());
+      target_code ^= target.CurrentCode();
+      CodePatcher::PatchStaticCallAt(pc_offset.Value() + code.EntryPoint(),

[Ivan Posva, 2015/10/03 00:07:31]

Can you please explain why only patching of the function based calls is needed
and not for the stubs above?

[rmacnak, 2015/10/05 17:54:03]

Allocation stubs are generated eagerly, so their uses already point to the right
Code. Static calls might refer to function that haven't been compiled yet, so
they point to a stub that will ensure compilation then patch up the reference to
the right Code.

[Ivan Posva, 2015/10/05 18:30:06]

Put differently: You are using the stub as a handle until compilation is
finished, correct? Can you please add a comment to that effect? Thanks!

+                                     code, target_code);
+    }
+  }
+  code.set_static_calls_target_table(Object::empty_array());
+}
+
 }  // namespace dart