v8::internal::compiler::CFGBuilder Class Reference

Collaboration diagram for v8::internal::compiler::CFGBuilder:

Public Member Functions
	CFGBuilder (Zone *zone, Scheduler *scheduler)
void	Run ()
void	FixNode (BasicBlock *block, Node *node)
void	Queue (Node *node)
void	BuildBlocks (Node *node)
void	ConnectBlocks (Node *node)
void	BuildBlockForNode (Node *node)
void	BuildBlocksForSuccessors (Node *node, IrOpcode::Value a, IrOpcode::Value b)
void	CollectSuccessorProjections (Node *node, Node **buffer, IrOpcode::Value true_opcode, IrOpcode::Value false_opcode)
void	CollectSuccessorBlocks (Node *node, BasicBlock **buffer, IrOpcode::Value true_opcode, IrOpcode::Value false_opcode)
void	ConnectBranch (Node *branch)
void	ConnectMerge (Node *merge)
void	ConnectReturn (Node *ret)
void	TraceConnect (Node *node, BasicBlock *block, BasicBlock *succ)

Public Attributes
Scheduler *	scheduler_
Schedule *	schedule_
ZoneQueue< Node * >	queue_
NodeVector	control_

Detailed Description

Definition at line 35 of file scheduler.cc.

Constructor & Destructor Documentation

CFGBuilder()

v8::internal::compiler::CFGBuilder::CFGBuilder ( Zone *  zone, Scheduler *  scheduler  )

inline

Definition at line 42 of file scheduler.cc.

      : scheduler_(scheduler),
        schedule_(scheduler->schedule_),
        queue_(zone),
        control_(zone) {}

Member Function Documentation

BuildBlockForNode()

void v8::internal::compiler::CFGBuilder::BuildBlockForNode ( Node *  node )

inline

Definition at line 122 of file scheduler.cc.

                                     {
    if (schedule_->block(node) == NULL) {
      BasicBlock* block = schedule_->NewBasicBlock();
      Trace("Create block B%d for #%d:%s\n", block->id(), node->id(),
            node->op()->mnemonic());
      FixNode(block, node);
    }
  }

References v8::internal::compiler::Schedule::block(), FixNode(), v8::internal::compiler::Schedule::NewBasicBlock(), NULL, schedule_, and v8::internal::compiler::Trace().

Referenced by BuildBlocks(), and BuildBlocksForSuccessors().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildBlocks()

void v8::internal::compiler::CFGBuilder::BuildBlocks ( Node *  node )

inline

Definition at line 89 of file scheduler.cc.

                               {
    switch (node->opcode()) {
      case IrOpcode::kLoop:
      case IrOpcode::kMerge:
        BuildBlockForNode(node);
        break;
      case IrOpcode::kBranch:
        BuildBlocksForSuccessors(node, IrOpcode::kIfTrue, IrOpcode::kIfFalse);
        break;
      default:
        break;
    }
  }

References BuildBlockForNode(), and BuildBlocksForSuccessors().

Referenced by Queue().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildBlocksForSuccessors()

void v8::internal::compiler::CFGBuilder::BuildBlocksForSuccessors ( Node *  node, IrOpcode::Value  a, IrOpcode::Value  b  )

inline

Definition at line 131 of file scheduler.cc.

                                                 {
    Node* successors[2];
    CollectSuccessorProjections(node, successors, a, b);
    BuildBlockForNode(successors[0]);
    BuildBlockForNode(successors[1]);
  }

References BuildBlockForNode(), and CollectSuccessorProjections().

Referenced by BuildBlocks().

Here is the call graph for this function:

Here is the caller graph for this function:

CollectSuccessorBlocks()

void v8::internal::compiler::CFGBuilder::CollectSuccessorBlocks ( Node *  node, BasicBlock **  buffer, IrOpcode::Value  true_opcode, IrOpcode::Value  false_opcode  )

inline

Definition at line 161 of file scheduler.cc.

                                                          {
    Node* successors[2];
    CollectSuccessorProjections(node, successors, true_opcode, false_opcode);
    buffer[0] = schedule_->block(successors[0]);
    buffer[1] = schedule_->block(successors[1]);
  }

References v8::internal::compiler::Schedule::block(), CollectSuccessorProjections(), and schedule_.

Referenced by ConnectBranch().

Here is the call graph for this function:

Here is the caller graph for this function:

CollectSuccessorProjections()

void v8::internal::compiler::CFGBuilder::CollectSuccessorProjections ( Node *  node, Node **  buffer, IrOpcode::Value  true_opcode, IrOpcode::Value  false_opcode  )

inline

