diff options
27 files changed, 302 insertions, 331 deletions
diff --git a/compiler/dex/global_value_numbering_test.cc b/compiler/dex/global_value_numbering_test.cc index c8aa9902c3..f2c2e22d6a 100644 --- a/compiler/dex/global_value_numbering_test.cc +++ b/compiler/dex/global_value_numbering_test.cc @@ -202,7 +202,7 @@ class GlobalValueNumberingTest : public testing::Test { for (size_t j = 0u; j != def->num_successors; ++j) { SuccessorBlockInfo* successor_block_info = static_cast<SuccessorBlockInfo*>(cu_.arena.Alloc(sizeof(SuccessorBlockInfo), - kArenaAllocSuccessor)); + kArenaAllocSuccessors)); successor_block_info->block = j; successor_block_info->key = 0u; // Not used by class init check elimination. bb->successor_blocks.push_back(successor_block_info); @@ -474,7 +474,7 @@ GlobalValueNumberingTestCatch::GlobalValueNumberingTestCatch() BasicBlock* check_bb = cu_.mir_graph->GetBasicBlock(3u); check_bb->successor_block_list_type = kCatch; SuccessorBlockInfo* successor_block_info = reinterpret_cast<SuccessorBlockInfo*> - (cu_.arena.Alloc(sizeof(SuccessorBlockInfo), kArenaAllocSuccessor)); + (cu_.arena.Alloc(sizeof(SuccessorBlockInfo), kArenaAllocSuccessors)); successor_block_info->block = catch_handler->id; check_bb->successor_blocks.push_back(successor_block_info); } @@ -2284,7 +2284,7 @@ TEST_F(GlobalValueNumberingTest, NormalPathToCatchEntry) { BasicBlock* check_bb = cu_.mir_graph->GetBasicBlock(3u); check_bb->successor_block_list_type = kCatch; SuccessorBlockInfo* successor_block_info = reinterpret_cast<SuccessorBlockInfo*> - (cu_.arena.Alloc(sizeof(SuccessorBlockInfo), kArenaAllocSuccessor)); + (cu_.arena.Alloc(sizeof(SuccessorBlockInfo), kArenaAllocSuccessors)); successor_block_info->block = catch_handler->id; check_bb->successor_blocks.push_back(successor_block_info); BasicBlock* merge_block = cu_.mir_graph->GetBasicBlock(4u); diff --git a/compiler/dex/gvn_dead_code_elimination_test.cc b/compiler/dex/gvn_dead_code_elimination_test.cc index 4df0a8b98d..28c61a8fca 100644 --- a/compiler/dex/gvn_dead_code_elimination_test.cc +++ b/compiler/dex/gvn_dead_code_elimination_test.cc @@ -209,7 +209,7 @@ class GvnDeadCodeEliminationTest : public testing::Test { for (size_t j = 0u; j != def->num_successors; ++j) { SuccessorBlockInfo* successor_block_info = static_cast<SuccessorBlockInfo*>(cu_.arena.Alloc(sizeof(SuccessorBlockInfo), - kArenaAllocSuccessor)); + kArenaAllocSuccessors)); successor_block_info->block = j; successor_block_info->key = 0u; // Not used by class init check elimination. bb->successor_blocks.push_back(successor_block_info); diff --git a/compiler/dex/mir_graph.cc b/compiler/dex/mir_graph.cc index 7976a9aea8..4efe4af896 100644 --- a/compiler/dex/mir_graph.cc +++ b/compiler/dex/mir_graph.cc @@ -572,7 +572,7 @@ BasicBlock* MIRGraph::ProcessCanSwitch(BasicBlock* cur_block, MIR* insn, DexOffs DCHECK(case_block != nullptr); SuccessorBlockInfo* successor_block_info = static_cast<SuccessorBlockInfo*>(arena_->Alloc(sizeof(SuccessorBlockInfo), - kArenaAllocSuccessor)); + kArenaAllocSuccessors)); successor_block_info->block = case_block->id; successor_block_info->key = (insn->dalvikInsn.opcode == Instruction::PACKED_SWITCH) ? @@ -627,7 +627,7 @@ BasicBlock* MIRGraph::ProcessCanThrow(BasicBlock* cur_block, MIR* insn, DexOffse catches_.insert(catch_block->start_offset); } SuccessorBlockInfo* successor_block_info = reinterpret_cast<SuccessorBlockInfo*> - (arena_->Alloc(sizeof(SuccessorBlockInfo), kArenaAllocSuccessor)); + (arena_->Alloc(sizeof(SuccessorBlockInfo), kArenaAllocSuccessors)); successor_block_info->block = catch_block->id; successor_block_info->key = iterator.GetHandlerTypeIndex(); cur_block->successor_blocks.push_back(successor_block_info); @@ -2178,7 +2178,7 @@ BasicBlock* BasicBlock::Copy(MIRGraph* mir_graph) { result_bb->successor_blocks.reserve(successor_blocks.size()); for (SuccessorBlockInfo* sbi_old : successor_blocks) { SuccessorBlockInfo* sbi_new = static_cast<SuccessorBlockInfo*>( - arena->Alloc(sizeof(SuccessorBlockInfo), kArenaAllocSuccessor)); + arena->Alloc(sizeof(SuccessorBlockInfo), kArenaAllocSuccessors)); memcpy(sbi_new, sbi_old, sizeof(SuccessorBlockInfo)); result_bb->successor_blocks.push_back(sbi_new); } diff --git a/compiler/dex/mir_graph.h b/compiler/dex/mir_graph.h index 1df6a4f9ce..097abdc018 100644 --- a/compiler/dex/mir_graph.h +++ b/compiler/dex/mir_graph.h @@ -379,7 +379,7 @@ class BasicBlock : public DeletableArenaObject<kArenaAllocBasicBlock> { terminated_by_return(), dominates_return(), use_lvn(), first_mir_insn(), last_mir_insn(), data_flow_info(), dominators(), i_dominated(), dom_frontier(), predecessors(allocator->Adapter(kArenaAllocBBPredecessors)), - successor_blocks(allocator->Adapter(kArenaAllocSuccessor)) { + successor_blocks(allocator->Adapter(kArenaAllocSuccessors)) { } BasicBlockId id; BasicBlockId dfs_id; diff --git a/compiler/dex/mir_graph_test.cc b/compiler/dex/mir_graph_test.cc index 49b7511b42..7858681e00 100644 --- a/compiler/dex/mir_graph_test.cc +++ b/compiler/dex/mir_graph_test.cc @@ -79,7 +79,7 @@ class TopologicalSortOrderTest : public testing::Test { for (size_t j = 0u; j != def->num_successors; ++j) { SuccessorBlockInfo* successor_block_info = static_cast<SuccessorBlockInfo*>(cu_.arena.Alloc(sizeof(SuccessorBlockInfo), - kArenaAllocSuccessor)); + kArenaAllocSuccessors)); successor_block_info->block = j; successor_block_info->key = 0u; // Not used by class init check elimination. bb->successor_blocks.push_back(successor_block_info); diff --git a/compiler/dex/mir_optimization_test.cc b/compiler/dex/mir_optimization_test.cc index 47123ba28c..a0cedff9b8 100644 --- a/compiler/dex/mir_optimization_test.cc +++ b/compiler/dex/mir_optimization_test.cc @@ -118,7 +118,7 @@ class MirOptimizationTest : public testing::Test { for (size_t j = 0u; j != def->num_successors; ++j) { SuccessorBlockInfo* successor_block_info = static_cast<SuccessorBlockInfo*>(cu_.arena.Alloc(sizeof(SuccessorBlockInfo), - kArenaAllocSuccessor)); + kArenaAllocSuccessors)); successor_block_info->block = j; successor_block_info->key = 0u; // Not used by class init check elimination. bb->successor_blocks.push_back(successor_block_info); @@ -244,7 +244,7 @@ class MirOptimizationTest : public testing::Test { BasicBlock* check_bb = cu_.mir_graph->GetBasicBlock(3u); check_bb->successor_block_list_type = kCatch; SuccessorBlockInfo* successor_block_info = reinterpret_cast<SuccessorBlockInfo*> - (cu_.arena.Alloc(sizeof(SuccessorBlockInfo), kArenaAllocSuccessor)); + (cu_.arena.Alloc(sizeof(SuccessorBlockInfo), kArenaAllocSuccessors)); successor_block_info->block = catch_handler->id; check_bb->successor_blocks.push_back(successor_block_info); } diff --git a/compiler/dex/type_inference_test.cc b/compiler/dex/type_inference_test.cc index 872a8d684b..528a18cc99 100644 --- a/compiler/dex/type_inference_test.cc +++ b/compiler/dex/type_inference_test.cc @@ -322,7 +322,7 @@ class TypeInferenceTest : public testing::Test { for (size_t j = 0u; j != def->num_successors; ++j) { SuccessorBlockInfo* successor_block_info = static_cast<SuccessorBlockInfo*>(cu_.arena.Alloc(sizeof(SuccessorBlockInfo), - kArenaAllocSuccessor)); + kArenaAllocSuccessors)); successor_block_info->block = j; successor_block_info->key = 0u; // Not used by class init check elimination. bb->successor_blocks.push_back(successor_block_info); diff --git a/compiler/optimizing/boolean_simplifier.cc b/compiler/optimizing/boolean_simplifier.cc index 84201c39a7..b0e83b0058 100644 --- a/compiler/optimizing/boolean_simplifier.cc +++ b/compiler/optimizing/boolean_simplifier.cc @@ -42,9 +42,9 @@ void HBooleanSimplifier::TryRemovingNegatedCondition(HBasicBlock* block) { // successor and the successor can only be reached from them. static bool BlocksDoMergeTogether(HBasicBlock* block1, HBasicBlock* block2) { if (!block1->IsSingleGoto() || !block2->IsSingleGoto()) return false; - HBasicBlock* succ1 = block1->GetSuccessors().Get(0); - HBasicBlock* succ2 = block2->GetSuccessors().Get(0); - return succ1 == succ2 && succ1->GetPredecessors().Size() == 2u; + HBasicBlock* succ1 = block1->GetSuccessor(0); + HBasicBlock* succ2 = block2->GetSuccessor(0); + return succ1 == succ2 && succ1->GetPredecessors().size() == 2u; } // Returns true if the outcome of the branching matches the boolean value of @@ -108,7 +108,7 @@ void HBooleanSimplifier::TryRemovingBooleanSelection(HBasicBlock* block) { if (!BlocksDoMergeTogether(true_block, false_block)) { return; } - HBasicBlock* merge_block = true_block->GetSuccessors().Get(0); + HBasicBlock* merge_block = true_block->GetSuccessor(0); if (!merge_block->HasSinglePhi()) { return; } diff --git a/compiler/optimizing/bounds_check_elimination.cc b/compiler/optimizing/bounds_check_elimination.cc index ebc0adc64a..70ad408fdf 100644 --- a/compiler/optimizing/bounds_check_elimination.cc +++ b/compiler/optimizing/bounds_check_elimination.cc @@ -275,9 +275,8 @@ class ArrayAccessInsideLoopFinder : public ValueObject { // Loop header of loop_info. Exiting loop is normal. return false; } - const GrowableArray<HBasicBlock*>& successors = block->GetSuccessors(); - for (size_t i = 0; i < successors.Size(); i++) { - if (!loop_info->Contains(*successors.Get(i))) { + for (HBasicBlock* successor : block->GetSuccessors()) { + if (!loop_info->Contains(*successor)) { // One of the successors exits the loop. return true; } @@ -797,8 +796,8 @@ class MonotonicValueRange : public ValueRange { HBasicBlock* new_pre_header = header->GetDominator(); DCHECK(new_pre_header == header->GetLoopInformation()->GetPreHeader()); HBasicBlock* if_block = new_pre_header->GetDominator(); - HBasicBlock* dummy_block = if_block->GetSuccessors().Get(0); // True successor. - HBasicBlock* deopt_block = if_block->GetSuccessors().Get(1); // False successor. + HBasicBlock* dummy_block = if_block->GetSuccessor(0); // True successor. + HBasicBlock* deopt_block = if_block->GetSuccessor(1); // False successor. dummy_block->AddInstruction(new (graph->GetArena()) HGoto()); deopt_block->AddInstruction(new (graph->GetArena()) HGoto()); @@ -845,14 +844,14 @@ class MonotonicValueRange : public ValueRange { DCHECK(header->IsLoopHeader()); HBasicBlock* pre_header = header->GetDominator(); if (loop_entry_test_block_added) { - DCHECK(deopt_block->GetSuccessors().Get(0) == pre_header); + DCHECK(deopt_block->GetSuccessor(0) == pre_header); } else { DCHECK(deopt_block == pre_header); } HGraph* graph = header->GetGraph(); HSuspendCheck* suspend_check = header->GetLoopInformation()->GetSuspendCheck(); if (loop_entry_test_block_added) { - DCHECK_EQ(deopt_block, header->GetDominator()->GetDominator()->GetSuccessors().Get(1)); + DCHECK_EQ(deopt_block, header->GetDominator()->GetDominator()->GetSuccessor(1)); } HIntConstant* const_instr = graph->GetIntConstant(constant); @@ -926,7 +925,7 @@ class MonotonicValueRange : public ValueRange { DCHECK(header->IsLoopHeader()); HBasicBlock* pre_header = header->GetDominator(); if (loop_entry_test_block_added) { - DCHECK(deopt_block->GetSuccessors().Get(0) == pre_header); + DCHECK(deopt_block->GetSuccessor(0) == pre_header); } else { DCHECK(deopt_block == pre_header); } @@ -1256,11 +1255,11 @@ class BCEVisitor : public HGraphVisitor { HBasicBlock* true_successor = instruction->IfTrueSuccessor(); // There should be no critical edge at this point. - DCHECK_EQ(true_successor->GetPredecessors().Size(), 1u); + DCHECK_EQ(true_successor->GetPredecessors().size(), 1u); HBasicBlock* false_successor = instruction->IfFalseSuccessor(); // There should be no critical edge at this point. - DCHECK_EQ(false_successor->GetPredecessors().Size(), 1u); + DCHECK_EQ(false_successor->GetPredecessors().size(), 1u); ValueRange* left_range = LookupValueRange(left, block); MonotonicValueRange* left_monotonic_range = nullptr; @@ -1468,10 +1467,10 @@ class BCEVisitor : public HGraphVisitor { // Start with input 1. Input 0 is from the incoming block. HInstruction* input1 = phi->InputAt(1); DCHECK(phi->GetBlock()->GetLoopInformation()->IsBackEdge( - *phi->GetBlock()->GetPredecessors().Get(1))); + *phi->GetBlock()->GetPredecessor(1))); for (size_t i = 2, e = phi->InputCount(); i < e; ++i) { DCHECK(phi->GetBlock()->GetLoopInformation()->IsBackEdge( - *phi->GetBlock()->GetPredecessors().Get(i))); + *phi->GetBlock()->GetPredecessor(i))); if (input1 != phi->InputAt(i)) { return false; } diff --git a/compiler/optimizing/builder.cc b/compiler/optimizing/builder.cc index 1650fd1ced..7fa16bbc0a 100644 --- a/compiler/optimizing/builder.cc +++ b/compiler/optimizing/builder.cc @@ -396,8 +396,8 @@ void HGraphBuilder::InsertTryBoundaryBlocks(const DexFile::CodeItem& code_item) // Find predecessors which are not covered by the same TryItem range. Such // edges enter the try block and will have a TryBoundary inserted. - for (size_t i = 0; i < try_block->GetPredecessors().Size(); ++i) { - HBasicBlock* predecessor = try_block->GetPredecessors().Get(i); + for (size_t i = 0; i < try_block->GetPredecessors().size(); ++i) { + HBasicBlock* predecessor = try_block->GetPredecessor(i); if (predecessor->IsSingleTryBoundary()) { // The edge was already split because of an exit from a neighbouring // TryItem. We split it again and insert an entry point. @@ -424,8 +424,7 @@ void HGraphBuilder::InsertTryBoundaryBlocks(const DexFile::CodeItem& code_item) // Find successors which are not covered by the same TryItem range. Such // edges exit the try block and will have a TryBoundary inserted. - for (size_t i = 0; i < try_block->GetSuccessors().Size(); ++i) { - HBasicBlock* successor = try_block->GetSuccessors().Get(i); + for (HBasicBlock* successor : try_block->GetSuccessors()) { if (successor->IsCatchBlock()) { // A catch block is always considered an entry point into its TryItem. // We therefore assume this is an exit point, regardless of whether diff --git a/compiler/optimizing/code_generator.cc b/compiler/optimizing/code_generator.cc index a6fc4557f7..f5c4498849 100644 --- a/compiler/optimizing/code_generator.cc +++ b/compiler/optimizing/code_generator.cc @@ -171,7 +171,7 @@ HBasicBlock* CodeGenerator::GetNextBlockToEmit() const { HBasicBlock* CodeGenerator::FirstNonEmptyBlock(HBasicBlock* block) const { while (block->IsSingleJump()) { - block = block->GetSuccessors().Get(0); + block = block->GetSuccessor(0); } return block; } diff --git a/compiler/optimizing/codegen_test.cc b/compiler/optimizing/codegen_test.cc index 4fbb51d43c..72c67f5651 100644 --- a/compiler/optimizing/codegen_test.cc +++ b/compiler/optimizing/codegen_test.cc @@ -561,7 +561,7 @@ TEST(CodegenTest, NonMaterializedCondition) { ASSERT_FALSE(equal->NeedsMaterialization()); auto hook_before_codegen = [](HGraph* graph_in) { - HBasicBlock* block = graph_in->GetEntryBlock()->GetSuccessors().Get(0); + HBasicBlock* block = graph_in->GetEntryBlock()->GetSuccessor(0); HParallelMove* move = new (graph_in->GetArena()) HParallelMove(graph_in->GetArena()); block->InsertInstructionBefore(move, block->GetLastInstruction()); }; @@ -667,7 +667,7 @@ TEST(CodegenTest, MaterializedCondition1) { code_block->AddInstruction(&ret); auto hook_before_codegen = [](HGraph* graph_in) { - HBasicBlock* block = graph_in->GetEntryBlock()->GetSuccessors().Get(0); + HBasicBlock* block = graph_in->GetEntryBlock()->GetSuccessor(0); HParallelMove* move = new (graph_in->GetArena()) HParallelMove(graph_in->GetArena()); block->InsertInstructionBefore(move, block->GetLastInstruction()); }; @@ -733,7 +733,7 @@ TEST(CodegenTest, MaterializedCondition2) { if_false_block->AddInstruction(&ret_ge); auto hook_before_codegen = [](HGraph* graph_in) { - HBasicBlock* block = graph_in->GetEntryBlock()->GetSuccessors().Get(0); + HBasicBlock* block = graph_in->GetEntryBlock()->GetSuccessor(0); HParallelMove* move = new (graph_in->GetArena()) HParallelMove(graph_in->GetArena()); block->InsertInstructionBefore(move, block->GetLastInstruction()); }; diff --git a/compiler/optimizing/dead_code_elimination.cc b/compiler/optimizing/dead_code_elimination.cc index 50cbf5ca77..509478cfad 100644 --- a/compiler/optimizing/dead_code_elimination.cc +++ b/compiler/optimizing/dead_code_elimination.cc @@ -42,8 +42,8 @@ static void MarkReachableBlocks(HBasicBlock* block, ArenaBitVector* visited) { MarkReachableBlocks(if_instruction->IfFalseSuccessor(), visited); } } else { - for (size_t i = 0, e = block->GetSuccessors().Size(); i < e; ++i) { - MarkReachableBlocks(block->GetSuccessors().Get(i), visited); + for (HBasicBlock* successor : block->GetSuccessors()) { + MarkReachableBlocks(successor, visited); } } } @@ -99,12 +99,12 @@ void HDeadCodeElimination::RemoveDeadBlocks() { // Connect successive blocks created by dead branches. Order does not matter. for (HReversePostOrderIterator it(*graph_); !it.Done();) { HBasicBlock* block = it.Current(); - if (block->IsEntryBlock() || block->GetSuccessors().Size() != 1u) { + if (block->IsEntryBlock() || block->GetSuccessors().size() != 1u) { it.Advance(); continue; } - HBasicBlock* successor = block->GetSuccessors().Get(0); - if (successor->IsExitBlock() || successor->GetPredecessors().Size() != 1u) { + HBasicBlock* successor = block->GetSuccessor(0); + if (successor->IsExitBlock() || successor->GetPredecessors().size() != 1u) { it.Advance(); continue; } diff --git a/compiler/optimizing/graph_checker.cc b/compiler/optimizing/graph_checker.cc index 847d5a4e9e..3e358358ae 100644 --- a/compiler/optimizing/graph_checker.cc +++ b/compiler/optimizing/graph_checker.cc @@ -29,19 +29,16 @@ void GraphChecker::VisitBasicBlock(HBasicBlock* block) { current_block_ = block; // Check consistency with respect to predecessors of `block`. - const GrowableArray<HBasicBlock*>& predecessors = block->GetPredecessors(); std::map<HBasicBlock*, size_t> predecessors_count; - for (size_t i = 0, e = predecessors.Size(); i < e; ++i) { - HBasicBlock* p = predecessors.Get(i); + for (HBasicBlock* p : block->GetPredecessors()) { ++predecessors_count[p]; } for (auto& pc : predecessors_count) { HBasicBlock* p = pc.first; size_t p_count_in_block_predecessors = pc.second; - const GrowableArray<HBasicBlock*>& p_successors = p->GetSuccessors(); size_t block_count_in_p_successors = 0; - for (size_t j = 0, f = p_successors.Size(); j < f; ++j) { - if (p_successors.Get(j) == block) { + for (HBasicBlock* p_successor : p->GetSuccessors()) { + if (p_successor == block) { ++block_count_in_p_successors; } } @@ -55,19 +52,16 @@ void GraphChecker::VisitBasicBlock(HBasicBlock* block) { } // Check consistency with respect to successors of `block`. - const GrowableArray<HBasicBlock*>& successors = block->GetSuccessors(); std::map<HBasicBlock*, size_t> successors_count; - for (size_t i = 0, e = successors.Size(); i < e; ++i) { - HBasicBlock* s = successors.Get(i); + for (HBasicBlock* s : block->GetSuccessors()) { ++successors_count[s]; } for (auto& sc : successors_count) { HBasicBlock* s = sc.first; size_t s_count_in_block_successors = sc.second; - const GrowableArray<HBasicBlock*>& s_predecessors = s->GetPredecessors(); size_t block_count_in_s_predecessors = 0; - for (size_t j = 0, f = s_predecessors.Size(); j < f; ++j) { - if (s_predecessors.Get(j) == block) { + for (HBasicBlock* s_predecessor : s->GetPredecessors()) { + if (s_predecessor == block) { ++block_count_in_s_predecessors; } } @@ -92,8 +86,7 @@ void GraphChecker::VisitBasicBlock(HBasicBlock* block) { // Ensure that only Return(Void) and Throw jump to Exit. An exiting // TryBoundary may be between a Throw and the Exit if the Throw is in a try. if (block->IsExitBlock()) { - for (size_t i = 0, e = block->GetPredecessors().Size(); i < e; ++i) { - HBasicBlock* predecessor = block->GetPredecessors().Get(i); + for (HBasicBlock* predecessor : block->GetPredecessors()) { if (predecessor->IsSingleTryBoundary() && !predecessor->GetLastInstruction()->AsTryBoundary()->IsEntry()) { HBasicBlock* real_predecessor = predecessor->GetSinglePredecessor(); @@ -178,8 +171,7 @@ void GraphChecker::VisitTryBoundary(HTryBoundary* try_boundary) { try_boundary->GetId(), handler->GetBlockId())); } - if (current_block_->GetSuccessors().Contains( - handler, /* start_from */ it.CurrentSuccessorIndex() + 1)) { + if (current_block_->HasSuccessor(handler, it.CurrentSuccessorIndex() + 1)) { AddError(StringPrintf("Exception handler block %d of %s:%d is listed multiple times.", handler->GetBlockId(), try_boundary->DebugName(), @@ -359,15 +351,15 @@ void SSAChecker::VisitBasicBlock(HBasicBlock* block) { // never exceptional successors. const size_t num_normal_successors = block->NumberOfNormalSuccessors(); for (size_t j = 0; j < num_normal_successors; ++j) { - HBasicBlock* successor = block->GetSuccessors().Get(j); + HBasicBlock* successor = block->GetSuccessor(j); if (successor->IsCatchBlock()) { AddError(StringPrintf("Catch block %d is a normal successor of block %d.", successor->GetBlockId(), block->GetBlockId())); } } - for (size_t j = num_normal_successors, e = block->GetSuccessors().Size(); j < e; ++j) { - HBasicBlock* successor = block->GetSuccessors().Get(j); + for (size_t j = num_normal_successors, e = block->GetSuccessors().size(); j < e; ++j) { + HBasicBlock* successor = block->GetSuccessor(j); if (!successor->IsCatchBlock()) { AddError(StringPrintf("Normal block %d is an exceptional successor of block %d.", successor->GetBlockId(), @@ -381,8 +373,8 @@ void SSAChecker::VisitBasicBlock(HBasicBlock* block) { // not accounted for. if (block->NumberOfNormalSuccessors() > 1) { for (size_t j = 0, e = block->NumberOfNormalSuccessors(); j < e; ++j) { - HBasicBlock* successor = block->GetSuccessors().Get(j); - if (successor->GetPredecessors().Size() > 1) { + HBasicBlock* successor = block->GetSuccessor(j); + if (successor->GetPredecessors().size() > 1) { AddError(StringPrintf("Critical edge between blocks %d and %d.", block->GetBlockId(), successor->GetBlockId())); @@ -417,8 +409,7 @@ void SSAChecker::VisitBasicBlock(HBasicBlock* block) { block->GetBlockId())); } } else { - for (size_t i = 0; i < block->GetPredecessors().Size(); ++i) { - HBasicBlock* predecessor = block->GetPredecessors().Get(i); + for (HBasicBlock* predecessor : block->GetPredecessors()) { const HTryBoundary* incoming_try_entry = predecessor->ComputeTryEntryOfSuccessors(); if (block->IsTryBlock()) { const HTryBoundary& stored_try_entry = block->GetTryCatchInformation()->GetTryEntry(); @@ -469,21 +460,21 @@ void SSAChecker::CheckLoop(HBasicBlock* loop_header) { // Ensure the loop header has only one incoming branch and the remaining // predecessors are back edges. - size_t num_preds = loop_header->GetPredecessors().Size(); + size_t num_preds = loop_header->GetPredecessors().size(); if (num_preds < 2) { AddError(StringPrintf( "Loop header %d has less than two predecessors: %zu.", id, num_preds)); } else { - HBasicBlock* first_predecessor = loop_header->GetPredecessors().Get(0); + HBasicBlock* first_predecessor = loop_header->GetPredecessor(0); if (loop_information->IsBackEdge(*first_predecessor)) { AddError(StringPrintf( "First predecessor of loop header %d is a back edge.", id)); } - for (size_t i = 1, e = loop_header->GetPredecessors().Size(); i < e; ++i) { - HBasicBlock* predecessor = loop_header->GetPredecessors().Get(i); + for (size_t i = 1, e = loop_header->GetPredecessors().size(); i < e; ++i) { + HBasicBlock* predecessor = loop_header->GetPredecessor(i); if (!loop_information->IsBackEdge(*predecessor)) { AddError(StringPrintf( "Loop header %d has multiple incoming (non back edge) blocks.", @@ -621,20 +612,19 @@ void SSAChecker::VisitPhi(HPhi* phi) { } else { // Ensure the number of inputs of a non-catch phi is the same as the number // of its predecessors. - const GrowableArray<HBasicBlock*>& predecessors = - phi->GetBlock()->GetPredecessors(); - if (phi->InputCount() != predecessors.Size()) { + const ArenaVector<HBasicBlock*>& predecessors = phi->GetBlock()->GetPredecessors(); + if (phi->InputCount() != predecessors.size()) { AddError(StringPrintf( "Phi %d in block %d has %zu inputs, " "but block %d has %zu predecessors.", phi->GetId(), phi->GetBlock()->GetBlockId(), phi->InputCount(), - phi->GetBlock()->GetBlockId(), predecessors.Size())); + phi->GetBlock()->GetBlockId(), predecessors.size())); } else { // Ensure phi input at index I either comes from the Ith // predecessor or from a block that dominates this predecessor. for (size_t i = 0, e = phi->InputCount(); i < e; ++i) { HInstruction* input = phi->InputAt(i); - HBasicBlock* predecessor = predecessors.Get(i); + HBasicBlock* predecessor = predecessors[i]; if (!(input->GetBlock() == predecessor || input->GetBlock()->Dominates(predecessor))) { AddError(StringPrintf( diff --git a/compiler/optimizing/graph_test.cc b/compiler/optimizing/graph_test.cc index 59d50926ad..7968e88117 100644 --- a/compiler/optimizing/graph_test.cc +++ b/compiler/optimizing/graph_test.cc @@ -99,7 +99,7 @@ TEST(GraphTest, IfSuccessorSimpleJoinBlock1) { ASSERT_NE(false_block, return_block); // Ensure the new block branches to the join block. - ASSERT_EQ(false_block->GetSuccessors().Get(0), return_block); + ASSERT_EQ(false_block->GetSuccessor(0), return_block); } // Test that the successors of an if block stay consistent after a SimplifyCFG. @@ -134,7 +134,7 @@ TEST(GraphTest, IfSuccessorSimpleJoinBlock2) { ASSERT_NE(true_block, return_block); // Ensure the new block branches to the join block. - ASSERT_EQ(true_block->GetSuccessors().Get(0), return_block); + ASSERT_EQ(true_block->GetSuccessor(0), return_block); } // Test that the successors of an if block stay consistent after a SimplifyCFG. @@ -163,12 +163,12 @@ TEST(GraphTest, IfSuccessorMultipleBackEdges1) { ASSERT_EQ(if_block->GetLastInstruction()->AsIf()->IfFalseSuccessor(), return_block); // Ensure there is only one back edge. - ASSERT_EQ(if_block->GetPredecessors().Size(), 2u); - ASSERT_EQ(if_block->GetPredecessors().Get(0), entry_block); - ASSERT_NE(if_block->GetPredecessors().Get(1), if_block); + ASSERT_EQ(if_block->GetPredecessors().size(), 2u); + ASSERT_EQ(if_block->GetPredecessor(0), entry_block); + ASSERT_NE(if_block->GetPredecessor(1), if_block); // Ensure the new block is the back edge. - ASSERT_EQ(if_block->GetPredecessors().Get(1), + ASSERT_EQ(if_block->GetPredecessor(1), if_block->GetLastInstruction()->AsIf()->IfTrueSuccessor()); } @@ -198,12 +198,12 @@ TEST(GraphTest, IfSuccessorMultipleBackEdges2) { ASSERT_EQ(if_block->GetLastInstruction()->AsIf()->IfTrueSuccessor(), return_block); // Ensure there is only one back edge. - ASSERT_EQ(if_block->GetPredecessors().Size(), 2u); - ASSERT_EQ(if_block->GetPredecessors().Get(0), entry_block); - ASSERT_NE(if_block->GetPredecessors().Get(1), if_block); + ASSERT_EQ(if_block->GetPredecessors().size(), 2u); + ASSERT_EQ(if_block->GetPredecessor(0), entry_block); + ASSERT_NE(if_block->GetPredecessor(1), if_block); // Ensure the new block is the back edge. - ASSERT_EQ(if_block->GetPredecessors().Get(1), + ASSERT_EQ(if_block->GetPredecessor(1), if_block->GetLastInstruction()->AsIf()->IfFalseSuccessor()); } @@ -238,11 +238,11 @@ TEST(GraphTest, IfSuccessorMultiplePreHeaders1) { ASSERT_EQ(if_instr->IfFalseSuccessor(), return_block); // Ensure there is only one pre header.. - ASSERT_EQ(loop_block->GetPredecessors().Size(), 2u); + ASSERT_EQ(loop_block->GetPredecessors().size(), 2u); // Ensure the new block is the successor of the true block. - ASSERT_EQ(if_instr->IfTrueSuccessor()->GetSuccessors().Size(), 1u); - ASSERT_EQ(if_instr->IfTrueSuccessor()->GetSuccessors().Get(0), + ASSERT_EQ(if_instr->IfTrueSuccessor()->GetSuccessors().size(), 1u); + ASSERT_EQ(if_instr->IfTrueSuccessor()->GetSuccessor(0), loop_block->GetLoopInformation()->GetPreHeader()); } @@ -276,11 +276,11 @@ TEST(GraphTest, IfSuccessorMultiplePreHeaders2) { ASSERT_EQ(if_instr->IfTrueSuccessor(), return_block); // Ensure there is only one pre header.. - ASSERT_EQ(loop_block->GetPredecessors().Size(), 2u); + ASSERT_EQ(loop_block->GetPredecessors().size(), 2u); // Ensure the new block is the successor of the false block. - ASSERT_EQ(if_instr->IfFalseSuccessor()->GetSuccessors().Size(), 1u); - ASSERT_EQ(if_instr->IfFalseSuccessor()->GetSuccessors().Get(0), + ASSERT_EQ(if_instr->IfFalseSuccessor()->GetSuccessors().size(), 1u); + ASSERT_EQ(if_instr->IfFalseSuccessor()->GetSuccessor(0), loop_block->GetLoopInformation()->GetPreHeader()); } diff --git a/compiler/optimizing/graph_visualizer.cc b/compiler/optimizing/graph_visualizer.cc index 069a7a460b..5b8e386fae 100644 --- a/compiler/optimizing/graph_visualizer.cc +++ b/compiler/optimizing/graph_visualizer.cc @@ -240,8 +240,7 @@ class HGraphVisualizerPrinter : public HGraphDelegateVisitor { void PrintPredecessors(HBasicBlock* block) { AddIndent(); output_ << "predecessors"; - for (size_t i = 0, e = block->GetPredecessors().Size(); i < e; ++i) { - HBasicBlock* predecessor = block->GetPredecessors().Get(i); + for (HBasicBlock* predecessor : block->GetPredecessors()) { output_ << " \"B" << predecessor->GetBlockId() << "\" "; } if (block->IsEntryBlock() && (disasm_info_ != nullptr)) { @@ -254,7 +253,7 @@ class HGraphVisualizerPrinter : public HGraphDelegateVisitor { AddIndent(); output_ << "successors"; for (size_t i = 0; i < block->NumberOfNormalSuccessors(); ++i) { - HBasicBlock* successor = block->GetSuccessors().Get(i); + HBasicBlock* successor = block->GetSuccessor(i); output_ << " \"B" << successor->GetBlockId() << "\" "; } output_<< std::endl; @@ -263,8 +262,8 @@ class HGraphVisualizerPrinter : public HGraphDelegateVisitor { void PrintExceptionHandlers(HBasicBlock* block) { AddIndent(); output_ << "xhandlers"; - for (size_t i = block->NumberOfNormalSuccessors(); i < block->GetSuccessors().Size(); ++i) { - HBasicBlock* handler = block->GetSuccessors().Get(i); + for (size_t i = block->NumberOfNormalSuccessors(); i < block->GetSuccessors().size(); ++i) { + HBasicBlock* handler = block->GetSuccessor(i); output_ << " \"B" << handler->GetBlockId() << "\" "; } if (block->IsExitBlock() && diff --git a/compiler/optimizing/gvn.cc b/compiler/optimizing/gvn.cc index 833dfb00a1..5bb4e8e099 100644 --- a/compiler/optimizing/gvn.cc +++ b/compiler/optimizing/gvn.cc @@ -340,8 +340,8 @@ void GlobalValueNumberer::Run() { void GlobalValueNumberer::VisitBasicBlock(HBasicBlock* block) { ValueSet* set = nullptr; - const GrowableArray<HBasicBlock*>& predecessors = block->GetPredecessors(); - if (predecessors.Size() == 0 || predecessors.Get(0)->IsEntryBlock()) { + const ArenaVector<HBasicBlock*>& predecessors = block->GetPredecessors(); + if (predecessors.size() == 0 || predecessors[0]->IsEntryBlock()) { // The entry block should only accumulate constant instructions, and // the builder puts constants only in the entry block. // Therefore, there is no need to propagate the value set to the next block. @@ -349,8 +349,8 @@ void GlobalValueNumberer::VisitBasicBlock(HBasicBlock* block) { } else { HBasicBlock* dominator = block->GetDominator(); ValueSet* dominator_set = sets_.Get(dominator->GetBlockId()); - if (dominator->GetSuccessors().Size() == 1) { - DCHECK_EQ(dominator->GetSuccessors().Get(0), block); + if (dominator->GetSuccessors().size() == 1) { + DCHECK_EQ(dominator->GetSuccessor(0), block); set = dominator_set; } else { // We have to copy if the dominator has other successors, or `block` is not a successor @@ -361,9 +361,9 @@ void GlobalValueNumberer::VisitBasicBlock(HBasicBlock* block) { if (block->IsLoopHeader()) { DCHECK_EQ(block->GetDominator(), block->GetLoopInformation()->GetPreHeader()); set->Kill(side_effects_.GetLoopEffects(block)); - } else if (predecessors.Size() > 1) { - for (size_t i = 0, e = predecessors.Size(); i < e; ++i) { - set->IntersectWith(sets_.Get(predecessors.Get(i)->GetBlockId())); + } else if (predecessors.size() > 1) { + for (HBasicBlock* predecessor : predecessors) { + set->IntersectWith(sets_.Get(predecessor->GetBlockId())); if (set->IsEmpty()) { break; } diff --git a/compiler/optimizing/inliner.cc b/compiler/optimizing/inliner.cc index b5870ae914..bd591f36af 100644 --- a/compiler/optimizing/inliner.cc +++ b/compiler/optimizing/inliner.cc @@ -423,8 +423,8 @@ bool HInliner::TryBuildAndInline(ArtMethod* resolved_method, } bool has_throw_predecessor = false; - for (size_t i = 0, e = exit_block->GetPredecessors().Size(); i < e; ++i) { - if (exit_block->GetPredecessors().Get(i)->GetLastInstruction()->IsThrow()) { + for (HBasicBlock* predecessor : exit_block->GetPredecessors()) { + if (predecessor->GetLastInstruction()->IsThrow()) { has_throw_predecessor = true; break; } diff --git a/compiler/optimizing/nodes.cc b/compiler/optimizing/nodes.cc index 4332d7ed02..62a460afa0 100644 --- a/compiler/optimizing/nodes.cc +++ b/compiler/optimizing/nodes.cc @@ -68,8 +68,8 @@ void HGraph::RemoveDeadBlocks(const ArenaBitVector& visited) { if (!visited.IsBitSet(i)) { HBasicBlock* block = blocks_.Get(i); // We only need to update the successor, which might be live. - for (size_t j = 0; j < block->GetSuccessors().Size(); ++j) { - block->GetSuccessors().Get(j)->RemovePredecessor(block); + for (HBasicBlock* successor : block->GetSuccessors()) { + successor->RemovePredecessor(block); } // Remove the block from the list of blocks, so that further analyses // never see it. @@ -86,8 +86,7 @@ void HGraph::VisitBlockForBackEdges(HBasicBlock* block, visited->SetBit(id); visiting->SetBit(id); - for (size_t i = 0; i < block->GetSuccessors().Size(); i++) { - HBasicBlock* successor = block->GetSuccessors().Get(i); + for (HBasicBlock* successor : block->GetSuccessors()) { if (visiting->IsBitSet(successor->GetBlockId())) { successor->AddBackEdge(block); } else { @@ -134,7 +133,7 @@ void HGraph::ClearDominanceInformation() { } void HBasicBlock::ClearDominanceInformation() { - dominated_blocks_.Reset(); + dominated_blocks_.clear(); dominator_ = nullptr; } @@ -143,8 +142,8 @@ void HGraph::ComputeDominanceInformation() { GrowableArray<size_t> visits(arena_, blocks_.Size()); visits.SetSize(blocks_.Size()); reverse_post_order_.Add(entry_block_); - for (size_t i = 0; i < entry_block_->GetSuccessors().Size(); i++) { - VisitBlockForDominatorTree(entry_block_->GetSuccessors().Get(i), entry_block_, &visits); + for (HBasicBlock* successor : entry_block_->GetSuccessors()) { + VisitBlockForDominatorTree(successor, entry_block_, &visits); } } @@ -179,11 +178,11 @@ void HGraph::VisitBlockForDominatorTree(HBasicBlock* block, // Once all the forward edges have been visited, we know the immediate // dominator of the block. We can then start visiting its successors. if (visits->Get(block->GetBlockId()) == - block->GetPredecessors().Size() - block->NumberOfBackEdges()) { + block->GetPredecessors().size() - block->NumberOfBackEdges()) { block->GetDominator()->AddDominatedBlock(block); reverse_post_order_.Add(block); - for (size_t i = 0; i < block->GetSuccessors().Size(); i++) { - VisitBlockForDominatorTree(block->GetSuccessors().Get(i), block, visits); + for (HBasicBlock* successor : block->GetSuccessors()) { + VisitBlockForDominatorTree(successor, block, visits); } } } @@ -224,14 +223,14 @@ void HGraph::SimplifyLoop(HBasicBlock* header) { // Make sure the loop has only one pre header. This simplifies SSA building by having // to just look at the pre header to know which locals are initialized at entry of the // loop. - size_t number_of_incomings = header->GetPredecessors().Size() - info->NumberOfBackEdges(); + size_t number_of_incomings = header->GetPredecessors().size() - info->NumberOfBackEdges(); if (number_of_incomings != 1) { HBasicBlock* pre_header = new (arena_) HBasicBlock(this, header->GetDexPc()); AddBlock(pre_header); pre_header->AddInstruction(new (arena_) HGoto()); - for (size_t pred = 0; pred < header->GetPredecessors().Size(); ++pred) { - HBasicBlock* predecessor = header->GetPredecessors().Get(pred); + for (size_t pred = 0; pred < header->GetPredecessors().size(); ++pred) { + HBasicBlock* predecessor = header->GetPredecessor(pred); if (!info->IsBackEdge(*predecessor)) { predecessor->ReplaceSuccessor(header, pre_header); pred--; @@ -241,13 +240,13 @@ void HGraph::SimplifyLoop(HBasicBlock* header) { } // Make sure the first predecessor of a loop header is the incoming block. - if (info->IsBackEdge(*header->GetPredecessors().Get(0))) { - HBasicBlock* to_swap = header->GetPredecessors().Get(0); - for (size_t pred = 1, e = header->GetPredecessors().Size(); pred < e; ++pred) { - HBasicBlock* predecessor = header->GetPredecessors().Get(pred); + if (info->IsBackEdge(*header->GetPredecessor(0))) { + HBasicBlock* to_swap = header->GetPredecessor(0); + for (size_t pred = 1, e = header->GetPredecessors().size(); pred < e; ++pred) { + HBasicBlock* predecessor = header->GetPredecessor(pred); if (!info->IsBackEdge(*predecessor)) { - header->predecessors_.Put(pred, to_swap); - header->predecessors_.Put(0, predecessor); + header->predecessors_[pred] = to_swap; + header->predecessors_[0] = predecessor; break; } } @@ -267,7 +266,7 @@ void HGraph::SimplifyLoop(HBasicBlock* header) { } static bool CheckIfPredecessorAtIsExceptional(const HBasicBlock& block, size_t pred_idx) { - HBasicBlock* predecessor = block.GetPredecessors().Get(pred_idx); + HBasicBlock* predecessor = block.GetPredecessor(pred_idx); if (!predecessor->EndsWithTryBoundary()) { // Only edges from HTryBoundary can be exceptional. return false; @@ -296,7 +295,7 @@ void HGraph::SimplifyCatchBlocks() { } bool exceptional_predecessors_only = true; - for (size_t j = 0; j < catch_block->GetPredecessors().Size(); ++j) { + for (size_t j = 0; j < catch_block->GetPredecessors().size(); ++j) { if (!CheckIfPredecessorAtIsExceptional(*catch_block, j)) { exceptional_predecessors_only = false; break; @@ -313,9 +312,9 @@ void HGraph::SimplifyCatchBlocks() { // a MOVE_EXCEPTION instruction, as guaranteed by the verifier. DCHECK(!catch_block->GetFirstInstruction()->IsLoadException()); HBasicBlock* normal_block = catch_block->SplitBefore(catch_block->GetFirstInstruction()); - for (size_t j = 0; j < catch_block->GetPredecessors().Size(); ++j) { + for (size_t j = 0; j < catch_block->GetPredecessors().size(); ++j) { if (!CheckIfPredecessorAtIsExceptional(*catch_block, j)) { - catch_block->GetPredecessors().Get(j)->ReplaceSuccessor(catch_block, normal_block); + catch_block->GetPredecessor(j)->ReplaceSuccessor(catch_block, normal_block); --j; } } @@ -337,7 +336,7 @@ void HGraph::ComputeTryBlockInformation() { // Infer try membership from the first predecessor. Having simplified loops, // the first predecessor can never be a back edge and therefore it must have // been visited already and had its try membership set. - HBasicBlock* first_predecessor = block->GetPredecessors().Get(0); + HBasicBlock* first_predecessor = block->GetPredecessor(0); DCHECK(!block->IsLoopHeader() || !block->GetLoopInformation()->IsBackEdge(*first_predecessor)); const HTryBoundary* try_entry = first_predecessor->ComputeTryEntryOfSuccessors(); if (try_entry != nullptr) { @@ -364,10 +363,10 @@ void HGraph::SimplifyCFG() { HBasicBlock* block = blocks_.Get(i); if (block == nullptr) continue; if (block->NumberOfNormalSuccessors() > 1) { - for (size_t j = 0; j < block->GetSuccessors().Size(); ++j) { - HBasicBlock* successor = block->GetSuccessors().Get(j); + for (size_t j = 0; j < block->GetSuccessors().size(); ++j) { + HBasicBlock* successor = block->GetSuccessor(j); DCHECK(!successor->IsCatchBlock()); - if (successor->GetPredecessors().Size() > 1) { + if (successor->GetPredecessors().size() > 1) { SplitCriticalEdge(block, successor); --j; } @@ -485,8 +484,8 @@ void HLoopInformation::PopulateRecursive(HBasicBlock* block) { blocks_.SetBit(block->GetBlockId()); block->SetInLoop(this); - for (size_t i = 0, e = block->GetPredecessors().Size(); i < e; ++i) { - PopulateRecursive(block->GetPredecessors().Get(i)); + for (HBasicBlock* predecessor : block->GetPredecessors()) { + PopulateRecursive(predecessor); } } @@ -1136,12 +1135,11 @@ HBasicBlock* HBasicBlock::SplitBefore(HInstruction* cursor) { new_block->instructions_.SetBlockOfInstructions(new_block); AddInstruction(new (GetGraph()->GetArena()) HGoto()); - for (size_t i = 0, e = GetSuccessors().Size(); i < e; ++i) { - HBasicBlock* successor = GetSuccessors().Get(i); - new_block->successors_.Add(successor); - successor->predecessors_.Put(successor->GetPredecessorIndexOf(this), new_block); + for (HBasicBlock* successor : GetSuccessors()) { + new_block->successors_.push_back(successor); + successor->predecessors_[successor->GetPredecessorIndexOf(this)] = new_block; } - successors_.Reset(); + successors_.clear(); AddSuccessor(new_block); GetGraph()->AddBlock(new_block); @@ -1161,19 +1159,17 @@ HBasicBlock* HBasicBlock::SplitAfter(HInstruction* cursor) { instructions_.last_instruction_ = cursor; new_block->instructions_.SetBlockOfInstructions(new_block); - for (size_t i = 0, e = GetSuccessors().Size(); i < e; ++i) { - HBasicBlock* successor = GetSuccessors().Get(i); - new_block->successors_.Add(successor); - successor->predecessors_.Put(successor->GetPredecessorIndexOf(this), new_block); + for (HBasicBlock* successor : GetSuccessors()) { + new_block->successors_.push_back(successor); + successor->predecessors_[successor->GetPredecessorIndexOf(this)] = new_block; } - successors_.Reset(); + successors_.clear(); - for (size_t i = 0, e = GetDominatedBlocks().Size(); i < e; ++i) { - HBasicBlock* dominated = GetDominatedBlocks().Get(i); + for (HBasicBlock* dominated : GetDominatedBlocks()) { dominated->dominator_ = new_block; - new_block->dominated_blocks_.Add(dominated); + new_block->dominated_blocks_.push_back(dominated); } - dominated_blocks_.Reset(); + dominated_blocks_.clear(); return new_block; } @@ -1226,7 +1222,7 @@ bool HBasicBlock::HasSinglePhi() const { } bool HTryBoundary::HasSameExceptionHandlersAs(const HTryBoundary& other) const { - if (GetBlock()->GetSuccessors().Size() != other.GetBlock()->GetSuccessors().Size()) { + if (GetBlock()->GetSuccessors().size() != other.GetBlock()->GetSuccessors().size()) { return false; } @@ -1286,7 +1282,7 @@ void HBasicBlock::DisconnectAndDelete() { // Dominators must be removed after all the blocks they dominate. This way // a loop header is removed last, a requirement for correct loop information // iteration. - DCHECK(dominated_blocks_.IsEmpty()); + DCHECK(dominated_blocks_.empty()); // Remove the block from all loops it is included in. for (HLoopInformationOutwardIterator it(*this); !it.Done(); it.Advance()) { @@ -1302,36 +1298,34 @@ void HBasicBlock::DisconnectAndDelete() { // Disconnect the block from its predecessors and update their control-flow // instructions. - for (size_t i = 0, e = predecessors_.Size(); i < e; ++i) { - HBasicBlock* predecessor = predecessors_.Get(i); + for (HBasicBlock* predecessor : predecessors_) { HInstruction* last_instruction = predecessor->GetLastInstruction(); predecessor->RemoveInstruction(last_instruction); predecessor->RemoveSuccessor(this); - if (predecessor->GetSuccessors().Size() == 1u) { + if (predecessor->GetSuccessors().size() == 1u) { DCHECK(last_instruction->IsIf()); predecessor->AddInstruction(new (graph_->GetArena()) HGoto()); } else { // The predecessor has no remaining successors and therefore must be dead. // We deliberately leave it without a control-flow instruction so that the // SSAChecker fails unless it is not removed during the pass too. - DCHECK_EQ(predecessor->GetSuccessors().Size(), 0u); + DCHECK_EQ(predecessor->GetSuccessors().size(), 0u); } } - predecessors_.Reset(); + predecessors_.clear(); // Disconnect the block from its successors and update their phis. - for (size_t i = 0, e = successors_.Size(); i < e; ++i) { - HBasicBlock* successor = successors_.Get(i); + for (HBasicBlock* successor : successors_) { // Delete this block from the list of predecessors. size_t this_index = successor->GetPredecessorIndexOf(this); - successor->predecessors_.DeleteAt(this_index); + successor->predecessors_.erase(successor->predecessors_.begin() + this_index); // Check that `successor` has other predecessors, otherwise `this` is the // dominator of `successor` which violates the order DCHECKed at the top. - DCHECK(!successor->predecessors_.IsEmpty()); + DCHECK(!successor->predecessors_.empty()); // Remove this block's entries in the successor's phis. - if (successor->predecessors_.Size() == 1u) { + if (successor->predecessors_.size() == 1u) { // The successor has just one predecessor left. Replace phis with the only // remaining input. for (HInstructionIterator phi_it(successor->GetPhis()); !phi_it.Done(); phi_it.Advance()) { @@ -1345,7 +1339,7 @@ void HBasicBlock::DisconnectAndDelete() { } } } - successors_.Reset(); + successors_.clear(); // Disconnect from the dominator. dominator_->RemoveDominatedBlock(this); @@ -1359,11 +1353,9 @@ void HBasicBlock::DisconnectAndDelete() { void HBasicBlock::MergeWith(HBasicBlock* other) { DCHECK_EQ(GetGraph(), other->GetGraph()); - DCHECK(GetDominatedBlocks().Contains(other)); - DCHECK_EQ(GetSuccessors().Size(), 1u); - DCHECK_EQ(GetSuccessors().Get(0), other); - DCHECK_EQ(other->GetPredecessors().Size(), 1u); - DCHECK_EQ(other->GetPredecessors().Get(0), this); + DCHECK(ContainsElement(dominated_blocks_, other)); + DCHECK_EQ(GetSingleSuccessor(), other); + DCHECK_EQ(other->GetSinglePredecessor(), this); DCHECK(other->GetPhis().IsEmpty()); // Move instructions from `other` to `this`. @@ -1383,24 +1375,23 @@ void HBasicBlock::MergeWith(HBasicBlock* other) { } // Update links to the successors of `other`. - successors_.Reset(); - while (!other->successors_.IsEmpty()) { - HBasicBlock* successor = other->successors_.Get(0); + successors_.clear(); + while (!other->successors_.empty()) { + HBasicBlock* successor = other->GetSuccessor(0); successor->ReplacePredecessor(other, this); } // Update the dominator tree. - dominated_blocks_.Delete(other); - for (size_t i = 0, e = other->GetDominatedBlocks().Size(); i < e; ++i) { - HBasicBlock* dominated = other->GetDominatedBlocks().Get(i); - dominated_blocks_.Add(dominated); + RemoveDominatedBlock(other); + for (HBasicBlock* dominated : other->GetDominatedBlocks()) { + dominated_blocks_.push_back(dominated); dominated->SetDominator(this); } - other->dominated_blocks_.Reset(); + other->dominated_blocks_.clear(); other->dominator_ = nullptr; // Clear the list of predecessors of `other` in preparation of deleting it. - other->predecessors_.Reset(); + other->predecessors_.clear(); // Delete `other` from the graph. The function updates reverse post order. graph_->DeleteDeadBlock(other); @@ -1409,11 +1400,10 @@ void HBasicBlock::MergeWith(HBasicBlock* other) { void HBasicBlock::MergeWithInlined(HBasicBlock* other) { DCHECK_NE(GetGraph(), other->GetGraph()); - DCHECK(GetDominatedBlocks().IsEmpty()); - DCHECK(GetSuccessors().IsEmpty()); + DCHECK(GetDominatedBlocks().empty()); + DCHECK(GetSuccessors().empty()); DCHECK(!EndsWithControlFlowInstruction()); - DCHECK_EQ(other->GetPredecessors().Size(), 1u); - DCHECK(other->GetPredecessors().Get(0)->IsEntryBlock()); + DCHECK(other->GetSinglePredecessor()->IsEntryBlock()); DCHECK(other->GetPhis().IsEmpty()); DCHECK(!other->IsInLoop()); @@ -1422,34 +1412,33 @@ void HBasicBlock::MergeWithInlined(HBasicBlock* other) { other->instructions_.SetBlockOfInstructions(this); // Update links to the successors of `other`. - successors_.Reset(); - while (!other->successors_.IsEmpty()) { - HBasicBlock* successor = other->successors_.Get(0); + successors_.clear(); + while (!other->successors_.empty()) { + HBasicBlock* successor = other->GetSuccessor(0); successor->ReplacePredecessor(other, this); } // Update the dominator tree. - for (size_t i = 0, e = other->GetDominatedBlocks().Size(); i < e; ++i) { - HBasicBlock* dominated = other->GetDominatedBlocks().Get(i); - dominated_blocks_.Add(dominated); + for (HBasicBlock* dominated : other->GetDominatedBlocks()) { + dominated_blocks_.push_back(dominated); dominated->SetDominator(this); } - other->dominated_blocks_.Reset(); + other->dominated_blocks_.clear(); other->dominator_ = nullptr; other->graph_ = nullptr; } void HBasicBlock::ReplaceWith(HBasicBlock* other) { - while (!GetPredecessors().IsEmpty()) { - HBasicBlock* predecessor = GetPredecessors().Get(0); + while (!GetPredecessors().empty()) { + HBasicBlock* predecessor = GetPredecessor(0); predecessor->ReplaceSuccessor(this, other); } - while (!GetSuccessors().IsEmpty()) { - HBasicBlock* successor = GetSuccessors().Get(0); + while (!GetSuccessors().empty()) { + HBasicBlock* successor = GetSuccessor(0); successor->ReplacePredecessor(this, other); } - for (size_t i = 0; i < dominated_blocks_.Size(); ++i) { - other->AddDominatedBlock(dominated_blocks_.Get(i)); + for (HBasicBlock* dominated : GetDominatedBlocks()) { + other->AddDominatedBlock(dominated); } GetDominator()->ReplaceDominatedBlock(this, other); other->SetDominator(GetDominator()); @@ -1472,9 +1461,9 @@ static void MakeRoomFor(GrowableArray<HBasicBlock*>* blocks, void HGraph::DeleteDeadBlock(HBasicBlock* block) { DCHECK_EQ(block->GetGraph(), this); - DCHECK(block->GetSuccessors().IsEmpty()); - DCHECK(block->GetPredecessors().IsEmpty()); - DCHECK(block->GetDominatedBlocks().IsEmpty()); + DCHECK(block->GetSuccessors().empty()); + DCHECK(block->GetPredecessors().empty()); + DCHECK(block->GetDominatedBlocks().empty()); DCHECK(block->GetDominator() == nullptr); for (HBackwardInstructionIterator it(block->GetInstructions()); !it.Done(); it.Advance()) { @@ -1548,16 +1537,16 @@ HInstruction* HGraph::InlineInto(HGraph* outer_graph, HInvoke* invoke) { HBasicBlock* at = invoke->GetBlock(); HBasicBlock* to = at->SplitAfter(invoke); - HBasicBlock* first = entry_block_->GetSuccessors().Get(0); + HBasicBlock* first = entry_block_->GetSuccessor(0); DCHECK(!first->IsInLoop()); at->MergeWithInlined(first); exit_block_->ReplaceWith(to); // Update all predecessors of the exit block (now the `to` block) // to not `HReturn` but `HGoto` instead. - bool returns_void = to->GetPredecessors().Get(0)->GetLastInstruction()->IsReturnVoid(); - if (to->GetPredecessors().Size() == 1) { - HBasicBlock* predecessor = to->GetPredecessors().Get(0); + bool returns_void = to->GetPredecessor(0)->GetLastInstruction()->IsReturnVoid(); + if (to->GetPredecessors().size() == 1) { + HBasicBlock* predecessor = to->GetPredecessor(0); HInstruction* last = predecessor->GetLastInstruction(); if (!returns_void) { return_value = last->InputAt(0); @@ -1571,8 +1560,7 @@ HInstruction* HGraph::InlineInto(HGraph* outer_graph, HInvoke* invoke) { allocator, kNoRegNumber, 0, HPhi::ToPhiType(invoke->GetType())); to->AddPhi(return_value->AsPhi()); } - for (size_t i = 0, e = to->GetPredecessors().Size(); i < e; ++i) { - HBasicBlock* predecessor = to->GetPredecessors().Get(i); + for (HBasicBlock* predecessor : to->GetPredecessors()) { HInstruction* last = predecessor->GetLastInstruction(); if (!returns_void) { return_value->AsPhi()->AddInput(last->InputAt(0)); @@ -1720,8 +1708,8 @@ void HGraph::TransformLoopHeaderForBCE(HBasicBlock* header) { AddBlock(new_pre_header); header->ReplacePredecessor(pre_header, new_pre_header); - pre_header->successors_.Reset(); - pre_header->dominated_blocks_.Reset(); + pre_header->successors_.clear(); + pre_header->dominated_blocks_.clear(); pre_header->AddSuccessor(if_block); if_block->AddSuccessor(dummy_block); // True successor @@ -1729,15 +1717,15 @@ void HGraph::TransformLoopHeaderForBCE(HBasicBlock* header) { dummy_block->AddSuccessor(new_pre_header); deopt_block->AddSuccessor(new_pre_header); - pre_header->dominated_blocks_.Add(if_block); + pre_header->dominated_blocks_.push_back(if_block); if_block->SetDominator(pre_header); - if_block->dominated_blocks_.Add(dummy_block); + if_block->dominated_blocks_.push_back(dummy_block); dummy_block->SetDominator(if_block); - if_block->dominated_blocks_.Add(deopt_block); + if_block->dominated_blocks_.push_back(deopt_block); deopt_block->SetDominator(if_block); - if_block->dominated_blocks_.Add(new_pre_header); + if_block->dominated_blocks_.push_back(new_pre_header); new_pre_header->SetDominator(if_block); - new_pre_header->dominated_blocks_.Add(header); + new_pre_header->dominated_blocks_.push_back(header); header->SetDominator(new_pre_header); size_t index_of_header = 0; diff --git a/compiler/optimizing/nodes.h b/compiler/optimizing/nodes.h index fef6f21b46..06a65e3219 100644 --- a/compiler/optimizing/nodes.h +++ b/compiler/optimizing/nodes.h @@ -17,11 +17,13 @@ #ifndef ART_COMPILER_OPTIMIZING_NODES_H_ #define ART_COMPILER_OPTIMIZING_NODES_H_ +#include <algorithm> #include <array> #include <type_traits> #include "base/arena_containers.h" #include "base/arena_object.h" +#include "base/stl_util.h" #include "dex/compiler_enums.h" #include "entrypoints/quick/quick_entrypoints_enum.h" #include "handle.h" @@ -628,26 +630,44 @@ class HBasicBlock : public ArenaObject<kArenaAllocBasicBlock> { public: explicit HBasicBlock(HGraph* graph, uint32_t dex_pc = kNoDexPc) : graph_(graph), - predecessors_(graph->GetArena(), kDefaultNumberOfPredecessors), - successors_(graph->GetArena(), kDefaultNumberOfSuccessors), + predecessors_(graph->GetArena()->Adapter(kArenaAllocPredecessors)), + successors_(graph->GetArena()->Adapter(kArenaAllocSuccessors)), loop_information_(nullptr), dominator_(nullptr), - dominated_blocks_(graph->GetArena(), kDefaultNumberOfDominatedBlocks), + dominated_blocks_(graph->GetArena()->Adapter(kArenaAllocDominated)), block_id_(-1), dex_pc_(dex_pc), lifetime_start_(kNoLifetime), lifetime_end_(kNoLifetime), - try_catch_information_(nullptr) {} + try_catch_information_(nullptr) { + predecessors_.reserve(kDefaultNumberOfPredecessors); + successors_.reserve(kDefaultNumberOfSuccessors); + dominated_blocks_.reserve(kDefaultNumberOfDominatedBlocks); + } - const GrowableArray<HBasicBlock*>& GetPredecessors() const { + const ArenaVector<HBasicBlock*>& GetPredecessors() const { return predecessors_; } - const GrowableArray<HBasicBlock*>& GetSuccessors() const { + HBasicBlock* GetPredecessor(size_t pred_idx) const { + DCHECK_LT(pred_idx, predecessors_.size()); + return predecessors_[pred_idx]; + } + + const ArenaVector<HBasicBlock*>& GetSuccessors() const { return successors_; } - const GrowableArray<HBasicBlock*>& GetDominatedBlocks() const { + HBasicBlock* GetSuccessor(size_t succ_idx) const { + DCHECK_LT(succ_idx, successors_.size()); + return successors_[succ_idx]; + } + + bool HasSuccessor(const HBasicBlock* block, size_t start_from = 0u) { + return ContainsElement(successors_, block, start_from); + } + + const ArenaVector<HBasicBlock*>& GetDominatedBlocks() const { return dominated_blocks_; } @@ -686,18 +706,16 @@ class HBasicBlock : public ArenaObject<kArenaAllocBasicBlock> { HBasicBlock* GetDominator() const { return dominator_; } void SetDominator(HBasicBlock* dominator) { dominator_ = dominator; } - void AddDominatedBlock(HBasicBlock* block) { dominated_blocks_.Add(block); } - void RemoveDominatedBlock(HBasicBlock* block) { dominated_blocks_.Delete(block); } + void AddDominatedBlock(HBasicBlock* block) { dominated_blocks_.push_back(block); } + + void RemoveDominatedBlock(HBasicBlock* block) { + RemoveElement(dominated_blocks_, block); + } + void ReplaceDominatedBlock(HBasicBlock* existing, HBasicBlock* new_block) { - for (size_t i = 0, e = dominated_blocks_.Size(); i < e; ++i) { - if (dominated_blocks_.Get(i) == existing) { - dominated_blocks_.Put(i, new_block); - return; - } - } - LOG(FATAL) << "Unreachable"; - UNREACHABLE(); + ReplaceElement(dominated_blocks_, existing, new_block); } + void ClearDominanceInformation(); int NumberOfBackEdges() const { @@ -712,24 +730,22 @@ class HBasicBlock : public ArenaObject<kArenaAllocBasicBlock> { const HInstructionList& GetPhis() const { return phis_; } void AddSuccessor(HBasicBlock* block) { - successors_.Add(block); - block->predecessors_.Add(this); + successors_.push_back(block); + block->predecessors_.push_back(this); } void ReplaceSuccessor(HBasicBlock* existing, HBasicBlock* new_block) { size_t successor_index = GetSuccessorIndexOf(existing); - DCHECK_NE(successor_index, static_cast<size_t>(-1)); existing->RemovePredecessor(this); - new_block->predecessors_.Add(this); - successors_.Put(successor_index, new_block); + new_block->predecessors_.push_back(this); + successors_[successor_index] = new_block; } void ReplacePredecessor(HBasicBlock* existing, HBasicBlock* new_block) { size_t predecessor_index = GetPredecessorIndexOf(existing); - DCHECK_NE(predecessor_index, static_cast<size_t>(-1)); existing->RemoveSuccessor(this); - new_block->successors_.Add(this); - predecessors_.Put(predecessor_index, new_block); + new_block->successors_.push_back(this); + predecessors_[predecessor_index] = new_block; } // Insert `this` between `predecessor` and `successor. This method @@ -737,85 +753,69 @@ class HBasicBlock : public ArenaObject<kArenaAllocBasicBlock> { // `predecessor` and `successor`. void InsertBetween(HBasicBlock* predecessor, HBasicBlock* successor) { size_t predecessor_index = successor->GetPredecessorIndexOf(predecessor); - DCHECK_NE(predecessor_index, static_cast<size_t>(-1)); size_t successor_index = predecessor->GetSuccessorIndexOf(successor); - DCHECK_NE(successor_index, static_cast<size_t>(-1)); - successor->predecessors_.Put(predecessor_index, this); - predecessor->successors_.Put(successor_index, this); - successors_.Add(successor); - predecessors_.Add(predecessor); + successor->predecessors_[predecessor_index] = this; + predecessor->successors_[successor_index] = this; + successors_.push_back(successor); + predecessors_.push_back(predecessor); } void RemovePredecessor(HBasicBlock* block) { - predecessors_.Delete(block); + predecessors_.erase(predecessors_.begin() + GetPredecessorIndexOf(block)); } void RemoveSuccessor(HBasicBlock* block) { - successors_.Delete(block); + successors_.erase(successors_.begin() + GetSuccessorIndexOf(block)); } void ClearAllPredecessors() { - predecessors_.Reset(); + predecessors_.clear(); } void AddPredecessor(HBasicBlock* block) { - predecessors_.Add(block); - block->successors_.Add(this); + predecessors_.push_back(block); + block->successors_.push_back(this); } void SwapPredecessors() { - DCHECK_EQ(predecessors_.Size(), 2u); - HBasicBlock* temp = predecessors_.Get(0); - predecessors_.Put(0, predecessors_.Get(1)); - predecessors_.Put(1, temp); + DCHECK_EQ(predecessors_.size(), 2u); + std::swap(predecessors_[0], predecessors_[1]); } void SwapSuccessors() { - DCHECK_EQ(successors_.Size(), 2u); - HBasicBlock* temp = successors_.Get(0); - successors_.Put(0, successors_.Get(1)); - successors_.Put(1, temp); + DCHECK_EQ(successors_.size(), 2u); + std::swap(successors_[0], successors_[1]); } size_t GetPredecessorIndexOf(HBasicBlock* predecessor) const { - for (size_t i = 0, e = predecessors_.Size(); i < e; ++i) { - if (predecessors_.Get(i) == predecessor) { - return i; - } - } - return -1; + return IndexOfElement(predecessors_, predecessor); } size_t GetSuccessorIndexOf(HBasicBlock* successor) const { - for (size_t i = 0, e = successors_.Size(); i < e; ++i) { - if (successors_.Get(i) == successor) { - return i; - } - } - return -1; + return IndexOfElement(successors_, successor); } HBasicBlock* GetSinglePredecessor() const { - DCHECK_EQ(GetPredecessors().Size(), 1u); - return GetPredecessors().Get(0); + DCHECK_EQ(GetPredecessors().size(), 1u); + return GetPredecessor(0); } HBasicBlock* GetSingleSuccessor() const { - DCHECK_EQ(GetSuccessors().Size(), 1u); - return GetSuccessors().Get(0); + DCHECK_EQ(GetSuccessors().size(), 1u); + return GetSuccessor(0); } // Returns whether the first occurrence of `predecessor` in the list of // predecessors is at index `idx`. bool IsFirstIndexOfPredecessor(HBasicBlock* predecessor, size_t idx) const { - DCHECK_EQ(GetPredecessors().Get(idx), predecessor); + DCHECK_EQ(GetPredecessor(idx), predecessor); return GetPredecessorIndexOf(predecessor) == idx; } // Returns the number of non-exceptional successors. SsaChecker ensures that // these are stored at the beginning of the successor list. size_t NumberOfNormalSuccessors() const { - return EndsWithTryBoundary() ? 1 : GetSuccessors().Size(); + return EndsWithTryBoundary() ? 1 : GetSuccessors().size(); } // Split the block into two blocks just before `cursor`. Returns the newly @@ -880,8 +880,7 @@ class HBasicBlock : public ArenaObject<kArenaAllocBasicBlock> { bool IsLoopPreHeaderFirstPredecessor() const { DCHECK(IsLoopHeader()); - DCHECK(!GetPredecessors().IsEmpty()); - return GetPredecessors().Get(0) == GetLoopInformation()->GetPreHeader(); + return GetPredecessor(0) == GetLoopInformation()->GetPreHeader(); } HLoopInformation* GetLoopInformation() const { @@ -952,13 +951,13 @@ class HBasicBlock : public ArenaObject<kArenaAllocBasicBlock> { private: HGraph* graph_; - GrowableArray<HBasicBlock*> predecessors_; - GrowableArray<HBasicBlock*> successors_; + ArenaVector<HBasicBlock*> predecessors_; + ArenaVector<HBasicBlock*> successors_; HInstructionList instructions_; HInstructionList phis_; HLoopInformation* loop_information_; HBasicBlock* dominator_; - GrowableArray<HBasicBlock*> dominated_blocks_; + ArenaVector<HBasicBlock*> dominated_blocks_; int block_id_; // The dex program counter of the first instruction of this block. const uint32_t dex_pc_; @@ -2268,11 +2267,11 @@ class HIf : public HTemplateInstruction<1> { bool IsControlFlow() const OVERRIDE { return true; } HBasicBlock* IfTrueSuccessor() const { - return GetBlock()->GetSuccessors().Get(0); + return GetBlock()->GetSuccessor(0); } HBasicBlock* IfFalseSuccessor() const { - return GetBlock()->GetSuccessors().Get(1); + return GetBlock()->GetSuccessor(1); } DECLARE_INSTRUCTION(If); @@ -2300,14 +2299,13 @@ class HTryBoundary : public HTemplateInstruction<0> { bool IsControlFlow() const OVERRIDE { return true; } // Returns the block's non-exceptional successor (index zero). - HBasicBlock* GetNormalFlowSuccessor() const { return GetBlock()->GetSuccessors().Get(0); } + HBasicBlock* GetNormalFlowSuccessor() const { return GetBlock()->GetSuccessor(0); } // Returns whether `handler` is among its exception handlers (non-zero index // successors). bool HasExceptionHandler(const HBasicBlock& handler) const { DCHECK(handler.IsCatchBlock()); - return GetBlock()->GetSuccessors().Contains( - const_cast<HBasicBlock*>(&handler), /* start_from */ 1); + return GetBlock()->HasSuccessor(&handler, 1u /* Skip first successor. */); } // If not present already, adds `handler` to its block's list of exception @@ -2337,8 +2335,8 @@ class HExceptionHandlerIterator : public ValueObject { explicit HExceptionHandlerIterator(const HTryBoundary& try_boundary) : block_(*try_boundary.GetBlock()), index_(block_.NumberOfNormalSuccessors()) {} - bool Done() const { return index_ == block_.GetSuccessors().Size(); } - HBasicBlock* Current() const { return block_.GetSuccessors().Get(index_); } + bool Done() const { return index_ == block_.GetSuccessors().size(); } + HBasicBlock* Current() const { return block_.GetSuccessor(index_); } size_t CurrentSuccessorIndex() const { return index_; } void Advance() { ++index_; } diff --git a/compiler/optimizing/pretty_printer.h b/compiler/optimizing/pretty_printer.h index 934514eeda..34850a564c 100644 --- a/compiler/optimizing/pretty_printer.h +++ b/compiler/optimizing/pretty_printer.h @@ -71,23 +71,23 @@ class HPrettyPrinter : public HGraphVisitor { void VisitBasicBlock(HBasicBlock* block) OVERRIDE { PrintString("BasicBlock "); PrintInt(block->GetBlockId()); - const GrowableArray<HBasicBlock*>& predecessors = block->GetPredecessors(); - if (!predecessors.IsEmpty()) { + const ArenaVector<HBasicBlock*>& predecessors = block->GetPredecessors(); + if (!predecessors.empty()) { PrintString(", pred: "); - for (size_t i = 0; i < predecessors.Size() -1; i++) { - PrintInt(predecessors.Get(i)->GetBlockId()); + for (size_t i = 0; i < predecessors.size() -1; i++) { + PrintInt(predecessors[i]->GetBlockId()); PrintString(", "); } - PrintInt(predecessors.Peek()->GetBlockId()); + PrintInt(predecessors.back()->GetBlockId()); } - const GrowableArray<HBasicBlock*>& successors = block->GetSuccessors(); - if (!successors.IsEmpty()) { + const ArenaVector<HBasicBlock*>& successors = block->GetSuccessors(); + if (!successors.empty()) { PrintString(", succ: "); - for (size_t i = 0; i < successors.Size() - 1; i++) { - PrintInt(successors.Get(i)->GetBlockId()); + for (size_t i = 0; i < successors.size() - 1; i++) { + PrintInt(successors[i]->GetBlockId()); PrintString(", "); } - PrintInt(successors.Peek()->GetBlockId()); + PrintInt(successors.back()->GetBlockId()); } PrintNewLine(); HGraphVisitor::VisitBasicBlock(block); @@ -131,7 +131,7 @@ class StringPrettyPrinter : public HPrettyPrinter { PrintString(" "); PrintInt(gota->GetId()); PrintString(": Goto "); - PrintInt(current_block_->GetSuccessors().Get(0)->GetBlockId()); + PrintInt(current_block_->GetSuccessor(0)->GetBlockId()); PrintNewLine(); } diff --git a/compiler/optimizing/register_allocator.cc b/compiler/optimizing/register_allocator.cc index 37c8bc5f51..6f1f6af62d 100644 --- a/compiler/optimizing/register_allocator.cc +++ b/compiler/optimizing/register_allocator.cc @@ -1212,14 +1212,13 @@ LiveInterval* RegisterAllocator::SplitBetween(LiveInterval* interval, size_t fro * moves in B3. */ if (block_from->GetDominator() != nullptr) { - const GrowableArray<HBasicBlock*>& dominated = block_from->GetDominator()->GetDominatedBlocks(); - for (size_t i = 0; i < dominated.Size(); ++i) { - size_t position = dominated.Get(i)->GetLifetimeStart(); + for (HBasicBlock* dominated : block_from->GetDominator()->GetDominatedBlocks()) { + size_t position = dominated->GetLifetimeStart(); if ((position > from) && (block_to->GetLifetimeStart() > position)) { // Even if we found a better block, we continue iterating in case // a dominated block is closer. // Note that dominated blocks are not sorted in liveness order. - block_to = dominated.Get(i); + block_to = dominated; DCHECK_NE(block_to, block_from); } } @@ -1498,7 +1497,7 @@ void RegisterAllocator::InsertParallelMoveAtExitOf(HBasicBlock* block, DCHECK(IsValidDestination(destination)) << destination; if (source.Equals(destination)) return; - DCHECK_EQ(block->GetSuccessors().Size(), 1u); + DCHECK_EQ(block->GetSuccessors().size(), 1u); HInstruction* last = block->GetLastInstruction(); // We insert moves at exit for phi predecessors and connecting blocks. // A block ending with an if cannot branch to a block with phis because @@ -1725,13 +1724,13 @@ void RegisterAllocator::ConnectSplitSiblings(LiveInterval* interval, // If `from` has only one successor, we can put the moves at the exit of it. Otherwise // we need to put the moves at the entry of `to`. - if (from->GetSuccessors().Size() == 1) { + if (from->GetSuccessors().size() == 1) { InsertParallelMoveAtExitOf(from, interval->GetParent()->GetDefinedBy(), source->ToLocation(), destination->ToLocation()); } else { - DCHECK_EQ(to->GetPredecessors().Size(), 1u); + DCHECK_EQ(to->GetPredecessors().size(), 1u); InsertParallelMoveAtEntryOf(to, interval->GetParent()->GetDefinedBy(), source->ToLocation(), @@ -1833,8 +1832,8 @@ void RegisterAllocator::Resolve() { for (uint32_t idx : live->Indexes()) { HInstruction* current = liveness_.GetInstructionFromSsaIndex(idx); LiveInterval* interval = current->GetLiveInterval(); - for (size_t i = 0, e = block->GetPredecessors().Size(); i < e; ++i) { - ConnectSplitSiblings(interval, block->GetPredecessors().Get(i), block); + for (HBasicBlock* predecessor : block->GetPredecessors()) { + ConnectSplitSiblings(interval, predecessor, block); } } } @@ -1844,9 +1843,9 @@ void RegisterAllocator::Resolve() { HBasicBlock* current = it.Current(); for (HInstructionIterator inst_it(current->GetPhis()); !inst_it.Done(); inst_it.Advance()) { HInstruction* phi = inst_it.Current(); - for (size_t i = 0, e = current->GetPredecessors().Size(); i < e; ++i) { - HBasicBlock* predecessor = current->GetPredecessors().Get(i); - DCHECK_EQ(predecessor->GetSuccessors().Size(), 1u); + for (size_t i = 0, e = current->GetPredecessors().size(); i < e; ++i) { + HBasicBlock* predecessor = current->GetPredecessor(i); + DCHECK_EQ(predecessor->GetSuccessors().size(), 1u); HInstruction* input = phi->InputAt(i); Location source = input->GetLiveInterval()->GetLocationAt( predecessor->GetLifetimeEnd() - 1); diff --git a/compiler/optimizing/ssa_builder.cc b/compiler/optimizing/ssa_builder.cc index 561c3b4964..e6209b9583 100644 --- a/compiler/optimizing/ssa_builder.cc +++ b/compiler/optimizing/ssa_builder.cc @@ -241,8 +241,8 @@ void SsaBuilder::BuildSsa() { HBasicBlock* block = loop_headers_.Get(i); for (HInstructionIterator it(block->GetPhis()); !it.Done(); it.Advance()) { HPhi* phi = it.Current()->AsPhi(); - for (size_t pred = 0; pred < block->GetPredecessors().Size(); pred++) { - HInstruction* input = ValueOfLocal(block->GetPredecessors().Get(pred), phi->GetRegNumber()); + for (HBasicBlock* predecessor : block->GetPredecessors()) { + HInstruction* input = ValueOfLocal(predecessor, phi->GetRegNumber()); phi->AddInput(input); } } @@ -369,16 +369,16 @@ void SsaBuilder::VisitBasicBlock(HBasicBlock* block) { // Save the loop header so that the last phase of the analysis knows which // blocks need to be updated. loop_headers_.Add(block); - } else if (block->GetPredecessors().Size() > 0) { + } else if (block->GetPredecessors().size() > 0) { // All predecessors have already been visited because we are visiting in reverse post order. // We merge the values of all locals, creating phis if those values differ. for (size_t local = 0; local < current_locals_->Size(); local++) { bool one_predecessor_has_no_value = false; bool is_different = false; - HInstruction* value = ValueOfLocal(block->GetPredecessors().Get(0), local); + HInstruction* value = ValueOfLocal(block->GetPredecessor(0), local); - for (size_t i = 0, e = block->GetPredecessors().Size(); i < e; ++i) { - HInstruction* current = ValueOfLocal(block->GetPredecessors().Get(i), local); + for (HBasicBlock* predecessor : block->GetPredecessors()) { + HInstruction* current = ValueOfLocal(predecessor, local); if (current == nullptr) { one_predecessor_has_no_value = true; break; @@ -395,9 +395,9 @@ void SsaBuilder::VisitBasicBlock(HBasicBlock* block) { if (is_different) { HPhi* phi = new (GetGraph()->GetArena()) HPhi( - GetGraph()->GetArena(), local, block->GetPredecessors().Size(), Primitive::kPrimVoid); - for (size_t i = 0; i < block->GetPredecessors().Size(); i++) { - HInstruction* pred_value = ValueOfLocal(block->GetPredecessors().Get(i), local); + GetGraph()->GetArena(), local, block->GetPredecessors().size(), Primitive::kPrimVoid); + for (size_t i = 0; i < block->GetPredecessors().size(); i++) { + HInstruction* pred_value = ValueOfLocal(block->GetPredecessor(i), local); phi->SetRawInputAt(i, pred_value); } block->AddPhi(phi); diff --git a/compiler/optimizing/ssa_liveness_analysis.cc b/compiler/optimizing/ssa_liveness_analysis.cc index 40502c173b..0c1831b45f 100644 --- a/compiler/optimizing/ssa_liveness_analysis.cc +++ b/compiler/optimizing/ssa_liveness_analysis.cc @@ -73,7 +73,7 @@ void SsaLivenessAnalysis::LinearizeGraph() { forward_predecessors.SetSize(graph_->GetBlocks().Size()); for (HReversePostOrderIterator it(*graph_); !it.Done(); it.Advance()) { HBasicBlock* block = it.Current(); - size_t number_of_forward_predecessors = block->GetPredecessors().Size(); + size_t number_of_forward_predecessors = block->GetPredecessors().size(); if (block->IsLoopHeader()) { number_of_forward_predecessors -= block->GetLoopInformation()->NumberOfBackEdges(); } @@ -89,8 +89,7 @@ void SsaLivenessAnalysis::LinearizeGraph() { do { HBasicBlock* current = worklist.Pop(); graph_->linear_order_.Add(current); - for (size_t i = 0, e = current->GetSuccessors().Size(); i < e; ++i) { - HBasicBlock* successor = current->GetSuccessors().Get(i); + for (HBasicBlock* successor : current->GetSuccessors()) { int block_id = successor->GetBlockId(); size_t number_of_remaining_predecessors = forward_predecessors.Get(block_id); if (number_of_remaining_predecessors == 1) { @@ -185,8 +184,7 @@ void SsaLivenessAnalysis::ComputeLiveRanges() { // Set phi inputs of successors of this block corresponding to this block // as live_in. - for (size_t i = 0, e = block->GetSuccessors().Size(); i < e; ++i) { - HBasicBlock* successor = block->GetSuccessors().Get(i); + for (HBasicBlock* successor : block->GetSuccessors()) { live_in->Union(GetLiveInSet(*successor)); size_t phi_input_index = successor->GetPredecessorIndexOf(block); for (HInstructionIterator inst_it(successor->GetPhis()); !inst_it.Done(); inst_it.Advance()) { @@ -296,8 +294,7 @@ bool SsaLivenessAnalysis::UpdateLiveOut(const HBasicBlock& block) { BitVector* live_out = GetLiveOutSet(block); bool changed = false; // The live_out set of a block is the union of live_in sets of its successors. - for (size_t i = 0, e = block.GetSuccessors().Size(); i < e; ++i) { - HBasicBlock* successor = block.GetSuccessors().Get(i); + for (HBasicBlock* successor : block.GetSuccessors()) { if (live_out->Union(GetLiveInSet(*successor))) { changed = true; } @@ -342,8 +339,8 @@ int LiveInterval::FindFirstRegisterHint(size_t* free_until, // will avoid a move between the two blocks. HBasicBlock* block = liveness.GetBlockFromPosition(GetStart() / 2); size_t next_register_use = FirstRegisterUse(); - for (size_t i = 0; i < block->GetPredecessors().Size(); ++i) { - size_t position = block->GetPredecessors().Get(i)->GetLifetimeEnd() - 1; + for (HBasicBlock* predecessor : block->GetPredecessors()) { + size_t position = predecessor->GetLifetimeEnd() - 1; // We know positions above GetStart() do not have a location yet. if (position < GetStart()) { LiveInterval* existing = GetParent()->GetSiblingAt(position); @@ -376,17 +373,16 @@ int LiveInterval::FindFirstRegisterHint(size_t* free_until, return reg; } } - const GrowableArray<HBasicBlock*>& predecessors = user->GetBlock()->GetPredecessors(); // If the instruction dies at the phi assignment, we can try having the // same register. - if (end == predecessors.Get(input_index)->GetLifetimeEnd()) { + if (end == user->GetBlock()->GetPredecessor(input_index)->GetLifetimeEnd()) { for (size_t i = 0, e = user->InputCount(); i < e; ++i) { if (i == input_index) { continue; } HInstruction* input = user->InputAt(i); Location location = input->GetLiveInterval()->GetLocationAt( - predecessors.Get(i)->GetLifetimeEnd() - 1); + user->GetBlock()->GetPredecessor(i)->GetLifetimeEnd() - 1); if (location.IsRegisterKind()) { int reg = RegisterOrLowRegister(location); if (free_until[reg] >= use_position) { @@ -420,10 +416,11 @@ int LiveInterval::FindFirstRegisterHint(size_t* free_until, int LiveInterval::FindHintAtDefinition() const { if (defined_by_->IsPhi()) { // Try to use the same register as one of the inputs. - const GrowableArray<HBasicBlock*>& predecessors = defined_by_->GetBlock()->GetPredecessors(); + const ArenaVector<HBasicBlock*>& predecessors = defined_by_->GetBlock()->GetPredecessors(); for (size_t i = 0, e = defined_by_->InputCount(); i < e; ++i) { HInstruction* input = defined_by_->InputAt(i); - size_t end = predecessors.Get(i)->GetLifetimeEnd(); + DCHECK_LT(i, predecessors.size()); + size_t end = predecessors[i]->GetLifetimeEnd(); LiveInterval* input_interval = input->GetLiveInterval()->GetSiblingAt(end - 1); if (input_interval->GetEnd() == end) { // If the input dies at the end of the predecessor, we know its register can diff --git a/compiler/optimizing/suspend_check_test.cc b/compiler/optimizing/suspend_check_test.cc index 5ca66a1de6..e745d94b89 100644 --- a/compiler/optimizing/suspend_check_test.cc +++ b/compiler/optimizing/suspend_check_test.cc @@ -36,7 +36,7 @@ static void TestCode(const uint16_t* data) { bool graph_built = builder.BuildGraph(*item); ASSERT_TRUE(graph_built); - HBasicBlock* first_block = graph->GetEntryBlock()->GetSuccessors().Get(0); + HBasicBlock* first_block = graph->GetEntryBlock()->GetSuccessor(0); HInstruction* first_instruction = first_block->GetFirstInstruction(); // Account for some tests having a store local as first instruction. ASSERT_TRUE(first_instruction->IsSuspendCheck() diff --git a/runtime/base/arena_allocator.cc b/runtime/base/arena_allocator.cc index 3a4bccd94c..a36b0fbb93 100644 --- a/runtime/base/arena_allocator.cc +++ b/runtime/base/arena_allocator.cc @@ -52,13 +52,14 @@ const char* const ArenaAllocatorStatsImpl<kCount>::kAllocNames[] = { "SSA2Dalvik ", "Dalvik2SSA ", "DebugInfo ", - "Successor ", "RegAlloc ", "Data ", - "Preds ", "STL ", "Graph ", "BasicBlock ", + "Predecessors ", + "Successors ", + "Dominated ", "Instruction ", "LoopInfo ", "TryCatchInf ", diff --git a/runtime/base/arena_allocator.h b/runtime/base/arena_allocator.h index af2bfbc944..47defb4ba2 100644 --- a/runtime/base/arena_allocator.h +++ b/runtime/base/arena_allocator.h @@ -62,13 +62,14 @@ enum ArenaAllocKind { kArenaAllocSSAToDalvikMap, kArenaAllocDalvikToSSAMap, kArenaAllocDebugInfo, - kArenaAllocSuccessor, kArenaAllocRegAlloc, kArenaAllocData, - kArenaAllocPredecessors, kArenaAllocSTL, kArenaAllocGraph, kArenaAllocBasicBlock, + kArenaAllocPredecessors, + kArenaAllocSuccessors, + kArenaAllocDominated, kArenaAllocInstruction, kArenaAllocLoopInfo, kArenaAllocTryCatchInfo, |