Restructure to support recursive invocation of the CFG builder. Add...

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 18 matching lines @@
 
 #include "bootstrapper.h"
 #include "cfg.h"
 #include "scopeinfo.h"
 #include "scopes.h"
 
 namespace v8 {
 namespace internal {
 
 
-ExitNode* Cfg::global_exit_ = NULL;
+CfgGlobals* CfgGlobals::top_ = NULL;
 
 
-void CfgNode::Reset() {
+CfgGlobals::CfgGlobals(FunctionLiteral* fun)
+    : global_fun_(fun),
+      global_exit_(new ExitNode()),
 #ifdef DEBUG
-  node_counter_ = 0;
+      node_counter_(0),
 #endif
-}
-
-
-void Cfg::Reset(FunctionLiteral* fun) {
-  global_exit_ = new ExitNode(fun);
-  CfgNode::Reset();
+      previous_(top_) {
+  top_ = this;
 }
 
 
 #define BAILOUT(reason)                         \
   do { return NULL; } while (false)
 
-Cfg* Cfg::Build(FunctionLiteral* fun) {
+Cfg* Cfg::Build() {
+  FunctionLiteral* fun = CfgGlobals::current()->fun();
+  if (fun->scope()->num_heap_slots() > 0) {
+    BAILOUT("function has context slots");
+  }
+  if (fun->scope()->arguments() != NULL) {
+    BAILOUT("function uses .arguments");
+  }
+
   ZoneList<Statement*>* body = fun->body();
   if (body->is_empty()) {
     BAILOUT("empty function body");
   }
 
-  Cfg::Reset(fun);
   StatementBuilder builder;
   builder.VisitStatements(body);
   Cfg* cfg = builder.cfg();
   if (cfg == NULL) {
     BAILOUT("unsupported statement type");
   }
   if (cfg->has_exit()) {
     BAILOUT("control path without explicit return");
   }
-  cfg->PrependEntryNode(fun);
+  cfg->PrependEntryNode();
   return cfg;
 }
 
 #undef BAILOUT
 
 
-void Cfg::PrependEntryNode(FunctionLiteral* fun) {
+void Cfg::PrependEntryNode() {
   ASSERT(!is_empty());
-  entry_ = new EntryNode(fun, InstructionBlock::cast(entry()));
+  entry_ = new EntryNode(InstructionBlock::cast(entry()));
 }
 
 
 void Cfg::Append(Instruction* instr) {
   ASSERT(has_exit());
   ASSERT(!is_empty());
   InstructionBlock::cast(exit_)->Append(instr);
 }
 
 
 void Cfg::AppendReturnInstruction(Value* value) {
   Append(new ReturnInstr(value));
-  InstructionBlock::cast(exit_)->set_successor(global_exit_);
+  ExitNode* global_exit = CfgGlobals::current()->exit();
+  InstructionBlock::cast(exit_)->set_successor(global_exit);
   exit_ = NULL;
 }
 
 
-EntryNode::EntryNode(FunctionLiteral* fun, InstructionBlock* succ)
-    : successor_(succ), local_count_(fun->scope()->num_stack_slots()) {
-}
-
-
-ExitNode::ExitNode(FunctionLiteral* fun)
-    : parameter_count_(fun->scope()->num_parameters()) {
-}
-
-
 void InstructionBlock::Unmark() {
   if (is_marked_) {
     is_marked_ = false;
     successor_->Unmark();
   }
 }
 
 
 void EntryNode::Unmark() {
   if (is_marked_) {
     is_marked_ = false;
     successor_->Unmark();
   }
 }
 
 
-void ExitNode::Unmark() {}
+void ExitNode::Unmark() { is_marked_ = false; }

[Kasper Lund, 2009/08/03 05:55:44]

I would put this on three lines.

[Kevin Millikin (Chromium), 2009/08/03 07:54:43]

Done.

 
 
-Handle<Code> Cfg::Compile(FunctionLiteral* fun, Handle<Script> script) {
+Handle<Code> Cfg::Compile(Handle<Script> script) {
   const int kInitialBufferSize = 4 * KB;
   MacroAssembler* masm = new MacroAssembler(NULL, kInitialBufferSize);
   entry()->Compile(masm);
   entry()->Unmark();
   CodeDesc desc;
   masm->GetCode(&desc);
+  FunctionLiteral* fun = CfgGlobals::current()->fun();
   ZoneScopeInfo info(fun->scope());
   InLoopFlag in_loop = fun->loop_nesting() ? IN_LOOP : NOT_IN_LOOP;
   Code::Flags flags = Code::ComputeFlags(Code::FUNCTION, in_loop);
   Handle<Code> code = Factory::NewCode(desc, &info, flags, masm->CodeObject());
 
   // Add unresolved entries in the code to the fixup list.
   Bootstrapper::AddFixup(*code, masm);
 
 #ifdef ENABLE_DISASSEMBLER
   if (FLAG_print_code) {
     // Print the source code if available.
     if (!script->IsUndefined() && !script->source()->IsUndefined()) {
       PrintF("--- Raw source ---\n");
       StringInputBuffer stream(String::cast(script->source()));
       stream.Seek(fun->start_position());
-      // fun->end_position() points to the last character in the stream. We
-      // need to compensate by adding one to calculate the length.
+      // fun->end_position() points to the last character in the
+      // stream. We need to compensate by adding one to calculate the
+      // length.
       int source_len = fun->end_position() - fun->start_position() + 1;
       for (int i = 0; i < source_len; i++) {
         if (stream.has_more()) PrintF("%c", stream.GetNext());
       }
       PrintF("\n\n");
     }
     PrintF("--- Code ---\n");
     code->Disassemble(*fun->name()->ToCString());
   }
 #endif
@@ skipping 36 matching lines @@
   BAILOUT("Conditional");
 }
 
 
 void ExpressionBuilder::VisitSlot(Slot* expr) {
   BAILOUT("Slot");
 }
 
 
 void ExpressionBuilder::VisitVariableProxy(VariableProxy* expr) {
-  BAILOUT("VariableProxy");
+  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)");
+  }
+  value_ = new SlotLocation(slot->type(), slot->index());
 }
 
 
 void ExpressionBuilder::VisitLiteral(Literal* expr) {
   value_ = new Constant(expr->handle());
 }
 
 
 void ExpressionBuilder::VisitRegExpLiteral(RegExpLiteral* expr) {
   BAILOUT("RegExpLiteral");
@@ skipping 188 matching lines @@
 #ifdef DEBUG
 // CFG printing support (via depth-first, preorder block traversal).
 
 void Cfg::Print() {
   entry_->Print();
   entry_->Unmark();
 }
 
 
 void Constant::Print() {
+  PrintF("Constant(");
   handle_->Print();
+  PrintF(")");
+}
+
+
+void SlotLocation::Print() {
+  PrintF("Slot(");
+  switch (type_) {
+    case Slot::PARAMETER:
+      PrintF("PARAMETER, %d)", index_);
+      break;
+    case Slot::LOCAL:
+      PrintF("LOCAL, %d)", index_);
+      break;
+    default:
+      UNREACHABLE();
+  }
 }
 
 
 void ReturnInstr::Print() {
   PrintF("Return ");
   value_->Print();
   PrintF("\n");
 }
 
 
-int CfgNode::node_counter_ = 0;
-
-
 void InstructionBlock::Print() {
   if (!is_marked_) {
     is_marked_ = true;
     PrintF("L%d:\n", number());
     for (int i = 0, len = instructions_.length(); i < len; i++) {
       instructions_[i]->Print();
     }
     PrintF("Goto L%d\n\n", successor_->number());
     successor_->Print();
   }
@@ skipping 11 matching lines @@
 void ExitNode::Print() {
   if (!is_marked_) {
     is_marked_ = true;
     PrintF("L%d:\nExit\n\n", number());
   }
 }
 
 #endif  // DEBUG
 
 } }  // namespace v8::internal