Definition at line 142 of file scheduler.cc.

                                                               {
    buffer[0] = NULL;
    buffer[1] = NULL;
    for (UseIter i = node->uses().begin(); i != node->uses().end(); ++i) {
      if ((*i)->opcode() == true_opcode) {
        DCHECK_EQ(NULL, buffer[0]);
        buffer[0] = *i;
      }
      if ((*i)->opcode() == false_opcode) {
        DCHECK_EQ(NULL, buffer[1]);
        buffer[1] = *i;
      }
    }
    DCHECK_NE(NULL, buffer[0]);
    DCHECK_NE(NULL, buffer[1]);
  }

References DCHECK_EQ, DCHECK_NE, and NULL.

Referenced by BuildBlocksForSuccessors(), and CollectSuccessorBlocks().

Here is the caller graph for this function:

ConnectBlocks()

void v8::internal::compiler::CFGBuilder::ConnectBlocks ( Node *  node )

inline

Definition at line 103 of file scheduler.cc.

                                 {
    switch (node->opcode()) {
      case IrOpcode::kLoop:
      case IrOpcode::kMerge:
        ConnectMerge(node);
        break;
      case IrOpcode::kBranch:
        scheduler_->schedule_root_nodes_.push_back(node);
        ConnectBranch(node);
        break;
      case IrOpcode::kReturn:
        scheduler_->schedule_root_nodes_.push_back(node);
        ConnectReturn(node);
        break;
      default:
        break;
    }
  }

References ConnectBranch(), ConnectMerge(), ConnectReturn(), v8::internal::compiler::Scheduler::schedule_root_nodes_, and scheduler_.

Referenced by Run().

Here is the call graph for this function:

Here is the caller graph for this function:

ConnectBranch()

void v8::internal::compiler::CFGBuilder::ConnectBranch ( Node *  branch )

inline

Definition at line 170 of file scheduler.cc.

                                   {
    Node* branch_block_node = NodeProperties::GetControlInput(branch);
    BasicBlock* branch_block = schedule_->block(branch_block_node);
    DCHECK(branch_block != NULL);
 
    BasicBlock* successor_blocks[2];
    CollectSuccessorBlocks(branch, successor_blocks, IrOpcode::kIfTrue,
                           IrOpcode::kIfFalse);
 
    TraceConnect(branch, branch_block, successor_blocks[0]);
    TraceConnect(branch, branch_block, successor_blocks[1]);
 
    schedule_->AddBranch(branch_block, branch, successor_blocks[0],
                         successor_blocks[1]);
  }

References v8::internal::compiler::Schedule::AddBranch(), v8::internal::compiler::Schedule::block(), CollectSuccessorBlocks(), DCHECK, v8::internal::compiler::NodeProperties::GetControlInput(), NULL, schedule_, and TraceConnect().

Referenced by ConnectBlocks().

Here is the call graph for this function:

Here is the caller graph for this function:

ConnectMerge()

void v8::internal::compiler::CFGBuilder::ConnectMerge ( Node *  merge )

inline

Definition at line 186 of file scheduler.cc.

                                 {
    BasicBlock* block = schedule_->block(merge);
    DCHECK(block != NULL);
    // For all of the merge's control inputs, add a goto at the end to the
    // merge's basic block.
    for (InputIter j = merge->inputs().begin(); j != merge->inputs().end();
         ++j) {
      BasicBlock* predecessor_block = schedule_->block(*j);
      if ((*j)->opcode() != IrOpcode::kReturn) {
        TraceConnect(merge, predecessor_block, block);
        schedule_->AddGoto(predecessor_block, block);
      }
    }
  }

References v8::internal::compiler::Schedule::AddGoto(), v8::internal::compiler::Schedule::block(), DCHECK, NULL, schedule_, and TraceConnect().

Referenced by ConnectBlocks().

Here is the call graph for this function:

Here is the caller graph for this function:

ConnectReturn()

void v8::internal::compiler::CFGBuilder::ConnectReturn ( Node *  ret )

inline

Definition at line 201 of file scheduler.cc.

                                {
    Node* return_block_node = NodeProperties::GetControlInput(ret);
    BasicBlock* return_block = schedule_->block(return_block_node);
    TraceConnect(ret, return_block, NULL);
    schedule_->AddReturn(return_block, ret);
  }

References v8::internal::compiler::Schedule::AddReturn(), v8::internal::compiler::Schedule::block(), v8::internal::compiler::NodeProperties::GetControlInput(), NULL, schedule_, and TraceConnect().

Referenced by ConnectBlocks().

Here is the call graph for this function:

Here is the caller graph for this function:

FixNode()

