Revert "Introduce FeedbackNexus for vector-based ics."

src/type-feedback-vector.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_TYPE_FEEDBACK_VECTOR_H_
 #define V8_TYPE_FEEDBACK_VECTOR_H_
 
 #include "src/checks.h"
 #include "src/elements-kind.h"
 #include "src/heap/heap.h"
@@ skipping 155 matching lines @@
   };
 
   static const int kVectorICKindBits = 2;
   static VectorICKind FromCodeKind(Code::Kind kind);
   static Code::Kind FromVectorICKind(VectorICKind kind);
   typedef BitSetComputer<VectorICKind, kVectorICKindBits, kSmiValueSize,
                          uint32_t> VectorICComputer;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(TypeFeedbackVector);
 };
-
-
-// A FeedbackNexus is the combination of a TypeFeedbackVector and a slot.
-// Derived classes customize the update and retrieval of feedback.
-class FeedbackNexus {
- public:
-  FeedbackNexus(Handle<TypeFeedbackVector> vector, FeedbackVectorICSlot slot)
-      : vector_handle_(vector), use_handle_(true), slot_(slot) {}
-  FeedbackNexus(TypeFeedbackVector* vector, FeedbackVectorICSlot slot)
-      : vector_(vector), use_handle_(false), slot_(slot) {}
-  virtual ~FeedbackNexus() {}
-
-  Handle<TypeFeedbackVector> vector_handle() const {
-    DCHECK(use_handle_);
-    return vector_handle_;
-  }
-  TypeFeedbackVector* vector() const {
-    return use_handle_ ? *vector_handle_ : vector_;
-  }
-  FeedbackVectorICSlot slot() const { return slot_; }
-
-  InlineCacheState ic_state() const { return StateFromFeedback(); }
-  Map* FindFirstMap() const {
-    MapHandleList maps;
-    ExtractMaps(&maps);
-    if (maps.length() > 0) return *maps.at(0);
-    return NULL;
-  }
-
-  virtual InlineCacheState StateFromFeedback() const = 0;
-  virtual int ExtractMaps(MapHandleList* maps) const = 0;
-  virtual MaybeHandle<Code> FindHandlerForMap(Handle<Map> map) const = 0;
-  virtual bool FindHandlers(CodeHandleList* code_list, int length = -1) const {
-    return length == 0;
-  }
-  virtual Name* FindFirstName() const { return NULL; }
-
-  Object* GetFeedback() const { return vector()->Get(slot()); }
-
- protected:
-  Isolate* GetIsolate() const { return vector()->GetIsolate(); }
-
-  void SetFeedback(Object* feedback,
-                   WriteBarrierMode mode = UPDATE_WRITE_BARRIER) {
-    vector()->Set(slot(), feedback, mode);
-  }
-
-  Handle<FixedArray> EnsureArrayOfSize(int length);
-  void InstallHandlers(int start_index, TypeHandleList* types,
-                       CodeHandleList* handlers);
-  int ExtractMaps(int start_index, MapHandleList* maps) const;
-  MaybeHandle<Code> FindHandlerForMap(int start_index, Handle<Map> map) const;
-  bool FindHandlers(int start_index, CodeHandleList* code_list,
-                    int length) const;
-
- private:
-  // The reason for the union is that we can use handles during IC miss,
-  // but not during GC when we clear ICs. If you have a handle to the
-  // vector that is better because more operations can be done, like
-  // allocation.
-  union {
-    Handle<TypeFeedbackVector> vector_handle_;
-    TypeFeedbackVector* vector_;
-  };
-  bool use_handle_;
-  FeedbackVectorICSlot slot_;
-};
-
-
-class CallICNexus : public FeedbackNexus {
- public:
-  CallICNexus(Handle<TypeFeedbackVector> vector, FeedbackVectorICSlot slot)
-      : FeedbackNexus(vector, slot) {
-    DCHECK(vector->GetKind(slot) == Code::CALL_IC);
-  }
-  CallICNexus(TypeFeedbackVector* vector, FeedbackVectorICSlot slot)
-      : FeedbackNexus(vector, slot) {
-    DCHECK(vector->GetKind(slot) == Code::CALL_IC);
-  }
-
-  void ConfigureUninitialized();
-  void ConfigureGeneric();
-  void ConfigureMonomorphicArray();
-  void ConfigureMonomorphic(Handle<JSFunction> function);
-
-  virtual InlineCacheState StateFromFeedback() const OVERRIDE;
-
-  virtual int ExtractMaps(MapHandleList* maps) const OVERRIDE {
-    // CallICs don't record map feedback.
-    return 0;
-  }
-  virtual MaybeHandle<Code> FindHandlerForMap(Handle<Map> map) const OVERRIDE {
-    return MaybeHandle<Code>();
-  }
-  virtual bool FindHandlers(CodeHandleList* code_list,
-                            int length = -1) const OVERRIDE {
-    return length == 0;
-  }
-};
 }
 }  // namespace v8::internal
 
 #endif  // V8_TRANSITIONS_H_