Cut back the syntactic constructs handled by the flow graph builder.

src/data-flow.cc

 // Copyright 2010 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 221 matching lines @@
   SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitBreakStatement(BreakStatement* stmt) {
   SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitReturnStatement(ReturnStatement* stmt) {
-  Visit(stmt->expression());
-  graph_.AppendInstruction(stmt);
-  graph_.AppendNode(global_exit());
+  SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitWithEnterStatement(WithEnterStatement* stmt) {
-  Visit(stmt->expression());
-  graph_.AppendInstruction(stmt);
+  SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitWithExitStatement(WithExitStatement* stmt) {
-  graph_.AppendInstruction(stmt);
+  SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitSwitchStatement(SwitchStatement* stmt) {
   SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitDoWhileStatement(DoWhileStatement* stmt) {
-  JoinNode* join = new JoinNode();
-  FlowGraph original = graph_;
-  graph_ = FlowGraph::Empty();
-  Visit(stmt->body());
-
-  FlowGraph body = graph_;
-  graph_ = FlowGraph::Empty();
-  Visit(stmt->cond());
-
-  BranchNode* branch = new BranchNode();
-
-  // Add body, condition and branch.
-  original.AppendNode(join);
-  original.AppendGraph(&body);
-  original.AppendGraph(&graph_);  // The condition.
-  original.AppendNode(branch);
-
-  // Tie the knot.
-  branch->AddSuccessor(join);
-  join->AddPredecessor(branch);
-
-  graph_ = original;
+  SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitWhileStatement(WhileStatement* stmt) {
-  JoinNode* join = new JoinNode();
-  FlowGraph original = graph_;
-  graph_ = FlowGraph::Empty();
-  Visit(stmt->cond());
-
-  BranchNode* branch = new BranchNode();
-  FlowGraph condition = graph_;
-  graph_ = FlowGraph::Empty();
-  Visit(stmt->body());
-
-  original.Loop(join, &condition, branch, &graph_);
-  graph_ = original;
+  SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitForStatement(ForStatement* stmt) {
   if (stmt->init() != NULL) Visit(stmt->init());
 
   JoinNode* join = new JoinNode();
   FlowGraph original = graph_;
   graph_ = FlowGraph::Empty();
   if (stmt->cond() != NULL) Visit(stmt->cond());
 
   BranchNode* branch = new BranchNode();
   FlowGraph condition = graph_;
   graph_ = FlowGraph::Empty();
   Visit(stmt->body());
 
   if (stmt->next() != NULL) Visit(stmt->next());
 
   original.Loop(join, &condition, branch, &graph_);
   graph_ = original;
 }
 
 
 void FlowGraphBuilder::VisitForInStatement(ForInStatement* stmt) {
-  Visit(stmt->enumerable());
-
-  JoinNode* join = new JoinNode();
-  FlowGraph empty;
-  BranchNode* branch = new BranchNode();
-  FlowGraph original = graph_;
-  graph_ = FlowGraph::Empty();
-  Visit(stmt->body());
-
-  original.Loop(join, &empty, branch, &graph_);
-  graph_ = original;
+  SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitTryCatchStatement(TryCatchStatement* stmt) {
   SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
   SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitDebuggerStatement(DebuggerStatement* stmt) {
-  graph_.AppendInstruction(stmt);
+  SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitFunctionLiteral(FunctionLiteral* expr) {
-  graph_.AppendInstruction(expr);
+  SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitFunctionBoilerplateLiteral(
     FunctionBoilerplateLiteral* expr) {
-  graph_.AppendInstruction(expr);
+  SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitConditional(Conditional* expr) {
-  Visit(expr->condition());
-
-  BranchNode* branch = new BranchNode();
-  FlowGraph original = graph_;
-  graph_ = FlowGraph::Empty();
-  Visit(expr->then_expression());
-
-  FlowGraph left = graph_;
-  graph_ = FlowGraph::Empty();
-  Visit(expr->else_expression());
-
-  JoinNode* join = new JoinNode();
-  original.Split(branch, &left, &graph_, join);
-  graph_ = original;
+  SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitSlot(Slot* expr) {
   UNREACHABLE();
 }
 
 
 void FlowGraphBuilder::VisitVariableProxy(VariableProxy* expr) {
   graph_.AppendInstruction(expr);
 }
 
 
 void FlowGraphBuilder::VisitLiteral(Literal* expr) {
   graph_.AppendInstruction(expr);
 }
 
 
 void FlowGraphBuilder::VisitRegExpLiteral(RegExpLiteral* expr) {
-  graph_.AppendInstruction(expr);
+  SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitObjectLiteral(ObjectLiteral* expr) {
-  ZoneList<ObjectLiteral::Property*>* properties = expr->properties();
-  for (int i = 0, len = properties->length(); i < len; i++) {
-    Visit(properties->at(i)->value());
-  }
-  graph_.AppendInstruction(expr);
+  SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitArrayLiteral(ArrayLiteral* expr) {
-  ZoneList<Expression*>* values = expr->values();
-  for (int i = 0, len = values->length(); i < len; i++) {
-    Visit(values->at(i));
-  }
-  graph_.AppendInstruction(expr);
+  SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitCatchExtensionObject(CatchExtensionObject* expr) {
-  graph_.AppendInstruction(expr);
+  SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitAssignment(Assignment* expr) {
   Variable* var = expr->target()->AsVariableProxy()->AsVariable();
   Property* prop = expr->target()->AsProperty();
   // Left-hand side can be a variable or property (or reference error) but
   // not both.
   ASSERT(var == NULL || prop == NULL);
   if (var != NULL) {
     Visit(expr->value());
     if (var->IsStackAllocated()) definitions_.Add(expr);
 
   } else if (prop != NULL) {
     Visit(prop->obj());
     if (!prop->key()->IsPropertyName()) Visit(prop->key());
     Visit(expr->value());
   }
   graph_.AppendInstruction(expr);
 }
 
 
 void FlowGraphBuilder::VisitThrow(Throw* expr) {
-  Visit(expr->exception());
-  graph_.AppendInstruction(expr);
+  SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitProperty(Property* expr) {
   Visit(expr->obj());
   if (!expr->key()->IsPropertyName()) Visit(expr->key());
   graph_.AppendInstruction(expr);
 }
 
 
 void FlowGraphBuilder::VisitCall(Call* expr) {
   Visit(expr->expression());
   ZoneList<Expression*>* arguments = expr->arguments();
   for (int i = 0, len = arguments->length(); i < len; i++) {
     Visit(arguments->at(i));
   }
   graph_.AppendInstruction(expr);
 }
 
 
 void FlowGraphBuilder::VisitCallNew(CallNew* expr) {
-  Visit(expr->expression());
-  ZoneList<Expression*>* arguments = expr->arguments();
-  for (int i = 0, len = arguments->length(); i < len; i++) {
-    Visit(arguments->at(i));
-  }
-  graph_.AppendInstruction(expr);
+  SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitCallRuntime(CallRuntime* expr) {
-  ZoneList<Expression*>* arguments = expr->arguments();
-  for (int i = 0, len = arguments->length(); i < len; i++) {
-    Visit(arguments->at(i));
-  }
-  graph_.AppendInstruction(expr);
+  SetStackOverflow();
 }
 
 
 void FlowGraphBuilder::VisitUnaryOperation(UnaryOperation* expr) {
-  Visit(expr->expression());
-  graph_.AppendInstruction(expr);
+  switch (expr->op()) {
+    case Token::NOT:
+    case Token::BIT_NOT:
+    case Token::DELETE:
+    case Token::TYPEOF:
+    case Token::VOID:
+      SetStackOverflow();
+      break;
+
+    case Token::ADD:
+    case Token::SUB:
+      Visit(expr->expression());
+      graph_.AppendInstruction(expr);
+      break;
+
+    default:
+      UNREACHABLE();
+  }
 }
 
 
 void FlowGraphBuilder::VisitCountOperation(CountOperation* expr) {
   Visit(expr->expression());
   Variable* var = expr->expression()->AsVariableProxy()->AsVariable();
   if (var != NULL && var->IsStackAllocated()) {
     definitions_.Add(expr);
   }
   graph_.AppendInstruction(expr);
 }
 
 
 void FlowGraphBuilder::VisitBinaryOperation(BinaryOperation* expr) {
-  Visit(expr->left());
 
   switch (expr->op()) {
     case Token::COMMA:
-      Visit(expr->right());
+    case Token::OR:
+    case Token::AND:
+      SetStackOverflow();
       break;
 
-    case Token::OR: {
-      BranchNode* branch = new BranchNode();
-      FlowGraph original = graph_;
-      graph_ = FlowGraph::Empty();
-      Visit(expr->right());
-      FlowGraph empty;
-      JoinNode* join = new JoinNode();
-      original.Split(branch, &empty, &graph_, join);
-      graph_ = original;
-      break;
-    }
-
-    case Token::AND: {
-      BranchNode* branch = new BranchNode();
-      FlowGraph original = graph_;
-      graph_ = FlowGraph::Empty();
-      Visit(expr->right());
-      FlowGraph empty;
-      JoinNode* join = new JoinNode();
-      original.Split(branch, &graph_, &empty, join);
-      graph_ = original;
-      break;
-    }
-
     case Token::BIT_OR:
     case Token::BIT_XOR:
     case Token::BIT_AND:
     case Token::SHL:
-    case Token::SAR:
     case Token::SHR:
     case Token::ADD:
     case Token::SUB:
     case Token::MUL:
     case Token::DIV:
     case Token::MOD:
+    case Token::SAR:
+      Visit(expr->left());
       Visit(expr->right());
       graph_.AppendInstruction(expr);
       break;
 
     default:
       UNREACHABLE();
   }
 }
 
 
 void FlowGraphBuilder::VisitCompareOperation(CompareOperation* expr) {
-  Visit(expr->left());
-  Visit(expr->right());
-  graph_.AppendInstruction(expr);
+  switch (expr->op()) {
+    case Token::EQ:
+    case Token::NE:
+    case Token::EQ_STRICT:
+    case Token::NE_STRICT:
+    case Token::INSTANCEOF:
+    case Token::IN:
+      SetStackOverflow();
+      break;
+
+    case Token::LT:
+    case Token::GT:
+    case Token::LTE:
+    case Token::GTE:
+      Visit(expr->left());
+      Visit(expr->right());
+      graph_.AppendInstruction(expr);
+      break;
+
+    default:
+      UNREACHABLE();
+  }
 }
 
 
 void FlowGraphBuilder::VisitThisFunction(ThisFunction* expr) {
-  graph_.AppendInstruction(expr);
+  SetStackOverflow();
 }
 
 
 void AstLabeler::Label(CompilationInfo* info) {
   info_ = info;
   VisitStatements(info_->function()->body());
 }
 
 
 void AstLabeler::VisitStatements(ZoneList<Statement*>* stmts) {
@@ skipping 881 matching lines @@
   for (int i = postorder->length() - 1; i >= 0; i--) {
     postorder->at(i)->PrintText();
   }
 }
 
 
 #endif  // defined(DEBUG)
 
 
 } }  // namespace v8::internal