VectorICs: --print-ast now prints allocated vector slots

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 <stdarg.h>
 
 #include "src/v8.h"
 
 #include "src/ast-value-factory.h"
 #include "src/base/platform/platform.h"
@@ skipping 401 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) {
+  int pos = SNPrintF(*buf, "%s", node_name);
+  if (!slot.IsInvalid()) {
+    const char* str = Code::Kind2String(node->FeedbackICSlotKind(0));
+    pos = SNPrintF(*buf + pos, " ICSlot(%d, %s)", slot.ToInt(), str);
+  }
+  return pos;
+}
+
+
 PrettyPrinter::PrettyPrinter(Isolate* isolate, Zone* zone) {
   output_ = NULL;
   size_ = 0;
   pos_ = 0;
   InitializeAstVisitor(isolate, zone);
 }
 
 
 PrettyPrinter::~PrettyPrinter() {
   DeleteArray(output_);
@@ skipping 991 matching lines @@
   PrintIndented(buf.start());
   if (node->values()->length() > 0) {
     IndentedScope indent(this, "VALUES");
     for (int i = 0; i < node->values()->length(); i++) {
       Visit(node->values()->at(i));
     }
   }
 }
 
 
-// TODO(svenpanne) Start with IndentedScope.
 void AstPrinter::VisitVariableProxy(VariableProxy* node) {
   Variable* var = node->var();
   EmbeddedVector<char, 128> buf;
-  int pos = SNPrintF(buf, "VAR PROXY");
+  int pos =
+      FormatICSlotNode(&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;
     case VariableLocation::CONTEXT:
@@ skipping 23 matching lines @@
 }
 
 
 void AstPrinter::VisitThrow(Throw* node) {
   IndentedScope indent(this, "THROW");
   Visit(node->exception());
 }
 
 
 void AstPrinter::VisitProperty(Property* node) {
-  IndentedScope indent(this, "PROPERTY");
+  EmbeddedVector<char, 128> buf;
+  FormatICSlotNode(&buf, node, "PROPERTY", node->PropertyFeedbackSlot());
+  IndentedScope indent(this, buf.start());
+
   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) {
-  IndentedScope indent(this, "CALL");
+  EmbeddedVector<char, 128> buf;
+  FormatICSlotNode(&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");
   Visit(node->expression());
   PrintArguments(node->arguments());
 }
 
 
 void AstPrinter::VisitCallRuntime(CallRuntime* node) {
-  IndentedScope indent(this, "CALL RUNTIME");
+  EmbeddedVector<char, 128> buf;
+  FormatICSlotNode(&buf, node, "CALL RUNTIME", node->CallRuntimeFeedbackSlot());
+  IndentedScope indent(this, buf.start());
   PrintLiteralIndented("NAME", node->name(), false);
   PrintArguments(node->arguments());
 }
 
 
 void AstPrinter::VisitUnaryOperation(UnaryOperation* node) {
   IndentedScope indent(this, Token::Name(node->op()));
   Visit(node->expression());
 }
 
@@ skipping 39 matching lines @@
 
 void AstPrinter::VisitSuperCallReference(SuperCallReference* node) {
   IndentedScope indent(this, "SUPER-CALL-REFERENCE");
 }
 
 
 #endif  // DEBUG
 
 }  // namespace internal
 }  // namespace v8