Distinction between FeedbackVectorICSlot and FeedbackVectorSlot eliminated.

src/prettyprinter.cc

 // 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.
 
 #include "src/prettyprinter.h"
 
 #include <stdarg.h>
 
 #include "src/ast-value-factory.h"
 #include "src/base/platform/platform.h"
@@ skipping 411 matching lines @@
 void CallPrinter::PrintLiteral(const AstRawString* value, bool quote) {
   PrintLiteral(value->string(), quote);
 }
 
 
 //-----------------------------------------------------------------------------
 
 
 #ifdef DEBUG
 
-// A helper for ast nodes that use FeedbackVectorICSlots.
-static int FormatICSlotNode(Vector<char>* buf, Expression* node,
-                            const char* node_name, FeedbackVectorICSlot slot) {
+// A helper for ast nodes that use FeedbackVectorSlots.
+static int FormatSlotNode(Vector<char>* buf, Expression* node,
+                          const char* node_name, FeedbackVectorSlot slot) {
   int pos = SNPrintF(*buf, "%s", node_name);
   if (!slot.IsInvalid()) {
-    pos = SNPrintF(*buf + pos, " ICSlot(%d)", slot.ToInt());
+    pos = SNPrintF(*buf + pos, " Slot(%d)", slot.ToInt());
   }
   return pos;
 }
 
 
 PrettyPrinter::PrettyPrinter(Isolate* isolate, Zone* zone) {
   output_ = NULL;
   size_ = 0;
   pos_ = 0;
   InitializeAstVisitor(isolate, zone);
@@ skipping 1023 matching lines @@
       Visit(node->values()->at(i));
     }
   }
 }
 
 
 void AstPrinter::VisitVariableProxy(VariableProxy* node) {
   Variable* var = node->var();
   EmbeddedVector<char, 128> buf;
   int pos =
-      FormatICSlotNode(&buf, node, "VAR PROXY", node->VariableFeedbackSlot());
+      FormatSlotNode(&buf, node, "VAR PROXY", node->VariableFeedbackSlot());
 
   switch (var->location()) {
     case VariableLocation::UNALLOCATED:
       break;
     case VariableLocation::PARAMETER:
       SNPrintF(buf + pos, " parameter[%d]", var->index());
       break;
     case VariableLocation::LOCAL:
       SNPrintF(buf + pos, " local[%d]", var->index());
       break;
@@ skipping 25 matching lines @@
 
 
 void AstPrinter::VisitThrow(Throw* node) {
   IndentedScope indent(this, "THROW", node->position());
   Visit(node->exception());
 }
 
 
 void AstPrinter::VisitProperty(Property* node) {
   EmbeddedVector<char, 128> buf;
-  FormatICSlotNode(&buf, node, "PROPERTY", node->PropertyFeedbackSlot());
+  FormatSlotNode(&buf, node, "PROPERTY", node->PropertyFeedbackSlot());
   IndentedScope indent(this, buf.start(), node->position());
 
   Visit(node->obj());
   Literal* literal = node->key()->AsLiteral();
   if (literal != NULL && literal->value()->IsInternalizedString()) {
     PrintLiteralIndented("NAME", literal->value(), false);
   } else {
     PrintIndentedVisit("KEY", node->key());
   }
 }
 
 
 void AstPrinter::VisitCall(Call* node) {
   EmbeddedVector<char, 128> buf;
-  FormatICSlotNode(&buf, node, "CALL", node->CallFeedbackICSlot());
+  FormatSlotNode(&buf, node, "CALL", node->CallFeedbackICSlot());
   IndentedScope indent(this, buf.start());
 
   Visit(node->expression());
   PrintArguments(node->arguments());
 }
 
 
 void AstPrinter::VisitCallNew(CallNew* node) {
   IndentedScope indent(this, "CALL NEW", node->position());
   Visit(node->expression());
@@ skipping 61 matching lines @@
 
 void AstPrinter::VisitSuperCallReference(SuperCallReference* node) {
   IndentedScope indent(this, "SUPER-CALL-REFERENCE", node->position());
 }
 
 
 #endif  // DEBUG
 
 }  // namespace internal
 }  // namespace v8