Lines Matching defs:block
520 bool IsAddedBlock(HBasicBlock* block) const {
521 return block->GetBlockId() >= initial_block_size_;
551 void VisitBasicBlock(HBasicBlock* block) OVERRIDE {
552 DCHECK(!IsAddedBlock(block));
554 HGraphVisitor::VisitBasicBlock(block);
558 AddComparesWithDeoptimization(block);
583 // Return the map of proven value ranges at the beginning of a basic block.
609 // Helper method to assign a new range to an instruction in given basic block.
705 HBasicBlock* block = instruction->GetBlock();
715 ValueRange* left_range = LookupValueRange(left, block);
738 ValueRange* right_range = LookupValueRange(right, block);
766 ApplyRangeFromComparison(left, block, true_successor, new_range);
778 ApplyRangeFromComparison(left, block, false_successor, new_range);
790 ApplyRangeFromComparison(left, block, true_successor, new_range);
801 ApplyRangeFromComparison(left, block, false_successor, new_range);
807 HBasicBlock* block = bounds_check->GetBlock();
822 ValueRange* index_range = LookupValueRange(index, block);
847 ValueRange* existing_range = LookupValueRange(array_length, block);
871 AssignRange(block, array_length, range);
894 // Start with input 1. Input 0 is from the incoming block.
1138 * preheader or, in combination with dynamic bce, the deoptimization block.
1168 void AddCompareWithDeoptimization(HBasicBlock* block,
1186 block->InsertInstructionBefore(lower, bounds_check);
1187 block->InsertInstructionBefore(upper, bounds_check);
1196 void AddComparesWithDeoptimization(HBasicBlock* block) {
1218 // Another bounds check in same or dominated block?
1221 if (user->IsBoundsCheck() && block->Dominates(other_block)) {
1233 // Since a subsequent dominated block could be under a conditional, only accept
1234 // the other bounds check if it is in same block or both blocks dominate the exit.
1238 if (block == user->GetBlock() ||
1239 (block->Dominates(exit) && other_block->Dominates(exit))) {
1268 AddCompareWithDeoptimization(block, array_length, base, min_c, max_c);
1347 HBasicBlock* block = GetPreHeader(loop, instruction);
1348 induction_range_.GenerateRangeCode(instruction, index, GetGraph(), block, &lower, &upper);
1350 InsertDeoptInLoop(loop, block, new (GetGraph()->GetArena()) HAbove(lower, upper));
1352 InsertDeoptInLoop(loop, block, new (GetGraph()->GetArena()) HAboveOrEqual(upper, length));
1362 bool DynamicBCESeemsProfitable(HLoopInformation* loop, HBasicBlock* block) {
1384 // Does the current basic block dominate all back edges? If not,
1386 return loop->DominatesAllBackEdges(block);
1445 HBasicBlock* block = GetPreHeader(loop, check);
1448 InsertDeoptInLoop(loop, block, cond);
1502 // Use preheader unless there is an earlier generated deoptimization block since
1508 HBasicBlock* block = it->second;
1510 // which can be found by following the predecessor of the true-block twice.
1512 return block->GetSinglePredecessor()->GetSinglePredecessor();
1514 return block;
1520 void InsertDeoptInLoop(HLoopInformation* loop, HBasicBlock* block, HInstruction* condition) {
1522 block->InsertInstructionBefore(condition, block->GetLastInstruction());
1525 block->InsertInstructionBefore(deoptimize, block->GetLastInstruction());
1534 HBasicBlock* block = bounds_check->GetBlock();
1535 block->InsertInstructionBefore(condition, bounds_check);
1538 block->InsertInstructionBefore(deoptimize, bounds_check);
1542 /** Hoists instruction out of the loop to preheader or deoptimization block. */
1544 HBasicBlock* block = GetPreHeader(loop, instruction);
1546 instruction->MoveBefore(block->GetLastInstruction());
1556 * if_block <- taken-test protects deoptimization block
1606 // loop isn't entered at all, it jumps around the deoptimization block.
1622 * All uses of instructions in the deoptimization block that reach the loop need
1639 // Scan all instructions in a new deoptimization block.
1710 // A set of maps, one per basic block, from instruction to range.
1714 // in a block that checks an index against that HArrayLength.
1763 // Skip forward to the current block in case new basic blocks were inserted
1765 // same basic block twice.