Rename: ExpressionBuilder => ExpressionCfgBuilder, StatementBuilder =>...

src/cfg.cc

 // Copyright 2009 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 57 matching lines @@
   }
   if (fun->scope()->arguments() != NULL) {
     BAILOUT("function uses .arguments");
   }
 
   ZoneList<Statement*>* body = fun->body();
   if (body->is_empty()) {
     BAILOUT("empty function body");
   }
 
-  StatementBuilder builder;
+  StatementCfgBuilder builder;
   builder.VisitStatements(body);
   Cfg* graph = builder.graph();
   if (graph == NULL) {
     BAILOUT("unsupported statement type");
   }
   if (graph->is_empty()) {
     BAILOUT("function body produces empty cfg");
   }
   if (graph->has_exit()) {
     BAILOUT("control path without explicit return");
@@ skipping 135 matching lines @@
   ASSERT(temp->where() == TempLocation::NOT_ALLOCATED);
   if (temp == value_) {
     temp->set_where(TempLocation::ACCUMULATOR);
   } else {
     temp->set_where(TempLocation::STACK);
   }
 }
 
 
 // The expression builder should not be used for declarations or statements.
-void ExpressionBuilder::VisitDeclaration(Declaration* decl) { UNREACHABLE(); }
+void ExpressionCfgBuilder::VisitDeclaration(Declaration* decl) {
+  UNREACHABLE();
+}
 
 #define DEFINE_VISIT(type)                                              \
-  void ExpressionBuilder::Visit##type(type* stmt) { UNREACHABLE(); }
+  void ExpressionCfgBuilder::Visit##type(type* stmt) { UNREACHABLE(); }
 STATEMENT_NODE_LIST(DEFINE_VISIT)
 #undef DEFINE_VISIT
 
 
 // Macros (temporarily) handling unsupported expression types.
 #define BAILOUT(reason)                         \
   do {                                          \
     graph_ = NULL;                              \
     return;                                     \
   } while (false)
 
