Merge bleeding edge up to 9192 into the GC branch.

src/prettyprinter.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 113 matching lines @@
 
 
 void PrettyPrinter::VisitWithStatement(WithStatement* node) {
   Print("with (");
   Visit(node->expression());
   Print(") ");
   Visit(node->statement());
 }
 
 
-void PrettyPrinter::VisitExitContextStatement(ExitContextStatement* node) {
-  Print("<exit context>");
-}
-
-
 void PrettyPrinter::VisitSwitchStatement(SwitchStatement* node) {
   PrintLabels(node->labels());
   Print("switch (");
   Visit(node->tag());
   Print(") { ");
   ZoneList<CaseClause*>* cases = node->cases();
   for (int i = 0; i < cases->length(); i++)
     PrintCaseClause(cases->at(i));
   Print("}");
 }
@@ skipping 128 matching lines @@
 void PrettyPrinter::VisitArrayLiteral(ArrayLiteral* node) {
   Print("[ ");
   for (int i = 0; i < node->values()->length(); i++) {
     if (i != 0) Print(",");
     Visit(node->values()->at(i));
   }
   Print(" ]");
 }
 
 
-void PrettyPrinter::VisitSlot(Slot* node) {
-  switch (node->type()) {
-    case Slot::PARAMETER:
-      Print("parameter[%d]", node->index());
-      break;
-    case Slot::LOCAL:
-      Print("local[%d]", node->index());
-      break;
-    case Slot::CONTEXT:
-      Print("context[%d]", node->index());
-      break;
-    case Slot::LOOKUP:
-      Print("lookup[");
-      PrintLiteral(node->var()->name(), false);
-      Print("]");
-      break;
-    default:
-      UNREACHABLE();
-  }
-}
-
-
 void PrettyPrinter::VisitVariableProxy(VariableProxy* node) {
   PrintLiteral(node->name(), false);
 }
 
 
 void PrettyPrinter::VisitAssignment(Assignment* node) {
   Visit(node->target());
   Print(" %s ", Token::String(node->op()));
   Visit(node->value());
 }
@@ skipping 425 matching lines @@
   const char* block_txt = node->is_initializer_block() ? "BLOCK INIT" : "BLOCK";
   IndentedScope indent(this, block_txt);
   PrintStatements(node->statements());
 }
 
 
 void AstPrinter::VisitDeclaration(Declaration* node) {
   if (node->fun() == NULL) {
     // var or const declarations
     PrintLiteralWithModeIndented(Variable::Mode2String(node->mode()),
-                                 node->proxy()->AsVariable(),
+                                 node->proxy()->var(),
                                  node->proxy()->name());
   } else {
     // function declarations
     PrintIndented("FUNCTION ");
     PrintLiteral(node->proxy()->name(), true);
     Print(" = function ");
     PrintLiteral(node->fun()->name(), false);
     Print("\n");
   }
 }
@@ skipping 33 matching lines @@
 }
 
 
 void AstPrinter::VisitWithStatement(WithStatement* node) {
   IndentedScope indent(this, "WITH");
   PrintIndentedVisit("OBJECT", node->expression());
   PrintIndentedVisit("BODY", node->statement());
 }
 
 
-void AstPrinter::VisitExitContextStatement(ExitContextStatement* node) {
-  PrintIndented("EXIT CONTEXT\n");
-}
-
-
 void AstPrinter::VisitSwitchStatement(SwitchStatement* node) {
   IndentedScope indent(this, "SWITCH");
   PrintLabelsIndented(NULL, node->labels());
   PrintIndentedVisit("TAG", node->tag());
   for (int i = 0; i < node->cases()->length(); i++) {
     PrintCaseClause(node->cases()->at(i));
   }
 }
 
 
@@ skipping 129 matching lines @@
   IndentedScope indent(this, "ARRAY LITERAL");
   if (node->values()->length() > 0) {
     IndentedScope indent(this, "VALUES");
     for (int i = 0; i < node->values()->length(); i++) {
       Visit(node->values()->at(i));
     }
   }
 }
 
 
