Revert "Save and restore feedback from JIT."

runtime/vm/dart_api_impl.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 "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "lib/stacktrace.h"
@@ skipping 18 matching lines @@
 #include "vm/message.h"
 #include "vm/message_handler.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os_thread.h"
 #include "vm/os.h"
 #include "vm/port.h"
 #include "vm/precompiler.h"
 #include "vm/profiler.h"
-#include "vm/program_visitor.h"
 #include "vm/resolver.h"
 #include "vm/reusable_handles.h"
 #include "vm/service_event.h"
 #include "vm/service_isolate.h"
 #include "vm/service.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 #include "vm/tags.h"
 #include "vm/thread_registry.h"
 #include "vm/timeline.h"
@@ skipping 56 matching lines @@
   } while (false)
 #define API_TIMELINE_BEGIN_END                                                 \
   do {                                                                         \
   } while (false)
 #endif  // !PRODUCT
 
 #if defined(DEBUG)
 // An object visitor which will iterate over all the function objects in the
 // heap and check if the result type and parameter types are canonicalized
 // or not. An assertion is raised if a type is not canonicalized.
-class CheckFunctionTypesVisitor : public ObjectVisitor {
+class FunctionVisitor : public ObjectVisitor {
  public:
-  explicit CheckFunctionTypesVisitor(Thread* thread)
+  explicit FunctionVisitor(Thread* thread)
       : classHandle_(Class::Handle(thread->zone())),
         funcHandle_(Function::Handle(thread->zone())),
         typeHandle_(AbstractType::Handle(thread->zone())) {}
 
   void VisitObject(RawObject* obj) {
     if (obj->IsFunction()) {
       funcHandle_ ^= obj;
       classHandle_ ^= funcHandle_.Owner();
       // Verify that the result type of a function is canonical or a
       // TypeParameter.
@@ skipping 1437 matching lines @@
   }
   // Finalize all classes if needed.
   Dart_Handle state = Api::CheckAndFinalizePendingClasses(T);
   if (::Dart_IsError(state)) {
     return state;
   }
   I->StopBackgroundCompiler();
 
 #if defined(DEBUG)
   I->heap()->CollectAllGarbage();
-  CheckFunctionTypesVisitor check_canonical(T);
+  FunctionVisitor check_canonical(T);
   I->heap()->IterateObjects(&check_canonical);
 #endif  // #if defined(DEBUG)
 
   FullSnapshotWriter writer(Snapshot::kCore, vm_isolate_snapshot_buffer,
                             isolate_snapshot_buffer, ApiReallocate,
                             NULL /* instructions_writer */);
   writer.WriteFullSnapshot();
   *vm_isolate_snapshot_size = writer.VmIsolateSnapshotSize();
   *isolate_snapshot_size = writer.IsolateSnapshotSize();
   return Api::Success();
@@ skipping 18 matching lines @@
   }
   Library& lib = Library::Handle(Z);
   if (library == Dart_Null()) {
     lib ^= I->object_store()->root_library();
   } else {
     lib ^= Api::UnwrapHandle(library);
   }
 
 #if defined(DEBUG)
   I->heap()->CollectAllGarbage();
-  CheckFunctionTypesVisitor check_canonical(T);
+  FunctionVisitor check_canonical(T);
   I->heap()->IterateObjects(&check_canonical);
 #endif  // #if defined(DEBUG)
 
   ScriptSnapshotWriter writer(buffer, ApiReallocate);
   writer.WriteScriptSnapshot(lib);
   *size = writer.BytesWritten();
   return Api::Success();
 }
 
 
@@ skipping 4794 matching lines @@
 DART_EXPORT void Dart_SetThreadName(const char* name) {
   OSThread* thread = OSThread::Current();
   if (thread == NULL) {
     // VM is shutting down.
     return;
   }
   thread->SetName(name);
 }
 
 
-DART_EXPORT
-Dart_Handle Dart_SaveJITFeedback(uint8_t** buffer, intptr_t* buffer_length) {
-#if defined(DART_PRECOMPILED_RUNTIME)
-  return Api::NewError("No JIT feedback to save on an AOT runtime.");
-#elif defined(PRODUCT)
-  // TOOD(rmacnak): We'd need to include the JSON printing code again.
-  return Api::NewError("Dart_SaveJITFeedback not supported in PRODUCT mode.");
-#else
-  Thread* thread = Thread::Current();
-  DARTSCOPE(thread);
-  Isolate* isolate = thread->isolate();
-  Zone* zone = thread->zone();
+// The precompiler is included in dart_bootstrap and dart_noopt, and
+// excluded from dart and dart_precompiled_runtime.
+#if !defined(DART_PRECOMPILER)
 
-  if (buffer == NULL) {
-    RETURN_NULL_ERROR(buffer);
-  }
-  if (buffer_length == NULL) {
-    RETURN_NULL_ERROR(buffer_length);
-  }
-
-  JSONStream js_stream;
-  {
-    JSONObject js_profile(&js_stream);
-    js_profile.AddProperty("vmVersion", Version::CommitString());
-    js_profile.AddProperty("asserts", FLAG_enable_asserts);
-    js_profile.AddProperty("typeChecks", FLAG_enable_type_checks);
-
-    {
-      JSONArray js_scripts(&js_profile, "scripts");
-
-      const GrowableObjectArray& libraries = GrowableObjectArray::Handle(
-          zone, isolate->object_store()->libraries());
-      Library& library = Library::Handle(zone);
-      Array& scripts = Array::Handle(zone);
-      Script& script = Script::Handle(zone);
-      String& uri = String::Handle(zone);
-      for (intptr_t i = 0; i < libraries.Length(); i++) {
-        library ^= libraries.At(i);
-        scripts = library.LoadedScripts();
-        for (intptr_t j = 0; j < scripts.Length(); j++) {
-          script ^= scripts.At(j);
-          JSONObject js_script(&js_scripts);
-          uri = script.url();
-          js_script.AddProperty("uri", uri.ToCString());
-          int64_t fp = script.SourceFingerprint();
-          js_script.AddProperty64("checksum", fp);
-        }
-      }
-    }
-
-    {
-      JSONArray js_classes(&js_profile, "classes");
-
-      ClassTable* classes = isolate->class_table();
-      Class& cls = Class::Handle(zone);
-      Library& library = Library::Handle(zone);
-      String& uri = String::Handle(zone);
-      String& name = String::Handle(zone);
-      for (intptr_t cid = kNumPredefinedCids; cid < classes->NumCids(); cid++) {
-        if (!classes->HasValidClassAt(cid)) continue;
-        cls ^= classes->At(cid);
-        library = cls.library();
-        JSONObject js_class(&js_classes);
-        js_class.AddProperty("cid", cid);
-        uri = library.url();
-        js_class.AddProperty("uri", uri.ToCString());
-        name = cls.Name();
-        name = String::RemovePrivateKey(name);
-        js_class.AddProperty("name", name.ToCString());
-      }
-    }
-
-    {
-      JSONArray js_functions(&js_profile, "functions");
-
-      class JITFeedbackFunctionVisitor : public FunctionVisitor {
-       public:
-        JITFeedbackFunctionVisitor(JSONArray* js_functions, Zone* zone)
-            : js_functions_(js_functions),
-              function_(Function::Handle(zone)),
-              owner_(Class::Handle(zone)),
-              name_(String::Handle(zone)),
-              ic_datas_(Array::Handle(zone)),
-              ic_data_(ICData::Handle(zone)),
-              entry_(Object::Handle(zone)) {}
-
-        void Visit(const Function& function) {
-          if (function.usage_counter() == 0) return;
-
-          JSONObject js_function(js_functions_);
-          name_ = function.name();
-          name_ = String::RemovePrivateKey(name_);
-          js_function.AddProperty("name", name_.ToCString());
-          owner_ ^= function.Owner();
-          js_function.AddProperty("class", owner_.id());
-          js_function.AddProperty("tokenPos", function.token_pos().value());
-          js_function.AddProperty("kind",
-                                  static_cast<intptr_t>(function.kind()));
-          intptr_t usage = function.usage_counter();
-          if (usage < 0) {
-            // Function was in the background compiler's queue.
-            usage = FLAG_optimization_counter_threshold;
-          }
-          js_function.AddProperty("usageCounter", usage);
-
-          ic_datas_ = function.ic_data_array();
-          JSONArray js_icdatas(&js_function, "ics");
-          if (ic_datas_.IsNull()) return;
-
-          for (intptr_t j = 0; j < ic_datas_.Length(); j++) {
-            entry_ = ic_datas_.At(j);
-            if (!entry_.IsICData()) continue;  // Skip edge counters.
-            ic_data_ ^= entry_.raw();
-
-            JSONObject js_icdata(&js_icdatas);
-            js_icdata.AddProperty("deoptId", ic_data_.deopt_id());
-            name_ = ic_data_.target_name();
-            name_ = String::RemovePrivateKey(name_);
-            js_icdata.AddProperty("selector", name_.ToCString());
-            js_icdata.AddProperty("isStaticCall", ic_data_.is_static_call());
-            intptr_t num_args_checked = ic_data_.NumArgsTested();
-            js_icdata.AddProperty("argsTested", num_args_checked);
-            JSONArray js_entries(&js_icdata, "entries");
-            for (intptr_t check = 0; check < ic_data_.NumberOfChecks();
-                 check++) {
-              GrowableArray<intptr_t> class_ids(num_args_checked);
-              ic_data_.GetClassIdsAt(check, &class_ids);
-              for (intptr_t k = 0; k < num_args_checked; k++) {
-                ASSERT(class_ids[k] != kIllegalCid);
-                js_entries.AddValue(class_ids[k]);
-              }
-              js_entries.AddValue(ic_data_.GetCountAt(check));
-            }
-          }
-        }
-
-       private:
-        JSONArray* js_functions_;
-        Function& function_;
-        Class& owner_;
-        String& name_;
-        Array& ic_datas_;
-        ICData& ic_data_;
-        Object& entry_;
-      };
-
-      JITFeedbackFunctionVisitor visitor(&js_functions, zone);
-      ProgramVisitor::VisitFunctions(&visitor);
-    }
-  }
-
-  js_stream.Steal(reinterpret_cast<char**>(buffer), buffer_length);
-  return Api::Success();
-#endif
+DART_EXPORT Dart_Handle
+Dart_Precompile(Dart_QualifiedFunctionName entry_points[], bool reset_fields) {
+  return Api::NewError(
+      "This VM was built without support for AOT compilation.");
 }
 
 
 DART_EXPORT Dart_Handle
-Dart_Precompile(Dart_QualifiedFunctionName entry_points[],
-                bool reset_fields,
-                uint8_t* jit_feedback,
-                intptr_t jit_feedback_length) {
-#if defined(TARGET_ARCH_IA32)
-  return Api::NewError("AOT compilation is not supported on IA32.");
-#elif defined(TARGET_ARCH_DBC)
-  return Api::NewError("AOT compilation is not supported on DBC.");
-#elif !defined(DART_PRECOMPILER)
+Dart_CreatePrecompiledSnapshotAssembly(uint8_t** assembly_buffer,
+                                       intptr_t* assembly_size) {
   return Api::NewError(
       "This VM was built without support for AOT compilation.");
+  return 0;
+}
+
+
+DART_EXPORT Dart_Handle
+Dart_CreatePrecompiledSnapshotBlob(uint8_t** vm_isolate_snapshot_buffer,
+                                   intptr_t* vm_isolate_snapshot_size,
+                                   uint8_t** isolate_snapshot_buffer,
+                                   intptr_t* isolate_snapshot_size,
+                                   uint8_t** instructions_blob_buffer,
+                                   intptr_t* instructions_blob_size,
+                                   uint8_t** rodata_blob_buffer,
+                                   intptr_t* rodata_blob_size) {
+  return Api::NewError(
+      "This VM was built without support for AOT compilation.");
+}
+
+#else  // DART_PRECOMPILER
+
+DART_EXPORT Dart_Handle
+Dart_Precompile(Dart_QualifiedFunctionName entry_points[], bool reset_fields) {
+#if defined(TARGET_ARCH_IA32)
+  return Api::NewError("Precompilation is not supported on IA32.");
+#elif defined(TARGET_ARCH_DBC)
+  return Api::NewError("Precompilation is not supported on DBC.");
 #else
   API_TIMELINE_BEGIN_END;
   DARTSCOPE(Thread::Current());
   if (!FLAG_precompiled_mode) {
     return Api::NewError("Flag --precompilation was not specified.");
   }
   Dart_Handle result = Api::CheckAndFinalizePendingClasses(T);
   if (::Dart_IsError(result)) {
     return result;
   }
   CHECK_CALLBACK_STATE(T);
-  const Error& error = Error::Handle(Precompiler::CompileAll(
-      entry_points, reset_fields, jit_feedback, jit_feedback_length));
+  const Error& error =
+      Error::Handle(Precompiler::CompileAll(entry_points, reset_fields));
   if (!error.IsNull()) {
     return Api::NewHandle(T, error.raw());
   }
   return Api::Success();
 #endif
 }
 
 
 DART_EXPORT Dart_Handle
 Dart_CreatePrecompiledSnapshotAssembly(uint8_t** assembly_buffer,
                                        intptr_t* assembly_size) {
 #if defined(TARGET_ARCH_IA32)
-  return Api::NewError("AOT compilation is not supported on IA32.");
+  return Api::NewError("Precompilation is not supported on IA32.");
 #elif defined(TARGET_ARCH_DBC)
-  return Api::NewError("AOT compilation is not supported on DBC.");
-#elif !defined(DART_PRECOMPILER)
-  return Api::NewError(
-      "This VM was built without support for AOT compilation.");
+  return Api::NewError("Precompilation is not supported on DBC.");
 #else
   API_TIMELINE_DURATION;
   DARTSCOPE(Thread::Current());
   Isolate* I = T->isolate();
   if (I->compilation_allowed()) {
     return Api::NewError(
         "Isolate is not precompiled. "
         "Did you forget to call Dart_Precompile?");
   }
   ASSERT(FLAG_load_deferred_eagerly);
@@ skipping 25 matching lines @@
 DART_EXPORT Dart_Handle
 Dart_CreatePrecompiledSnapshotBlob(uint8_t** vm_isolate_snapshot_buffer,
                                    intptr_t* vm_isolate_snapshot_size,
                                    uint8_t** isolate_snapshot_buffer,
                                    intptr_t* isolate_snapshot_size,
                                    uint8_t** instructions_blob_buffer,
                                    intptr_t* instructions_blob_size,
                                    uint8_t** rodata_blob_buffer,
                                    intptr_t* rodata_blob_size) {
 #if defined(TARGET_ARCH_IA32)
-  return Api::NewError("AOT compilation is not supported on IA32.");
+  return Api::NewError("Precompilation is not supported on IA32.");
 #elif defined(TARGET_ARCH_DBC)
-  return Api::NewError("AOT compilation is not supported on DBC.");
-#elif !defined(DART_PRECOMPILER)
-  return Api::NewError(
-      "This VM was built without support for AOT compilation.");
+  return Api::NewError("Precompilation is not supported on DBC.");
 #else
   API_TIMELINE_DURATION;
   DARTSCOPE(Thread::Current());
   Isolate* I = T->isolate();
   if (I->compilation_allowed()) {
     return Api::NewError(
         "Isolate is not precompiled. "
         "Did you forget to call Dart_Precompile?");
   }
   ASSERT(FLAG_load_deferred_eagerly);
@@ skipping 33 matching lines @@
 
   writer.WriteFullSnapshot();
   *vm_isolate_snapshot_size = writer.VmIsolateSnapshotSize();
   *isolate_snapshot_size = writer.IsolateSnapshotSize();
   *instructions_blob_size = instructions_writer.InstructionsBlobSize();
   *rodata_blob_size = instructions_writer.RodataBlobSize();
 
   return Api::Success();
 #endif
 }
+#endif  // DART_PRECOMPILER
 
 
 DART_EXPORT Dart_Handle Dart_PrecompileJIT() {
   API_TIMELINE_BEGIN_END;
   DARTSCOPE(Thread::Current());
   Isolate* I = T->isolate();
   Dart_Handle result = Api::CheckAndFinalizePendingClasses(T);
   if (::Dart_IsError(result)) {
     return result;
   }
@@ skipping 101 matching lines @@
 }
 
 
 DART_EXPORT void Dart_DumpNativeStackTrace(void* context) {
 #ifndef PRODUCT
   Profiler::DumpStackTrace(context);
 #endif
 }
 
 }  // namespace dart