Revert "Save and restore feedback from JIT."

runtime/vm/precompiler.h

 // 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.
 
 #ifndef RUNTIME_VM_PRECOMPILER_H_
 #define RUNTIME_VM_PRECOMPILER_H_
 
 #include "vm/allocation.h"
 #include "vm/hash_map.h"
 #include "vm/hash_table.h"
 #include "vm/object.h"
 
 namespace dart {
 
 // Forward declarations.
 class Class;
 class Error;
 class Field;
 class Function;
 class GrowableObjectArray;
 class RawError;
 class SequenceNode;
 class String;
-class ParsedJSONObject;
-class ParsedJSONArray;
-class Precompiler;
-class FlowGraph;
 
-class TypeRangeCache : public ValueObject {
+
+class TypeRangeCache : public StackResource {
  public:
-  TypeRangeCache(Precompiler* precompiler, Thread* thread, intptr_t num_cids);
-  ~TypeRangeCache();
+  TypeRangeCache(Thread* thread, intptr_t num_cids)
+      : StackResource(thread),
+        thread_(thread),
+        lower_limits_(thread->zone()->Alloc<intptr_t>(num_cids)),
+        upper_limits_(thread->zone()->Alloc<intptr_t>(num_cids)) {
+    for (intptr_t i = 0; i < num_cids; i++) {
+      lower_limits_[i] = kNotComputed;
+      upper_limits_[i] = kNotComputed;
+    }
+    // We don't re-enter the precompiler.
+    ASSERT(thread->type_range_cache() == NULL);
+    thread->set_type_range_cache(this);
+  }
+
+  ~TypeRangeCache() {
+    ASSERT(thread_->type_range_cache() == this);
+    thread_->set_type_range_cache(NULL);
+  }
 
   bool InstanceOfHasClassRange(const AbstractType& type,
                                intptr_t* lower_limit,
                                intptr_t* upper_limit);
 
  private:
   static const intptr_t kNotComputed = -1;
   static const intptr_t kNotContiguous = -2;
 
-  Precompiler* precompiler_;
   Thread* thread_;
   intptr_t* lower_limits_;
   intptr_t* upper_limits_;
 };
 
 
 class SymbolKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const String* Key;
@@ skipping 256 matching lines @@
 
   void Print() const;
 
   const Field* field_;
   intptr_t cid_;
 };
 
 typedef DirectChainedHashMap<FieldTypePair> FieldTypeMap;
 
 
-struct IntptrPair {
-  // Typedefs needed for the DirectChainedHashMap template.
-  typedef intptr_t Key;
-  typedef intptr_t Value;
-  typedef IntptrPair Pair;
-
-  static Key KeyOf(Pair kv) { return kv.key_; }
-
-  static Value ValueOf(Pair kv) { return kv.value_; }
-
-  static inline intptr_t Hashcode(Key key) { return key; }
-
-  static inline bool IsKeyEqual(Pair pair, Key key) { return pair.key_ == key; }
-
-  IntptrPair(intptr_t key, intptr_t value) : key_(key), value_(value) {}
-
-  IntptrPair() : key_(kIllegalCid), value_(kIllegalCid) {}
-
-  Key key_;
-  Value value_;
-};
-
-typedef DirectChainedHashMap<IntptrPair> CidMap;
-
-
-struct FunctionFeedbackKey {
-  FunctionFeedbackKey() : owner_cid_(kIllegalCid), token_(0), kind_(0) {}
-  FunctionFeedbackKey(intptr_t owner_cid, intptr_t token, intptr_t kind)
-      : owner_cid_(owner_cid), token_(token), kind_(kind) {}
-
-  intptr_t owner_cid_;
-  intptr_t token_;
-  intptr_t kind_;
-};
-
-
-struct FunctionFeedbackPair {
-  // Typedefs needed for the DirectChainedHashMap template.
-  typedef FunctionFeedbackKey Key;
-  typedef ParsedJSONObject* Value;
-  typedef FunctionFeedbackPair Pair;
-
-  static Key KeyOf(Pair kv) { return kv.key_; }
-
-  static Value ValueOf(Pair kv) { return kv.value_; }
-
-  static inline intptr_t Hashcode(Key key) {
-    return key.token_ ^ key.owner_cid_ ^ key.kind_;
-  }
-
-  static inline bool IsKeyEqual(Pair pair, Key key) {
-    return (pair.key_.owner_cid_ == key.owner_cid_) &&
-           (pair.key_.token_ == key.token_) && (pair.key_.kind_ == key.kind_);
-  }
-
-  FunctionFeedbackPair(Key key, Value value) : key_(key), value_(value) {}
-
-  FunctionFeedbackPair() : key_(), value_(NULL) {}
-
-  Key key_;
-  Value value_;
-};
-
-typedef DirectChainedHashMap<FunctionFeedbackPair> FunctionFeedbackMap;
-
-
 class Precompiler : public ValueObject {
  public:
   static RawError* CompileAll(
       Dart_QualifiedFunctionName embedder_entry_points[],
-      bool reset_fields,
-      uint8_t* jit_feedback,
-      intptr_t jit_feedback_length);
+      bool reset_fields);
 
   static RawError* CompileFunction(Precompiler* precompiler,
                                    Thread* thread,
                                    Zone* zone,
                                    const Function& function,
                                    FieldTypeMap* field_type_map = NULL);
 
   static RawObject* EvaluateStaticInitializer(const Field& field);
   static RawObject* ExecuteOnce(SequenceNode* fragment);
 
   static RawFunction* CompileStaticInitializer(const Field& field,
                                                bool compute_type);
 
   // Returns true if get:runtimeType is not overloaded by any class.
   bool get_runtime_type_is_unique() const {
     return get_runtime_type_is_unique_;
   }
 
   FieldTypeMap* field_type_map() { return &field_type_map_; }
-  TypeRangeCache* type_range_cache() { return type_range_cache_; }
-  void set_type_range_cache(TypeRangeCache* value) {
-    type_range_cache_ = value;
-  }
-
-  bool HasFeedback() const { return jit_feedback_ != NULL; }
-  static void PopulateWithICData(const Function& func, FlowGraph* graph);
-  void TryApplyFeedback(const Function& func, FlowGraph* graph);
-  void TryApplyFeedback(ParsedJSONArray* js_icdatas, const ICData& ic);
 
  private:
   Precompiler(Thread* thread, bool reset_fields);
 
-  void LoadFeedback(uint8_t* jit_feedback, intptr_t jit_feedback_length);
-  ParsedJSONObject* LookupFeedback(const Function& function);
-
   void DoCompileAll(Dart_QualifiedFunctionName embedder_entry_points[]);
   void ClearAllCode();
   void AddRoots(Dart_QualifiedFunctionName embedder_entry_points[]);
   void AddEntryPoints(Dart_QualifiedFunctionName entry_points[]);
   void Iterate();
 
   void AddType(const AbstractType& type);
   void AddTypesOf(const Class& cls);
   void AddTypesOf(const Function& function);
   void AddTypeArguments(const TypeArguments& args);
@@ skipping 27 matching lines @@
   void DedupStackMaps();
   void DedupLists();
   void DedupInstructions();
   void ResetPrecompilerState();
 
   void CollectDynamicFunctionNames();
 
   void PrecompileStaticInitializers();
   void PrecompileConstructors();
 
+  template <typename T>
+  class Visitor : public ValueObject {
+   public:
+    virtual ~Visitor() {}
+    virtual void Visit(const T& obj) = 0;
+  };
+  typedef Visitor<Function> FunctionVisitor;
+  typedef Visitor<Class> ClassVisitor;
+
+  void VisitFunctions(FunctionVisitor* visitor);
+  void VisitClasses(ClassVisitor* visitor);
+
   void FinalizeAllClasses();
   void SortClasses();
   void RemapClassIds(intptr_t* old_to_new_cid);
-  void VerifyJITFeedback();
-  RawScript* LookupScript(const char* uri);
-  intptr_t MapCid(intptr_t feedback_cid);
 
   Thread* thread() const { return thread_; }
   Zone* zone() const { return zone_; }
   Isolate* isolate() const { return isolate_; }
 
   Thread* thread_;
   Zone* zone_;
   Isolate* isolate_;
 
   const bool reset_fields_;
 
-  ParsedJSONObject* jit_feedback_;
-
   bool changed_;
   intptr_t function_count_;
   intptr_t class_count_;
   intptr_t selector_count_;
   intptr_t dropped_function_count_;
   intptr_t dropped_field_count_;
   intptr_t dropped_class_count_;
   intptr_t dropped_typearg_count_;
   intptr_t dropped_type_count_;
   intptr_t dropped_library_count_;
 
   GrowableObjectArray& libraries_;
   const GrowableObjectArray& pending_functions_;
   SymbolSet sent_selectors_;
   FunctionSet enqueued_functions_;
   FieldSet fields_to_retain_;
   FunctionSet functions_to_retain_;
   ClassSet classes_to_retain_;
   TypeArgumentsSet typeargs_to_retain_;
   AbstractTypeSet types_to_retain_;
   InstanceSet consts_to_retain_;
   FieldTypeMap field_type_map_;
-  TypeRangeCache* type_range_cache_;
-  CidMap feedback_cid_map_;
-  FunctionFeedbackMap function_feedback_map_;
   Error& error_;
 
   bool get_runtime_type_is_unique_;
 };
 
 
 class FunctionsTraits {
  public:
   static const char* Name() { return "FunctionsTraits"; }
   static bool ReportStats() { return false; }
@@ skipping 17 matching lines @@
   }
   static RawObject* NewKey(const Function& function) { return function.raw(); }
 };
 
 typedef UnorderedHashSet<FunctionsTraits> UniqueFunctionsSet;
 
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_PRECOMPILER_H_