-void AstPrinter::VisitSlot(Slot* node) {
-  PrintIndented("SLOT ");
-  PrettyPrinter::VisitSlot(node);
-  Print("\n");
-}
-
-
 void AstPrinter::VisitVariableProxy(VariableProxy* node) {
-  PrintLiteralWithModeIndented("VAR PROXY", node->AsVariable(), node->name());
   Variable* var = node->var();
-  if (var != NULL && var->rewrite() != NULL) {
-    IndentedScope indent(this);
-    Visit(var->rewrite());
+  PrintLiteralWithModeIndented("VAR PROXY", var, node->name());
+  { IndentedScope indent(this);
+    switch (var->location()) {
+      case Variable::UNALLOCATED:
+        break;
+      case Variable::PARAMETER:
+        Print("parameter[%d]", var->index());
+        break;
+      case Variable::LOCAL:
+        Print("local[%d]", var->index());
+        break;
+      case Variable::CONTEXT:
+        Print("context[%d]", var->index());
+        break;
+      case Variable::LOOKUP:
+        Print("lookup");
+        break;
+    }
   }
 }
 
 
 void AstPrinter::VisitAssignment(Assignment* node) {
   IndentedScope indent(this, Token::Name(node->op()), node);
   Visit(node->target());
   Visit(node->value());
 }
 
@@ skipping 210 matching lines @@
 }
 
 
 void JsonAstBuilder::VisitWithStatement(WithStatement* stmt) {
   TagScope tag(this, "WithStatement");
   Visit(stmt->expression());
   Visit(stmt->statement());
 }
 
 
-void JsonAstBuilder::VisitExitContextStatement(ExitContextStatement* stmt) {
-  TagScope tag(this, "ExitContextStatement");
-}
-
-
 void JsonAstBuilder::VisitSwitchStatement(SwitchStatement* stmt) {
   TagScope tag(this, "SwitchStatement");
 }
 
 
 void JsonAstBuilder::VisitDoWhileStatement(DoWhileStatement* stmt) {
   TagScope tag(this, "DoWhileStatement");
   Visit(stmt->body());
   Visit(stmt->cond());
 }
@@ skipping 60 matching lines @@
     SharedFunctionInfoLiteral* expr) {
   TagScope tag(this, "SharedFunctionInfoLiteral");
 }
 
 
 void JsonAstBuilder::VisitConditional(Conditional* expr) {
   TagScope tag(this, "Conditional");
 }
 
 
-void JsonAstBuilder::VisitSlot(Slot* expr) {
-  TagScope tag(this, "Slot");
-  {
-    AttributesScope attributes(this);
-    switch (expr->type()) {
-      case Slot::PARAMETER:
-        AddAttribute("type", "PARAMETER");
-        break;
-      case Slot::LOCAL:
-        AddAttribute("type", "LOCAL");
-        break;
-      case Slot::CONTEXT:
-        AddAttribute("type", "CONTEXT");
-        break;
-      case Slot::LOOKUP:
-        AddAttribute("type", "LOOKUP");
-        break;
-    }
-    AddAttribute("index", expr->index());
-  }
-}
-
-
 void JsonAstBuilder::VisitVariableProxy(VariableProxy* expr) {
-  if (expr->var()->rewrite() == NULL) {
-    TagScope tag(this, "VariableProxy");
-    {
-      AttributesScope attributes(this);
-      AddAttribute("name", expr->name());
-      AddAttribute("mode", Variable::Mode2String(expr->var()->mode()));
+  TagScope tag(this, "Variable");
+  {
+    AttributesScope attributes(this);
+    Variable* var = expr->var();
+    AddAttribute("name", var->name());
+    switch (var->location()) {
+      case Variable::UNALLOCATED:
+        AddAttribute("location", "UNALLOCATED");
+        break;
+      case Variable::PARAMETER:
+        AddAttribute("location", "PARAMETER");
+        AddAttribute("index", var->index());
+        break;
+      case Variable::LOCAL:
+        AddAttribute("location", "LOCAL");
+        AddAttribute("index", var->index());
+        break;
+      case Variable::CONTEXT:
+        AddAttribute("location", "CONTEXT");
+        AddAttribute("index", var->index());
+        break;
+      case Variable::LOOKUP:
+        AddAttribute("location", "LOOKUP");
+        break;
     }
-  } else {
-    Visit(expr->var()->rewrite());
   }
 }
 
 
 void JsonAstBuilder::VisitLiteral(Literal* expr) {
   TagScope tag(this, "Literal");
   {
     AttributesScope attributes(this);
     Handle<Object> handle = expr->handle();
     if (handle->IsString()) {
@@ skipping 133 matching lines @@
     AddAttribute("mode", Variable::Mode2String(decl->mode()));
   }
   Visit(decl->proxy());
   if (decl->fun() != NULL) Visit(decl->fun());
 }
 
 
 #endif  // DEBUG
 
 } }  // namespace v8::internal