Lines Matching refs:block
28 #include "opto/block.hpp"
61 pop(); // shrink list by one block
65 push(b); // grow list by one block
82 // Check for Root block
84 // Check for Start block
117 // Compute the size of first 'inst_cnt' instructions in this block.
118 // Return the number of instructions left to compute if the block has
151 // Find and remove n from block list
157 // Return empty status of a block. Empty blocks contain only the head, other
161 // Root or start block is not considered empty
196 // Return true if the block's code implies that it is likely to be
197 // executed infrequently. Check to see if the block ends in a Halt or
222 // True if block is low enough frequency or guarded by a test which
242 // Check to see if this block follows its guard 1 time out of 10000
265 // The block is uncommon if all preds are uncommon or
281 // Dump the original block's idx
301 // Print the basic block
393 // Build a proper looking CFG. Make every block begin with either a StartNode
394 // or a RegionNode. Make every block end with either a Goto, If or Return.
395 // The RootNode both starts and ends it's own block. Do this with a recursive
409 // only nodes which point to the start of basic block (see below).
417 // Does the block end with a proper block-ending Node? One of Return,
425 if (!visited.test_set(x->_idx)) { // Visit this block once
433 // Make the block begin with one of Region or StartNode.
440 // 'p' now points to the start of this basic block
450 ++sum; // Count 1 for self block
458 // This breaks critical edges. The RegionNode to start the block
463 // Force a block on the control-dependent edge
475 // Find predecessor basic block
480 // Map basic block of projection
484 // Insert self as a child of my predecessor block
495 // Inserts a goto & corresponding basic block between
496 // block[block_no] and its succ_no'th successor block
498 // get block with block_no
499 assert(block_no < _num_blocks, "illegal block number");
501 // get successor block succ_no
504 // Compute frequency of the new block. Do this before inserting
505 // new block in case succ_prob() needs to infer the probability from
508 // get ProjNode corresponding to the succ_no'th successor of the in block
510 // create region for basic block
513 // setup corresponding basic block
514 Block* block = new (_bbs._arena) Block(_bbs._arena, region);
515 _bbs.map(region->_idx, block);
520 // add it to the basic block
521 block->_nodes.push(gto);
522 _bbs.map(gto->_idx, block);
524 // hook up successor block
525 block->_succs.map(block->_num_succs++, out);
530 // remap predecessor's successor to new block
531 in->_succs.map(succ_no, block);
532 // Set the frequency of the new block
533 block->_freq = freq;
534 // add new basic block to basic block list
535 _blocks.insert(block_no + 1, block);
540 // Does this block end in a multiway branch that cannot have the default case
559 // Check for NeverBranch at block end. This needs to become a GOTO to the
589 // Scan through block, yanking dead path from
597 // Helper function to move block bx to the slot following b_index. Return
608 // Find the current index of block bx on the block list
611 assert(_blocks[bx_index] == bx, "block not found");
613 // If the previous block conditionally falls into bx, return false,
624 // Reinsert bx just past block 'b'
636 // Remove the goto, but leave the block.
639 // Mark this block as a connector block, which will cause it to be
643 // Move the empty block to the end, and don't recheck.
649 // Set loop alignment for every block
674 // Check for NeverBranch at block end. This needs to become a GOTO to the
689 b = _blocks[i]; // Find the fall-thru block
693 i--; // backup block counter post-increment
714 // block. If neither arm of a IF follows the conditional branch, we
719 b->_pre_order = i; // turn pre-order into block-index
743 // but it is not the next block => insert a goto
763 // We fall into next block; remove the Goto
769 // Note: Since this basic block has 2 exits, the last 2 nodes must
783 // Check for neither successor block following the current
784 // block ending in a conditional. If so, move one of the
816 // conditional, if needed, so it falls into the following block
817 // and branches to the not-following block.
819 // Check for the next block being in succs[0]. We are going to branch
820 // to succs[0], so we want the fall-thru case as the next block in
835 // Alas, it must appear in its own block and adding a
836 // block this late in the game is complicated. Sigh.
849 // Multi-exit block, e.g. a switch statement
862 // Do not visit this block again
865 // Skip through this block
876 // Dump the block
882 if( _blocks.size() ) { // Did we do basic-block layout?
911 "CreateEx must be first instruction in block");
917 "must have block; constants for debug info ok");
918 // Verify that instructions in the block is in correct order.
919 // Uses must follow their definition if they are at the same block.
943 assert( bp, "last instruction must be a block proj" );
944 assert( bp == b->_nodes[j], "wrong number of successors for this block" );
1146 // If this block and the next one have a one-to-one successor
1147 // predecessor relationship, simply append the next block
1159 // We see a merge point, so stop search for the next block
1163 assert(n = _cfg._blocks[i], "expecting next block");
1334 // But leave root entry at the beginning of the block list.
1346 // jumps at the end of each block.
1362 // The entry block should be first on the new trace list.
1401 // Mapping block index --> block_trace
1428 // Edge e completes a loop in a trace. If the target block is head of the
1429 // loop, rotate the loop block so that the loop ends in a conditional branch.
1438 // Find the last block in the trace that has a conditional