Distinction between FeedbackVectorICSlot and FeedbackVectorSlot eliminated.

src/full-codegen/full-codegen.h

 // Copyright 2012 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_FULL_CODEGEN_FULL_CODEGEN_H_
 #define V8_FULL_CODEGEN_FULL_CODEGEN_H_
 
 #include "src/allocation.h"
 #include "src/assert-scope.h"
 #include "src/ast.h"
@@ skipping 409 matching lines @@
   void PrepareForBailout(Expression* node, State state);
   void PrepareForBailoutForId(BailoutId id, State state);
 
   // Returns a smi for the index into the FixedArray that backs the feedback
   // vector
   Smi* SmiFromSlot(FeedbackVectorSlot slot) const {
     return Smi::FromInt(TypeFeedbackVector::GetIndexFromSpec(
         literal()->feedback_vector_spec(), slot));
   }
 
-  Smi* SmiFromSlot(FeedbackVectorICSlot slot) const {
-    return Smi::FromInt(TypeFeedbackVector::GetIndexFromSpec(
-        literal()->feedback_vector_spec(), slot));
-  }
-
   // Record a call's return site offset, used to rebuild the frame if the
   // called function was inlined at the site.
   void RecordJSReturnSite(Call* call);
 
   // Prepare for bailout before a test (or compare) and branch.  If
   // should_normalize, then the following comparison will not handle the
   // canonical JS true value so we will insert a (dead) test against true at
   // the actual bailout target from the optimized code. If not
   // should_normalize, the true and false labels are ignored.
   void PrepareForBailoutBeforeSplit(Expression* expr,
@@ skipping 146 matching lines @@
   // Helper functions for generating inlined smi code for certain
   // binary operations.
   void EmitInlineSmiBinaryOp(BinaryOperation* expr,
                              Token::Value op,
                              Expression* left,
                              Expression* right);
 
   // Assign to the given expression as if via '='. The right-hand-side value
   // is expected in the accumulator. slot is only used if FLAG_vector_stores
   // is true.
-  void EmitAssignment(Expression* expr, FeedbackVectorICSlot slot);
+  void EmitAssignment(Expression* expr, FeedbackVectorSlot slot);
 
   // Complete a variable assignment.  The right-hand-side value is expected
   // in the accumulator.
   void EmitVariableAssignment(Variable* var, Token::Value op,
-                              FeedbackVectorICSlot slot);
+                              FeedbackVectorSlot slot);
 
   // Helper functions to EmitVariableAssignment
   void EmitStoreToStackLocalOrContextSlot(Variable* var,
                                           MemOperand location);
 
   // Complete a named property assignment.  The receiver is expected on top
   // of the stack and the right-hand-side value in the accumulator.
   void EmitNamedPropertyAssignment(Assignment* expr);
 
   // Complete a super named property assignment. The right-hand-side value
@@ skipping 10 matching lines @@
   void EmitKeyedPropertyAssignment(Assignment* expr);
 
   static bool NeedsHomeObject(Expression* expr) {
     return FunctionLiteral::NeedsHomeObject(expr);
   }
 
   // Adds the [[HomeObject]] to |initializer| if it is a FunctionLiteral.
   // The value of the initializer is expected to be at the top of the stack.
   // |offset| is the offset in the stack where the home object can be found.
   void EmitSetHomeObject(Expression* initializer, int offset,
-                         FeedbackVectorICSlot slot);
+                         FeedbackVectorSlot slot);
 
   void EmitSetHomeObjectAccumulator(Expression* initializer, int offset,
-                                    FeedbackVectorICSlot slot);
+                                    FeedbackVectorSlot slot);
 
   void EmitLoadSuperConstructor(SuperCallReference* super_call_ref);
 
   void CallIC(Handle<Code> code,
               TypeFeedbackId id = TypeFeedbackId::None());
 
   // Inside typeof reference errors are never thrown.
   void CallLoadIC(TypeofMode typeof_mode, LanguageMode language_mode = SLOPPY,
                   TypeFeedbackId id = TypeFeedbackId::None());
   void CallStoreIC(TypeFeedbackId id = TypeFeedbackId::None());
@@ skipping 78 matching lines @@
   void VisitForTypeofValue(Expression* expr);
 
   void Generate();
   void PopulateDeoptimizationData(Handle<Code> code);
   void PopulateTypeFeedbackInfo(Handle<Code> code);
   void PopulateHandlerTable(Handle<Code> code);
 
   bool MustCreateObjectLiteralWithRuntime(ObjectLiteral* expr) const;
   bool MustCreateArrayLiteralWithRuntime(ArrayLiteral* expr) const;
 
-  void EmitLoadStoreICSlot(FeedbackVectorICSlot slot);
+  void EmitLoadStoreICSlot(FeedbackVectorSlot slot);
 
   int NewHandlerTableEntry();
 
   struct BailoutEntry {
     BailoutId id;
     unsigned pc_and_state;
   };
 
   struct BackEdgeEntry {
     BailoutId id;
@@ skipping 328 matching lines @@
   Address start_;
   Address instruction_start_;
   uint32_t length_;
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_FULL_CODEGEN_FULL_CODEGEN_H_