mirror of https://github.com/lukechilds/node.git
Ryan Dahl
15 years ago
43 changed files with 2594 additions and 1823 deletions
File diff suppressed because it is too large
@ -0,0 +1,588 @@ |
|||||
|
// 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
|
||||
|
// with the distribution.
|
||||
|
// * Neither the name of Google Inc. nor the names of its
|
||||
|
// contributors may be used to endorse or promote products derived
|
||||
|
// from this software without specific prior written permission.
|
||||
|
//
|
||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
|
||||
|
#include "flow-graph.h" |
||||
|
|
||||
|
namespace v8 { |
||||
|
namespace internal { |
||||
|
|
||||
|
void FlowGraph::AppendInstruction(AstNode* instruction) { |
||||
|
// Add a (non-null) AstNode to the end of the graph fragment.
|
||||
|
ASSERT(instruction != NULL); |
||||
|
if (exit()->IsExitNode()) return; |
||||
|
if (!exit()->IsBlockNode()) AppendNode(new BlockNode()); |
||||
|
BlockNode::cast(exit())->AddInstruction(instruction); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraph::AppendNode(Node* node) { |
||||
|
// Add a node to the end of the graph. An empty block is added to
|
||||
|
// maintain edge-split form (that no join nodes or exit nodes as
|
||||
|
// successors to branch nodes).
|
||||
|
ASSERT(node != NULL); |
||||
|
if (exit()->IsExitNode()) return; |
||||
|
if (exit()->IsBranchNode() && (node->IsJoinNode() || node->IsExitNode())) { |
||||
|
AppendNode(new BlockNode()); |
||||
|
} |
||||
|
exit()->AddSuccessor(node); |
||||
|
node->AddPredecessor(exit()); |
||||
|
exit_ = node; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraph::AppendGraph(FlowGraph* graph) { |
||||
|
// Add a flow graph fragment to the end of this one. An empty block is
|
||||
|
// added to maintain edge-split form (that no join nodes or exit nodes as
|
||||
|
// successors to branch nodes).
|
||||
|
ASSERT(graph != NULL); |
||||
|
if (exit()->IsExitNode()) return; |
||||
|
Node* node = graph->entry(); |
||||
|
if (exit()->IsBranchNode() && (node->IsJoinNode() || node->IsExitNode())) { |
||||
|
AppendNode(new BlockNode()); |
||||
|
} |
||||
|
exit()->AddSuccessor(node); |
||||
|
node->AddPredecessor(exit()); |
||||
|
exit_ = graph->exit(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraph::Split(BranchNode* branch, |
||||
|
FlowGraph* left, |
||||
|
FlowGraph* right, |
||||
|
JoinNode* join) { |
||||
|
// Add the branch node, left flowgraph, join node.
|
||||
|
AppendNode(branch); |
||||
|
AppendGraph(left); |
||||
|
AppendNode(join); |
||||
|
|
||||
|
// Splice in the right flowgraph.
|
||||
|
right->AppendNode(join); |
||||
|
branch->AddSuccessor(right->entry()); |
||||
|
right->entry()->AddPredecessor(branch); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraph::Loop(JoinNode* join, |
||||
|
FlowGraph* condition, |
||||
|
BranchNode* branch, |
||||
|
FlowGraph* body) { |
||||
|
// Add the join, condition and branch. Add join's predecessors in
|
||||
|
// left-to-right order.
|
||||
|
AppendNode(join); |
||||
|
body->AppendNode(join); |
||||
|
AppendGraph(condition); |
||||
|
AppendNode(branch); |
||||
|
|
||||
|
// Splice in the body flowgraph.
|
||||
|
branch->AddSuccessor(body->entry()); |
||||
|
body->entry()->AddPredecessor(branch); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void ExitNode::Traverse(bool mark, |
||||
|
ZoneList<Node*>* preorder, |
||||
|
ZoneList<Node*>* postorder) { |
||||
|
preorder->Add(this); |
||||
|
postorder->Add(this); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void BlockNode::Traverse(bool mark, |
||||
|
ZoneList<Node*>* preorder, |
||||
|
ZoneList<Node*>* postorder) { |
||||
|
ASSERT(successor_ != NULL); |
||||
|
preorder->Add(this); |
||||
|
if (!successor_->IsMarkedWith(mark)) { |
||||
|
successor_->MarkWith(mark); |
||||
|
successor_->Traverse(mark, preorder, postorder); |
||||
|
} |
||||
|
postorder->Add(this); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void BranchNode::Traverse(bool mark, |
||||
|
ZoneList<Node*>* preorder, |
||||
|
ZoneList<Node*>* postorder) { |
||||
|
ASSERT(successor0_ != NULL && successor1_ != NULL); |
||||
|
preorder->Add(this); |
||||
|
if (!successor1_->IsMarkedWith(mark)) { |
||||
|
successor1_->MarkWith(mark); |
||||
|
successor1_->Traverse(mark, preorder, postorder); |
||||
|
} |
||||
|
if (!successor0_->IsMarkedWith(mark)) { |
||||
|
successor0_->MarkWith(mark); |
||||
|
successor0_->Traverse(mark, preorder, postorder); |
||||
|
} |
||||
|
postorder->Add(this); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void JoinNode::Traverse(bool mark, |
||||
|
ZoneList<Node*>* preorder, |
||||
|
ZoneList<Node*>* postorder) { |
||||
|
ASSERT(successor_ != NULL); |
||||
|
preorder->Add(this); |
||||
|
if (!successor_->IsMarkedWith(mark)) { |
||||
|
successor_->MarkWith(mark); |
||||
|
successor_->Traverse(mark, preorder, postorder); |
||||
|
} |
||||
|
postorder->Add(this); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::Build(FunctionLiteral* lit) { |
||||
|
global_exit_ = new ExitNode(); |
||||
|
VisitStatements(lit->body()); |
||||
|
|
||||
|
if (HasStackOverflow()) return; |
||||
|
|
||||
|
// The graph can end with a branch node (if the function ended with a
|
||||
|
// loop). Maintain edge-split form (no join nodes or exit nodes as
|
||||
|
// successors to branch nodes).
|
||||
|
if (graph_.exit()->IsBranchNode()) graph_.AppendNode(new BlockNode()); |
||||
|
graph_.AppendNode(global_exit_); |
||||
|
|
||||
|
// Build preorder and postorder traversal orders. All the nodes in
|
||||
|
// the graph have the same mark flag. For the traversal, use that
|
||||
|
// flag's negation. Traversal will flip all the flags.
|
||||
|
bool mark = graph_.entry()->IsMarkedWith(false); |
||||
|
graph_.entry()->MarkWith(mark); |
||||
|
graph_.entry()->Traverse(mark, &preorder_, &postorder_); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
// This function peels off one iteration of a for-loop. The return value
|
||||
|
// is either a block statement containing the peeled loop or NULL in case
|
||||
|
// there is a stack overflow.
|
||||
|
static Statement* PeelForLoop(ForStatement* stmt) { |
||||
|
// Mark this for-statement as processed.
|
||||
|
stmt->set_peel_this_loop(false); |
||||
|
|
||||
|
// Create new block containing the init statement of the for-loop and
|
||||
|
// an if-statement containing the peeled iteration and the original
|
||||
|
// loop without the init-statement.
|
||||
|
Block* block = new Block(NULL, 2, false); |
||||
|
if (stmt->init() != NULL) { |
||||
|
Statement* init = stmt->init(); |
||||
|
// The init statement gets the statement position of the for-loop
|
||||
|
// to make debugging of peeled loops possible.
|
||||
|
init->set_statement_pos(stmt->statement_pos()); |
||||
|
block->AddStatement(init); |
||||
|
} |
||||
|
|
||||
|
// Copy the condition.
|
||||
|
CopyAstVisitor copy_visitor; |
||||
|
Expression* cond_copy = stmt->cond() != NULL |
||||
|
? copy_visitor.DeepCopyExpr(stmt->cond()) |
||||
|
: new Literal(Factory::true_value()); |
||||
|
if (copy_visitor.HasStackOverflow()) return NULL; |
||||
|
|
||||
|
// Construct a block with the peeled body and the rest of the for-loop.
|
||||
|
Statement* body_copy = copy_visitor.DeepCopyStmt(stmt->body()); |
||||
|
if (copy_visitor.HasStackOverflow()) return NULL; |
||||
|
|
||||
|
Statement* next_copy = stmt->next() != NULL |
||||
|
? copy_visitor.DeepCopyStmt(stmt->next()) |
||||
|
: new EmptyStatement(); |
||||
|
if (copy_visitor.HasStackOverflow()) return NULL; |
||||
|
|
||||
|
Block* peeled_body = new Block(NULL, 3, false); |
||||
|
peeled_body->AddStatement(body_copy); |
||||
|
peeled_body->AddStatement(next_copy); |
||||
|
peeled_body->AddStatement(stmt); |
||||
|
|
||||
|
// Remove the duplicated init statement from the for-statement.
|
||||
|
stmt->set_init(NULL); |
||||
|
|
||||
|
// Create new test at the top and add it to the newly created block.
|
||||
|
IfStatement* test = new IfStatement(cond_copy, |
||||
|
peeled_body, |
||||
|
new EmptyStatement()); |
||||
|
block->AddStatement(test); |
||||
|
return block; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitStatements(ZoneList<Statement*>* stmts) { |
||||
|
for (int i = 0, len = stmts->length(); i < len; i++) { |
||||
|
stmts->at(i) = ProcessStatement(stmts->at(i)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
Statement* FlowGraphBuilder::ProcessStatement(Statement* stmt) { |
||||
|
if (FLAG_loop_peeling && |
||||
|
stmt->AsForStatement() != NULL && |
||||
|
stmt->AsForStatement()->peel_this_loop()) { |
||||
|
Statement* tmp_stmt = PeelForLoop(stmt->AsForStatement()); |
||||
|
if (tmp_stmt == NULL) { |
||||
|
SetStackOverflow(); |
||||
|
} else { |
||||
|
stmt = tmp_stmt; |
||||
|
} |
||||
|
} |
||||
|
Visit(stmt); |
||||
|
return stmt; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitDeclaration(Declaration* decl) { |
||||
|
UNREACHABLE(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitBlock(Block* stmt) { |
||||
|
VisitStatements(stmt->statements()); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitExpressionStatement(ExpressionStatement* stmt) { |
||||
|
Visit(stmt->expression()); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitEmptyStatement(EmptyStatement* stmt) { |
||||
|
// Nothing to do.
|
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitIfStatement(IfStatement* stmt) { |
||||
|
Visit(stmt->condition()); |
||||
|
|
||||
|
BranchNode* branch = new BranchNode(); |
||||
|
FlowGraph original = graph_; |
||||
|
graph_ = FlowGraph::Empty(); |
||||
|
stmt->set_then_statement(ProcessStatement(stmt->then_statement())); |
||||
|
|
||||
|
FlowGraph left = graph_; |
||||
|
graph_ = FlowGraph::Empty(); |
||||
|
stmt->set_else_statement(ProcessStatement(stmt->else_statement())); |
||||
|
|
||||
|
if (HasStackOverflow()) return; |
||||
|
JoinNode* join = new JoinNode(); |
||||
|
original.Split(branch, &left, &graph_, join); |
||||
|
graph_ = original; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitContinueStatement(ContinueStatement* stmt) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitBreakStatement(BreakStatement* stmt) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitReturnStatement(ReturnStatement* stmt) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitWithEnterStatement(WithEnterStatement* stmt) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitWithExitStatement(WithExitStatement* stmt) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitSwitchStatement(SwitchStatement* stmt) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitDoWhileStatement(DoWhileStatement* stmt) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitWhileStatement(WhileStatement* stmt) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitForStatement(ForStatement* stmt) { |
||||
|
if (stmt->init() != NULL) stmt->set_init(ProcessStatement(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(); |
||||
|
stmt->set_body(ProcessStatement(stmt->body())); |
||||
|
|
||||
|
if (stmt->next() != NULL) stmt->set_next(ProcessStatement(stmt->next())); |
||||
|
|
||||
|
if (HasStackOverflow()) return; |
||||
|
original.Loop(join, &condition, branch, &graph_); |
||||
|
graph_ = original; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitForInStatement(ForInStatement* stmt) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitTryCatchStatement(TryCatchStatement* stmt) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitTryFinallyStatement(TryFinallyStatement* stmt) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitDebuggerStatement(DebuggerStatement* stmt) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitFunctionLiteral(FunctionLiteral* expr) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitSharedFunctionInfoLiteral( |
||||
|
SharedFunctionInfoLiteral* expr) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitConditional(Conditional* expr) { |
||||
|
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) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitObjectLiteral(ObjectLiteral* expr) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitArrayLiteral(ArrayLiteral* expr) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitCatchExtensionObject(CatchExtensionObject* 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) { |
||||
|
if (expr->is_compound()) Visit(expr->target()); |
||||
|
Visit(expr->value()); |
||||
|
if (var->IsStackAllocated()) { |
||||
|
// The first definition in the body is numbered n, where n is the
|
||||
|
// number of parameters and stack-allocated locals.
|
||||
|
expr->set_num(body_definitions_.length() + variable_count_); |
||||
|
body_definitions_.Add(expr); |
||||
|
} |
||||
|
|
||||
|
} else if (prop != NULL) { |
||||
|
Visit(prop->obj()); |
||||
|
if (!prop->key()->IsPropertyName()) Visit(prop->key()); |
||||
|
Visit(expr->value()); |
||||
|
} |
||||
|
|
||||
|
if (HasStackOverflow()) return; |
||||
|
graph_.AppendInstruction(expr); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitThrow(Throw* expr) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitProperty(Property* expr) { |
||||
|
Visit(expr->obj()); |
||||
|
if (!expr->key()->IsPropertyName()) Visit(expr->key()); |
||||
|
|
||||
|
if (HasStackOverflow()) return; |
||||
|
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)); |
||||
|
} |
||||
|
|
||||
|
if (HasStackOverflow()) return; |
||||
|
graph_.AppendInstruction(expr); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitCallNew(CallNew* expr) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitCallRuntime(CallRuntime* expr) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitUnaryOperation(UnaryOperation* 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()); |
||||
|
if (HasStackOverflow()) return; |
||||
|
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()) { |
||||
|
// The first definition in the body is numbered n, where n is the number
|
||||
|
// of parameters and stack-allocated locals.
|
||||
|
expr->set_num(body_definitions_.length() + variable_count_); |
||||
|
body_definitions_.Add(expr); |
||||
|
} |
||||
|
|
||||
|
if (HasStackOverflow()) return; |
||||
|
graph_.AppendInstruction(expr); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitBinaryOperation(BinaryOperation* expr) { |
||||
|
switch (expr->op()) { |
||||
|
case Token::COMMA: |
||||
|
case Token::OR: |
||||
|
case Token::AND: |
||||
|
SetStackOverflow(); |
||||
|
break; |
||||
|
|
||||
|
case Token::BIT_OR: |
||||
|
case Token::BIT_XOR: |
||||
|
case Token::BIT_AND: |
||||
|
case Token::SHL: |
||||
|
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()); |
||||
|
if (HasStackOverflow()) return; |
||||
|
graph_.AppendInstruction(expr); |
||||
|
break; |
||||
|
|
||||
|
default: |
||||
|
UNREACHABLE(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitCompareOperation(CompareOperation* 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()); |
||||
|
if (HasStackOverflow()) return; |
||||
|
graph_.AppendInstruction(expr); |
||||
|
break; |
||||
|
|
||||
|
default: |
||||
|
UNREACHABLE(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void FlowGraphBuilder::VisitThisFunction(ThisFunction* expr) { |
||||
|
SetStackOverflow(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
@ -0,0 +1,379 @@ |
|||||
|
// 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
|
||||
|
// with the distribution.
|
||||
|
// * Neither the name of Google Inc. nor the names of its
|
||||
|
// contributors may be used to endorse or promote products derived
|
||||
|
// from this software without specific prior written permission.
|
||||
|
//
|
||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
|
||||
|
#ifndef V8_FLOW_GRAPH_H_ |
||||
|
#define V8_FLOW_GRAPH_H_ |
||||
|
|
||||
|
#include "v8.h" |
||||
|
|
||||
|
#include "data-flow.h" |
||||
|
#include "zone.h" |
||||
|
|
||||
|
namespace v8 { |
||||
|
namespace internal { |
||||
|
|
||||
|
// Flow-graph nodes.
|
||||
|
class Node: public ZoneObject { |
||||
|
public: |
||||
|
Node() : number_(-1), mark_(false) {} |
||||
|
|
||||
|
virtual ~Node() {} |
||||
|
|
||||
|
virtual bool IsExitNode() { return false; } |
||||
|
virtual bool IsBlockNode() { return false; } |
||||
|
virtual bool IsBranchNode() { return false; } |
||||
|
virtual bool IsJoinNode() { return false; } |
||||
|
|
||||
|
virtual void AddPredecessor(Node* predecessor) = 0; |
||||
|
virtual void AddSuccessor(Node* successor) = 0; |
||||
|
|
||||
|
bool IsMarkedWith(bool mark) { return mark_ == mark; } |
||||
|
void MarkWith(bool mark) { mark_ = mark; } |
||||
|
|
||||
|
// Perform a depth first search and record preorder and postorder
|
||||
|
// traversal orders.
|
||||
|
virtual void Traverse(bool mark, |
||||
|
ZoneList<Node*>* preorder, |
||||
|
ZoneList<Node*>* postorder) = 0; |
||||
|
|
||||
|
int number() { return number_; } |
||||
|
void set_number(int number) { number_ = number; } |
||||
|
|
||||
|
// Functions used by data-flow analyses.
|
||||
|
virtual void InitializeReachingDefinitions(int definition_count, |
||||
|
List<BitVector*>* variables, |
||||
|
WorkList<Node>* worklist, |
||||
|
bool mark); |
||||
|
virtual void ComputeRDOut(BitVector* result) = 0; |
||||
|
virtual void UpdateRDIn(WorkList<Node>* worklist, bool mark) = 0; |
||||
|
virtual void PropagateReachingDefinitions(List<BitVector*>* variables); |
||||
|
|
||||
|
// Functions used by dead-code elimination.
|
||||
|
virtual void MarkCriticalInstructions( |
||||
|
List<AstNode*>* stack, |
||||
|
ZoneList<Expression*>* body_definitions, |
||||
|
int variable_count); |
||||
|
|
||||
|
#ifdef DEBUG |
||||
|
void AssignNodeNumber(); |
||||
|
void PrintReachingDefinitions(); |
||||
|
virtual void PrintText() = 0; |
||||
|
#endif |
||||
|
|
||||
|
protected: |
||||
|
ReachingDefinitionsData rd_; |
||||
|
|
||||
|
private: |
||||
|
int number_; |
||||
|
bool mark_; |
||||
|
|
||||
|
DISALLOW_COPY_AND_ASSIGN(Node); |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// An exit node has a arbitrarily many predecessors and no successors.
|
||||
|
class ExitNode: public Node { |
||||
|
public: |
||||
|
ExitNode() : predecessors_(4) {} |
||||
|
|
||||
|
virtual bool IsExitNode() { return true; } |
||||
|
|
||||
|
virtual void AddPredecessor(Node* predecessor) { |
||||
|
ASSERT(predecessor != NULL); |
||||
|
predecessors_.Add(predecessor); |
||||
|
} |
||||
|
|
||||
|
virtual void AddSuccessor(Node* successor) { UNREACHABLE(); } |
||||
|
|
||||
|
virtual void Traverse(bool mark, |
||||
|
ZoneList<Node*>* preorder, |
||||
|
ZoneList<Node*>* postorder); |
||||
|
|
||||
|
virtual void ComputeRDOut(BitVector* result); |
||||
|
virtual void UpdateRDIn(WorkList<Node>* worklist, bool mark); |
||||
|
|
||||
|
#ifdef DEBUG |
||||
|
virtual void PrintText(); |
||||
|
#endif |
||||
|
|
||||
|
private: |
||||
|
ZoneList<Node*> predecessors_; |
||||
|
|
||||
|
DISALLOW_COPY_AND_ASSIGN(ExitNode); |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// Block nodes have a single successor and predecessor and a list of
|
||||
|
// instructions.
|
||||
|
class BlockNode: public Node { |
||||
|
public: |
||||
|
BlockNode() : predecessor_(NULL), successor_(NULL), instructions_(4) {} |
||||
|
|
||||
|
static BlockNode* cast(Node* node) { |
||||
|
ASSERT(node->IsBlockNode()); |
||||
|
return reinterpret_cast<BlockNode*>(node); |
||||
|
} |
||||
|
|
||||
|
virtual bool IsBlockNode() { return true; } |
||||
|
|
||||
|
bool is_empty() { return instructions_.is_empty(); } |
||||
|
|
||||
|
ZoneList<AstNode*>* instructions() { return &instructions_; } |
||||
|
|
||||
|
virtual void AddPredecessor(Node* predecessor) { |
||||
|
ASSERT(predecessor_ == NULL && predecessor != NULL); |
||||
|
predecessor_ = predecessor; |
||||
|
} |
||||
|
|
||||
|
virtual void AddSuccessor(Node* successor) { |
||||
|
ASSERT(successor_ == NULL && successor != NULL); |
||||
|
successor_ = successor; |
||||
|
} |
||||
|
|
||||
|
void AddInstruction(AstNode* instruction) { |
||||
|
instructions_.Add(instruction); |
||||
|
} |
||||
|
|
||||
|
virtual void Traverse(bool mark, |
||||
|
ZoneList<Node*>* preorder, |
||||
|
ZoneList<Node*>* postorder); |
||||
|
|
||||
|
virtual void InitializeReachingDefinitions(int definition_count, |
||||
|
List<BitVector*>* variables, |
||||
|
WorkList<Node>* worklist, |
||||
|
bool mark); |
||||
|
virtual void ComputeRDOut(BitVector* result); |
||||
|
virtual void UpdateRDIn(WorkList<Node>* worklist, bool mark); |
||||
|
virtual void PropagateReachingDefinitions(List<BitVector*>* variables); |
||||
|
|
||||
|
virtual void MarkCriticalInstructions( |
||||
|
List<AstNode*>* stack, |
||||
|
ZoneList<Expression*>* body_definitions, |
||||
|
int variable_count); |
||||
|
|
||||
|
#ifdef DEBUG |
||||
|
virtual void PrintText(); |
||||
|
#endif |
||||
|
|
||||
|
private: |
||||
|
Node* predecessor_; |
||||
|
Node* successor_; |
||||
|
ZoneList<AstNode*> instructions_; |
||||
|
|
||||
|
DISALLOW_COPY_AND_ASSIGN(BlockNode); |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// Branch nodes have a single predecessor and a pair of successors.
|
||||
|
class BranchNode: public Node { |
||||
|
public: |
||||
|
BranchNode() : predecessor_(NULL), successor0_(NULL), successor1_(NULL) {} |
||||
|
|
||||
|
virtual bool IsBranchNode() { return true; } |
||||
|
|
||||
|
virtual void AddPredecessor(Node* predecessor) { |
||||
|
ASSERT(predecessor_ == NULL && predecessor != NULL); |
||||
|
predecessor_ = predecessor; |
||||
|
} |
||||
|
|
||||
|
virtual void AddSuccessor(Node* successor) { |
||||
|
ASSERT(successor1_ == NULL && successor != NULL); |
||||
|
if (successor0_ == NULL) { |
||||
|
successor0_ = successor; |
||||
|
} else { |
||||
|
successor1_ = successor; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
virtual void Traverse(bool mark, |
||||
|
ZoneList<Node*>* preorder, |
||||
|
ZoneList<Node*>* postorder); |
||||
|
|
||||
|
virtual void ComputeRDOut(BitVector* result); |
||||
|
virtual void UpdateRDIn(WorkList<Node>* worklist, bool mark); |
||||
|
|
||||
|
#ifdef DEBUG |
||||
|
virtual void PrintText(); |
||||
|
#endif |
||||
|
|
||||
|
private: |
||||
|
Node* predecessor_; |
||||
|
Node* successor0_; |
||||
|
Node* successor1_; |
||||
|
|
||||
|
DISALLOW_COPY_AND_ASSIGN(BranchNode); |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// Join nodes have arbitrarily many predecessors and a single successor.
|
||||
|
class JoinNode: public Node { |
||||
|
public: |
||||
|
JoinNode() : predecessors_(2), successor_(NULL) {} |
||||
|
|
||||
|
static JoinNode* cast(Node* node) { |
||||
|
ASSERT(node->IsJoinNode()); |
||||
|
return reinterpret_cast<JoinNode*>(node); |
||||
|
} |
||||
|
|
||||
|
virtual bool IsJoinNode() { return true; } |
||||
|
|
||||
|
virtual void AddPredecessor(Node* predecessor) { |
||||
|
ASSERT(predecessor != NULL); |
||||
|
predecessors_.Add(predecessor); |
||||
|
} |
||||
|
|
||||
|
virtual void AddSuccessor(Node* successor) { |
||||
|
ASSERT(successor_ == NULL && successor != NULL); |
||||
|
successor_ = successor; |
||||
|
} |
||||
|
|
||||
|
virtual void Traverse(bool mark, |
||||
|
ZoneList<Node*>* preorder, |
||||
|
ZoneList<Node*>* postorder); |
||||
|
|
||||
|
virtual void ComputeRDOut(BitVector* result); |
||||
|
virtual void UpdateRDIn(WorkList<Node>* worklist, bool mark); |
||||
|
|
||||
|
#ifdef DEBUG |
||||
|
virtual void PrintText(); |
||||
|
#endif |
||||
|
|
||||
|
private: |
||||
|
ZoneList<Node*> predecessors_; |
||||
|
Node* successor_; |
||||
|
|
||||
|
DISALLOW_COPY_AND_ASSIGN(JoinNode); |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// Flow graphs have a single entry and single exit. The empty flowgraph is
|
||||
|
// represented by both entry and exit being NULL.
|
||||
|
class FlowGraph BASE_EMBEDDED { |
||||
|
public: |
||||
|
static FlowGraph Empty() { |
||||
|
FlowGraph graph; |
||||
|
graph.entry_ = new BlockNode(); |
||||
|
graph.exit_ = graph.entry_; |
||||
|
return graph; |
||||
|
} |
||||
|
|
||||
|
bool is_empty() const { |
||||
|
return entry_ == exit_ && BlockNode::cast(entry_)->is_empty(); |
||||
|
} |
||||
|
Node* entry() const { return entry_; } |
||||
|
Node* exit() const { return exit_; } |
||||
|
|
||||
|
// Add a single instruction to the end of this flowgraph.
|
||||
|
void AppendInstruction(AstNode* instruction); |
||||
|
|
||||
|
// Add a single node to the end of this flow graph.
|
||||
|
void AppendNode(Node* node); |
||||
|
|
||||
|
// Add a flow graph fragment to the end of this one.
|
||||
|
void AppendGraph(FlowGraph* graph); |
||||
|
|
||||
|
// Concatenate an if-then-else flow-graph to this one. Control is split
|
||||
|
// and merged, so the graph remains single-entry, single-exit.
|
||||
|
void Split(BranchNode* branch, |
||||
|
FlowGraph* left, |
||||
|
FlowGraph* right, |
||||
|
JoinNode* merge); |
||||
|
|
||||
|
// Concatenate a forward loop (e.g., while or for loop) flow-graph to this
|
||||
|
// one. Control is split by the condition and merged back from the back
|
||||
|
// edge at end of the body to the beginning of the condition. The single
|
||||
|
// (free) exit of the result graph is the right (false) arm of the branch
|
||||
|
// node.
|
||||
|
void Loop(JoinNode* merge, |
||||
|
FlowGraph* condition, |
||||
|
BranchNode* branch, |
||||
|
FlowGraph* body); |
||||
|
|
||||
|
#ifdef DEBUG |
||||
|
void PrintText(FunctionLiteral* fun, ZoneList<Node*>* postorder); |
||||
|
#endif |
||||
|
|
||||
|
private: |
||||
|
FlowGraph() : entry_(NULL), exit_(NULL) {} |
||||
|
|
||||
|
Node* entry_; |
||||
|
Node* exit_; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// Construct a flow graph from a function literal. Build pre- and postorder
|
||||
|
// traversal orders as a byproduct.
|
||||
|
class FlowGraphBuilder: public AstVisitor { |
||||
|
public: |
||||
|
explicit FlowGraphBuilder(int variable_count) |
||||
|
: graph_(FlowGraph::Empty()), |
||||
|
global_exit_(NULL), |
||||
|
preorder_(4), |
||||
|
postorder_(4), |
||||
|
variable_count_(variable_count), |
||||
|
body_definitions_(4) { |
||||
|
} |
||||
|
|
||||
|
void Build(FunctionLiteral* lit); |
||||
|
|
||||
|
FlowGraph* graph() { return &graph_; } |
||||
|
ZoneList<Node*>* preorder() { return &preorder_; } |
||||
|
ZoneList<Node*>* postorder() { return &postorder_; } |
||||
|
ZoneList<Expression*>* body_definitions() { return &body_definitions_; } |
||||
|
|
||||
|
private: |
||||
|
ExitNode* global_exit() { return global_exit_; } |
||||
|
|
||||
|
// Helpers to allow tranforming the ast during flow graph construction.
|
||||
|
void VisitStatements(ZoneList<Statement*>* stmts); |
||||
|
Statement* ProcessStatement(Statement* stmt); |
||||
|
|
||||
|
// AST node visit functions.
|
||||
|
#define DECLARE_VISIT(type) virtual void Visit##type(type* node); |
||||
|
AST_NODE_LIST(DECLARE_VISIT) |
||||
|
#undef DECLARE_VISIT |
||||
|
|
||||
|
FlowGraph graph_; |
||||
|
ExitNode* global_exit_; |
||||
|
ZoneList<Node*> preorder_; |
||||
|
ZoneList<Node*> postorder_; |
||||
|
|
||||
|
// The flow graph builder collects a list of explicit definitions
|
||||
|
// (assignments and count operations) to stack-allocated variables to use
|
||||
|
// for reaching definitions analysis. It does not count the implicit
|
||||
|
// definition at function entry. AST node numbers in the AST are used to
|
||||
|
// refer into this list.
|
||||
|
int variable_count_; |
||||
|
ZoneList<Expression*> body_definitions_; |
||||
|
|
||||
|
DISALLOW_COPY_AND_ASSIGN(FlowGraphBuilder); |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
|
|
||||
|
#endif // V8_FLOW_GRAPH_H_
|
||||
Loading…
Reference in new issue