void v8::internal::compiler::CFGBuilder::FixNode ( BasicBlock *  block, Node *  node  )

inline

Definition at line 72 of file scheduler.cc.

                                              {
    schedule_->AddNode(block, node);
    scheduler_->GetData(node)->is_connected_control_ = true;
    scheduler_->GetData(node)->placement_ = Scheduler::kFixed;
  }

References v8::internal::compiler::Schedule::AddNode(), v8::internal::compiler::Scheduler::GetData(), v8::internal::compiler::Scheduler::SchedulerData::is_connected_control_, v8::internal::compiler::Scheduler::kFixed, v8::internal::compiler::Scheduler::SchedulerData::placement_, schedule_, and scheduler_.

Referenced by BuildBlockForNode(), and Run().

Here is the call graph for this function:

Here is the caller graph for this function:

Queue()

void v8::internal::compiler::CFGBuilder::Queue ( Node *  node )

inline

Definition at line 78 of file scheduler.cc.

                         {
    // Mark the connected control nodes as they queued.
    Scheduler::SchedulerData* data = scheduler_->GetData(node);
    if (!data->is_connected_control_) {
      BuildBlocks(node);
      queue_.push(node);
      control_.push_back(node);
      data->is_connected_control_ = true;
    }
  }

References BuildBlocks(), control_, v8::internal::compiler::Scheduler::GetData(), v8::internal::compiler::Scheduler::SchedulerData::is_connected_control_, queue_, and scheduler_.

Referenced by Run().

Here is the call graph for this function:

Here is the caller graph for this function:

Run()

void v8::internal::compiler::CFGBuilder::Run ( )

inline

Definition at line 51 of file scheduler.cc.

             {
    Graph* graph = scheduler_->graph_;
    FixNode(schedule_->start(), graph->start());
    Queue(graph->end());
 
    while (!queue_.empty()) {  // Breadth-first backwards traversal.
      Node* node = queue_.front();
      queue_.pop();
      int max = NodeProperties::PastControlIndex(node);
      for (int i = NodeProperties::FirstControlIndex(node); i < max; i++) {
        Queue(node->InputAt(i));
      }
    }
 
    for (NodeVector::iterator i = control_.begin(); i != control_.end(); ++i) {
      ConnectBlocks(*i);  // Connect block to its predecessor/successors.
    }
 
    FixNode(schedule_->end(), graph->end());
  }

References ConnectBlocks(), control_, v8::internal::compiler::GenericGraph< V >::end(), v8::internal::compiler::NodeProperties::FirstControlIndex(), FixNode(), v8::internal::compiler::Scheduler::graph_, v8::internal::compiler::NodeProperties::PastControlIndex(), Queue(), queue_, schedule_, scheduler_, and v8::internal::compiler::GenericGraph< V >::start().

Referenced by v8::internal::compiler::Scheduler::BuildCFG().

Here is the call graph for this function:

Here is the caller graph for this function:

TraceConnect()

void v8::internal::compiler::CFGBuilder::TraceConnect ( Node *  node, BasicBlock *  block, BasicBlock *  succ  )

inline

Definition at line 208 of file scheduler.cc.

                                                                     {
    DCHECK_NE(NULL, block);
    if (succ == NULL) {
      Trace("Connect #%d:%s, B%d -> end\n", node->id(), node->op()->mnemonic(),
            block->id());
    } else {
      Trace("Connect #%d:%s, B%d -> B%d\n", node->id(), node->op()->mnemonic(),
            block->id(), succ->id());
    }
  }

References DCHECK_NE, NULL, and v8::internal::compiler::Trace().

Referenced by ConnectBranch(), ConnectMerge(), and ConnectReturn().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

control_

NodeVector v8::internal::compiler::CFGBuilder::control_

Definition at line 40 of file scheduler.cc.

Referenced by Queue(), and Run().

queue_

ZoneQueue<Node*> v8::internal::compiler::CFGBuilder::queue_

Definition at line 39 of file scheduler.cc.

Referenced by Queue(), and Run().

schedule_

Schedule* v8::internal::compiler::CFGBuilder::schedule_

Definition at line 38 of file scheduler.cc.

Referenced by BuildBlockForNode(), CollectSuccessorBlocks(), ConnectBranch(), ConnectMerge(), ConnectReturn(), FixNode(), and Run().

scheduler_

Scheduler* v8::internal::compiler::CFGBuilder::scheduler_

Definition at line 37 of file scheduler.cc.

Referenced by ConnectBlocks(), FixNode(), Queue(), and Run().

---

The documentation for this class was generated from the following file:

• /mnt/V8SourceCode/src/compiler/scheduler.cc