-void ExpressionBuilder::VisitFunctionLiteral(FunctionLiteral* expr) {
+void ExpressionCfgBuilder::VisitFunctionLiteral(FunctionLiteral* expr) {
   BAILOUT("FunctionLiteral");
 }
 
 
-void ExpressionBuilder::VisitFunctionBoilerplateLiteral(
+void ExpressionCfgBuilder::VisitFunctionBoilerplateLiteral(
     FunctionBoilerplateLiteral* expr) {
   BAILOUT("FunctionBoilerplateLiteral");
 }
 
 
-void ExpressionBuilder::VisitConditional(Conditional* expr) {
+void ExpressionCfgBuilder::VisitConditional(Conditional* expr) {
   BAILOUT("Conditional");
 }
 
 
-void ExpressionBuilder::VisitSlot(Slot* expr) {
+void ExpressionCfgBuilder::VisitSlot(Slot* expr) {
   BAILOUT("Slot");
 }
 
 
-void ExpressionBuilder::VisitVariableProxy(VariableProxy* expr) {
+void ExpressionCfgBuilder::VisitVariableProxy(VariableProxy* expr) {
   Expression* rewrite = expr->var()->rewrite();
   if (rewrite == NULL || rewrite->AsSlot() == NULL) {
     BAILOUT("unsupported variable (not a slot)");
   }
   Slot* slot = rewrite->AsSlot();
   if (slot->type() != Slot::PARAMETER && slot->type() != Slot::LOCAL) {
     BAILOUT("unsupported slot type (not a parameter or local)");
   }
   // Ignore the passed destination.
   value_ = new SlotLocation(slot->type(), slot->index());
 }
 
 
-void ExpressionBuilder::VisitLiteral(Literal* expr) {
+void ExpressionCfgBuilder::VisitLiteral(Literal* expr) {
   // Ignore the passed destination.
   value_ = new Constant(expr->handle());
 }
 
 
-void ExpressionBuilder::VisitRegExpLiteral(RegExpLiteral* expr) {
+void ExpressionCfgBuilder::VisitRegExpLiteral(RegExpLiteral* expr) {
   BAILOUT("RegExpLiteral");
 }
 
 
-void ExpressionBuilder::VisitObjectLiteral(ObjectLiteral* expr) {
+void ExpressionCfgBuilder::VisitObjectLiteral(ObjectLiteral* expr) {
   BAILOUT("ObjectLiteral");
 }
 
 
-void ExpressionBuilder::VisitArrayLiteral(ArrayLiteral* expr) {
+void ExpressionCfgBuilder::VisitArrayLiteral(ArrayLiteral* expr) {
   BAILOUT("ArrayLiteral");
 }
 
 
-void ExpressionBuilder::VisitCatchExtensionObject(CatchExtensionObject* expr) {
+void ExpressionCfgBuilder::VisitCatchExtensionObject(
+    CatchExtensionObject* expr) {
   BAILOUT("CatchExtensionObject");
 }
 
 
-void ExpressionBuilder::VisitAssignment(Assignment* expr) {
+void ExpressionCfgBuilder::VisitAssignment(Assignment* expr) {
   if (expr->op() != Token::ASSIGN && expr->op() != Token::INIT_VAR) {
     BAILOUT("unsupported compound assignment");
   }
   Expression* lhs = expr->target();
   if (lhs->AsProperty() != NULL) {
     BAILOUT("unsupported property assignment");
   }
   Variable* var = lhs->AsVariableProxy()->AsVariable();
   if (var == NULL) {
     BAILOUT("unsupported invalid left-hand side");
   }
   if (var->is_global()) {
     BAILOUT("unsupported global variable");
   }
   Slot* slot = var->slot();
   ASSERT(slot != NULL);
   if (slot->type() != Slot::PARAMETER && slot->type() != Slot::LOCAL) {
     BAILOUT("unsupported slot lhs (not a parameter or local)");
   }
 
-  ExpressionBuilder builder;
+  ExpressionCfgBuilder builder;
   SlotLocation* loc = new SlotLocation(slot->type(), slot->index());
   builder.Build(expr->value(), loc);
   if (builder.graph() == NULL) {
     BAILOUT("unsupported expression in assignment");
   }
   // If the expression did not come back in the slot location, append
   // a move to the CFG.
   graph_ = builder.graph();
   if (builder.value() != loc) {
     graph()->Append(new MoveInstr(loc, builder.value()));
   }
   // Record the assignment.
   assigned_vars_.AddElement(loc);
   // Ignore the destination passed to us.
   value_ = loc;
 }
 
 
-void ExpressionBuilder::VisitThrow(Throw* expr) {
+void ExpressionCfgBuilder::VisitThrow(Throw* expr) {
   BAILOUT("Throw");
 }
 
 
-void ExpressionBuilder::VisitProperty(Property* expr) {
+void ExpressionCfgBuilder::VisitProperty(Property* expr) {
   BAILOUT("Property");
 }
 
 
-void ExpressionBuilder::VisitCall(Call* expr) {
+void ExpressionCfgBuilder::VisitCall(Call* expr) {
   BAILOUT("Call");
 }
 
 
-void ExpressionBuilder::VisitCallEval(CallEval* expr) {
+void ExpressionCfgBuilder::VisitCallEval(CallEval* expr) {
   BAILOUT("CallEval");
 }
 
 
-void ExpressionBuilder::VisitCallNew(CallNew* expr) {
+void ExpressionCfgBuilder::VisitCallNew(CallNew* expr) {
   BAILOUT("CallNew");
 }
 
 
-void ExpressionBuilder::VisitCallRuntime(CallRuntime* expr) {
+void ExpressionCfgBuilder::VisitCallRuntime(CallRuntime* expr) {
   BAILOUT("CallRuntime");
 }
 
 
-void ExpressionBuilder::VisitUnaryOperation(UnaryOperation* expr) {
+void ExpressionCfgBuilder::VisitUnaryOperation(UnaryOperation* expr) {
   BAILOUT("UnaryOperation");
 }
 
 
-void ExpressionBuilder::VisitCountOperation(CountOperation* expr) {
+void ExpressionCfgBuilder::VisitCountOperation(CountOperation* expr) {
   BAILOUT("CountOperation");
 }
 
 
-void ExpressionBuilder::VisitBinaryOperation(BinaryOperation* expr) {
+void ExpressionCfgBuilder::VisitBinaryOperation(BinaryOperation* expr) {
   Token::Value op = expr->op();
   switch (op) {
     case Token::COMMA:
     case Token::OR:
     case Token::AND:
       BAILOUT("unsupported binary operation");
 
     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: {
-      ExpressionBuilder left, right;
+      ExpressionCfgBuilder left, right;
       left.Build(expr->left(), NULL);
       if (left.graph() == NULL) {
         BAILOUT("unsupported left subexpression in binop");
       }
       right.Build(expr->right(), NULL);
       if (right.graph() == NULL) {
         BAILOUT("unsupported right subexpression in binop");
       }
 
       if (destination_ == NULL) destination_ = new TempLocation();
@@ skipping 18 matching lines @@
       value_ = destination_;
       return;
     }
 
     default:
       UNREACHABLE();
   }
 }
 
 
-void ExpressionBuilder::VisitCompareOperation(CompareOperation* expr) {
+void ExpressionCfgBuilder::VisitCompareOperation(CompareOperation* expr) {
   BAILOUT("CompareOperation");
 }
 
 
-void ExpressionBuilder::VisitThisFunction(ThisFunction* expr) {
+void ExpressionCfgBuilder::VisitThisFunction(ThisFunction* expr) {
   BAILOUT("ThisFunction");
 }
 
 #undef BAILOUT
 
 
 // Macros (temporarily) handling unsupported statement types.
 #define BAILOUT(reason)                         \
   do {                                          \
     graph_ = NULL;                              \
     return;                                     \
   } while (false)
 
 #define CHECK_BAILOUT()                         \
   if (graph() == NULL) { return; } else {}
 
-void StatementBuilder::VisitStatements(ZoneList<Statement*>* stmts) {
+void StatementCfgBuilder::VisitStatements(ZoneList<Statement*>* stmts) {
   for (int i = 0, len = stmts->length(); i < len; i++) {
     Visit(stmts->at(i));
     CHECK_BAILOUT();
     if (!graph()->has_exit()) return;
   }
 }
 
 
 // The statement builder should not be used for declarations or expressions.
-void StatementBuilder::VisitDeclaration(Declaration* decl) { UNREACHABLE(); }
+void StatementCfgBuilder::VisitDeclaration(Declaration* decl) { UNREACHABLE(); }
 
 #define DEFINE_VISIT(type)                                      \
-  void StatementBuilder::Visit##type(type* expr) { UNREACHABLE(); }
+  void StatementCfgBuilder::Visit##type(type* expr) { UNREACHABLE(); }
 EXPRESSION_NODE_LIST(DEFINE_VISIT)
 #undef DEFINE_VISIT
 
 
-void StatementBuilder::VisitBlock(Block* stmt) {
+void StatementCfgBuilder::VisitBlock(Block* stmt) {
   VisitStatements(stmt->statements());
 }
 
 
-void StatementBuilder::VisitExpressionStatement(ExpressionStatement* stmt) {
-  ExpressionBuilder builder;
+void StatementCfgBuilder::VisitExpressionStatement(ExpressionStatement* stmt) {
+  ExpressionCfgBuilder builder;
   builder.Build(stmt->expression(), CfgGlobals::current()->nowhere());
   if (builder.graph() == NULL) {
     BAILOUT("unsupported expression in expression statement");
   }
   graph()->Append(new PositionInstr(stmt->statement_pos()));
   graph()->Concatenate(builder.graph());
 }
 
 
-void StatementBuilder::VisitEmptyStatement(EmptyStatement* stmt) {
+void StatementCfgBuilder::VisitEmptyStatement(EmptyStatement* stmt) {
   // Nothing to do.
 }
 
 
-void StatementBuilder::VisitIfStatement(IfStatement* stmt) {
+void StatementCfgBuilder::VisitIfStatement(IfStatement* stmt) {
   BAILOUT("IfStatement");
 }
 
 
-void StatementBuilder::VisitContinueStatement(ContinueStatement* stmt) {
+void StatementCfgBuilder::VisitContinueStatement(ContinueStatement* stmt) {
   BAILOUT("ContinueStatement");
 }
 
 
-void StatementBuilder::VisitBreakStatement(BreakStatement* stmt) {
+void StatementCfgBuilder::VisitBreakStatement(BreakStatement* stmt) {
   BAILOUT("BreakStatement");
 }
 
 
-void StatementBuilder::VisitReturnStatement(ReturnStatement* stmt) {
-  ExpressionBuilder builder;
+void StatementCfgBuilder::VisitReturnStatement(ReturnStatement* stmt) {
+  ExpressionCfgBuilder builder;
   builder.Build(stmt->expression(), NULL);
   if (builder.graph() == NULL) {
     BAILOUT("unsupported expression in return statement");
   }
 
   graph()->Append(new PositionInstr(stmt->statement_pos()));
   graph()->Concatenate(builder.graph());
   graph()->AppendReturnInstruction(builder.value());
 }
 
 
-void StatementBuilder::VisitWithEnterStatement(WithEnterStatement* stmt) {
+void StatementCfgBuilder::VisitWithEnterStatement(WithEnterStatement* stmt) {
   BAILOUT("WithEnterStatement");
 }
 
 
-void StatementBuilder::VisitWithExitStatement(WithExitStatement* stmt) {
+void StatementCfgBuilder::VisitWithExitStatement(WithExitStatement* stmt) {
   BAILOUT("WithExitStatement");
 }
 
 
-void StatementBuilder::VisitSwitchStatement(SwitchStatement* stmt) {
+void StatementCfgBuilder::VisitSwitchStatement(SwitchStatement* stmt) {
   BAILOUT("SwitchStatement");
 }
 
 
-void StatementBuilder::VisitLoopStatement(LoopStatement* stmt) {
+void StatementCfgBuilder::VisitLoopStatement(LoopStatement* stmt) {
   BAILOUT("LoopStatement");
 }
 
 
-void StatementBuilder::VisitForInStatement(ForInStatement* stmt) {
+void StatementCfgBuilder::VisitForInStatement(ForInStatement* stmt) {
   BAILOUT("ForInStatement");
 }
 
 
-void StatementBuilder::VisitTryCatch(TryCatch* stmt) {
+void StatementCfgBuilder::VisitTryCatch(TryCatch* stmt) {
   BAILOUT("TryCatch");
 }
 
 
-void StatementBuilder::VisitTryFinally(TryFinally* stmt) {
+void StatementCfgBuilder::VisitTryFinally(TryFinally* stmt) {
   BAILOUT("TryFinally");
 }
 
 
-void StatementBuilder::VisitDebuggerStatement(DebuggerStatement* stmt) {
+void StatementCfgBuilder::VisitDebuggerStatement(DebuggerStatement* stmt) {
   BAILOUT("DebuggerStatement");
 }
 
 
 #ifdef DEBUG
 // CFG printing support (via depth-first, preorder block traversal).
 
 void Cfg::Print() {
   entry_->Print();
   entry_->Unmark();
@@ skipping 83 matching lines @@
 void ExitNode::Print() {
   if (!is_marked_) {
     is_marked_ = true;
     PrintF("L%d:\nExit\n\n", number());
   }
 }
 
 #endif  // DEBUG
 
 } }  // namespace v8::internal