Lines Matching refs:block
33 bool BasicBlock::LoopContains(BasicBlock* block) const {
36 DCHECK(block->rpo_number_ >= 0);
38 return block->rpo_number_ >= rpo_number_ &&
39 block->rpo_number_ < loop_end_->rpo_number_;
139 BasicBlock* Schedule::block(Node* node) const {
160 BasicBlock* block = this->block(a);
161 return block != nullptr && block == this->block(b);
166 BasicBlock* block = new (zone_)
168 all_blocks_.push_back(block);
169 return block;
173 void Schedule::PlanNode(BasicBlock* block, Node* node) {
177 << " for future add to B" << block->id() << "\n";
179 DCHECK(this->block(node) == nullptr);
180 SetBlockForNode(block, node);
184 void Schedule::AddNode(BasicBlock* block, Node* node) {
188 << block->id() << "\n";
190 DCHECK(this->block(node) == nullptr || this->block(node) == block);
191 block->AddNode(node);
192 SetBlockForNode(block, node);
196 void Schedule::AddGoto(BasicBlock* block, BasicBlock* succ) {
197 DCHECK_EQ(BasicBlock::kNone, block->control());
198 block->set_control(BasicBlock::kGoto);
199 AddSuccessor(block, succ);
220 void Schedule::AddCall(BasicBlock* block, Node* call, BasicBlock* success_block,
222 DCHECK_EQ(BasicBlock::kNone, block->control());
224 block->set_control(BasicBlock::kCall);
225 AddSuccessor(block, success_block);
226 AddSuccessor(block, exception_block);
227 SetControlInput(block, call);
231 void Schedule::AddBranch(BasicBlock* block, Node* branch, BasicBlock* tblock,
233 DCHECK_EQ(BasicBlock::kNone, block->control());
235 block->set_control(BasicBlock::kBranch);
236 AddSuccessor(block, tblock);
237 AddSuccessor(block, fblock);
238 SetControlInput(block, branch);
242 void Schedule::AddSwitch(BasicBlock* block, Node* sw, BasicBlock** succ_blocks,
244 DCHECK_EQ(BasicBlock::kNone, block->control());
246 block->set_control(BasicBlock::kSwitch);
248 AddSuccessor(block, succ_blocks[index]);
250 SetControlInput(block, sw);
254 void Schedule::AddTailCall(BasicBlock* block, Node* input) {
255 DCHECK_EQ(BasicBlock::kNone, block->control());
256 block->set_control(BasicBlock::kTailCall);
257 SetControlInput(block, input);
258 if (block != end()) AddSuccessor(block, end());
262 void Schedule::AddReturn(BasicBlock* block, Node* input) {
263 DCHECK_EQ(BasicBlock::kNone, block->control());
264 block->set_control(BasicBlock::kReturn);
265 SetControlInput(block, input);
266 if (block != end()) AddSuccessor(block, end());
270 void Schedule::AddDeoptimize(BasicBlock* block, Node* input) {
271 DCHECK_EQ(BasicBlock::kNone, block->control());
272 block->set_control(BasicBlock::kDeoptimize);
273 SetControlInput(block, input);
274 if (block != end()) AddSuccessor(block, end());
278 void Schedule::AddThrow(BasicBlock* block, Node* input) {
279 DCHECK_EQ(BasicBlock::kNone, block->control());
280 block->set_control(BasicBlock::kThrow);
281 SetControlInput(block, input);
282 if (block != end()) AddSuccessor(block, end());
286 void Schedule::InsertBranch(BasicBlock* block, BasicBlock* end, Node* branch,
288 DCHECK_NE(BasicBlock::kNone, block->control());
290 end->set_control(block->control());
291 block->set_control(BasicBlock::kBranch);
292 MoveSuccessors(block, end);
293 AddSuccessor(block, tblock);
294 AddSuccessor(block, fblock);
295 if (block->control_input() != nullptr) {
296 SetControlInput(end, block->control_input());
298 SetControlInput(block, branch);
302 void Schedule::InsertSwitch(BasicBlock* block, BasicBlock* end, Node* sw,
304 DCHECK_NE(BasicBlock::kNone, block->control());
306 end->set_control(block->control());
307 block->set_control(BasicBlock::kSwitch);
308 MoveSuccessors(block, end);
310 AddSuccessor(block, succ_blocks[index]);
312 if (block->control_input() != nullptr) {
313 SetControlInput(end, block->control_input());
315 SetControlInput(block, sw);
324 for (auto block : all_blocks_copy) {
325 if (block->PredecessorCount() > 1) {
326 if (block != end_) {
327 EnsureSplitEdgeForm(block);
329 if (block->deferred()) {
330 EnsureDeferredCodeSingleEntryPoint(block);
336 void Schedule::EnsureSplitEdgeForm(BasicBlock* block) {
337 DCHECK(block->PredecessorCount() > 1 && block != end_);
338 for (auto current_pred = block->predecessors().begin();
339 current_pred != block->predecessors().end(); ++current_pred) {
342 // Found a predecessor block with multiple successors.
345 split_edge_block->successors().push_back(block);
347 split_edge_block->set_deferred(block->deferred());
349 // Find a corresponding successor in the previous block, replace it
350 // with the split edge block... but only do it once, since we only
351 // replace the previous blocks in the current block one at a time.
354 if (*successor == block) {
363 void Schedule::EnsureDeferredCodeSingleEntryPoint(BasicBlock* block) {
364 // If a deferred block has multiple predecessors, they have to
366 // that spills only in deferred blocks inserts its spill in the block, but
369 // To ensure that, when a deferred block has multiple predecessors, and some
370 // are not deferred, we add a non-deferred block to collect all such edges.
372 DCHECK(block->deferred() && block->PredecessorCount() > 1);
374 for (auto current_pred = block->predecessors().begin();
375 current_pred != block->predecessors().end(); ++current_pred) {
386 merger->successors().push_back(block);
387 for (auto current_pred = block->predecessors().begin();
388 current_pred != block->predecessors().end(); ++current_pred) {
395 block->predecessors().clear();
396 block->predecessors().push_back(merger);
400 // Push forward the deferred block marks through newly inserted blocks and
406 for (auto block : all_blocks_) {
407 if (!block->deferred()) {
408 bool deferred = block->PredecessorCount() > 0;
409 for (auto pred : block->predecessors()) {
410 if (!pred->deferred() && (pred->rpo_number() < block->rpo_number())) {
415 block->set_deferred(true);
423 void Schedule::AddSuccessor(BasicBlock* block, BasicBlock* succ) {
424 block->AddSuccessor(succ);
425 succ->AddPredecessor(block);
440 void Schedule::SetControlInput(BasicBlock* block, Node* node) {
441 block->set_control_input(node);
442 SetBlockForNode(block, node);
446 void Schedule::SetBlockForNode(BasicBlock* block, Node* node) {
450 nodeid_to_block_[node->id()] = block;
455 for (BasicBlock* block :
457 if (block->rpo_number() == -1) {
458 os << "--- BLOCK id:" << block->id().ToInt();
460 os << "--- BLOCK B" << block->rpo_number();
462 if (block->deferred()) os << " (deferred)";
463 if (block->PredecessorCount() != 0) os << " <- ";
465 for (BasicBlock const* predecessor : block->predecessors()) {
475 for (Node* node : *block) {
484 BasicBlock::Control control = block->control();
487 if (block->control_input() != nullptr) {
488 os << *block->control_input();
494 for (BasicBlock const* successor : block->successors()) {
