| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "graph_checker.h" |
| |
| #include <map> |
| #include <string> |
| #include <sstream> |
| |
| #include "base/bit_vector-inl.h" |
| #include "base/stringprintf.h" |
| |
| namespace art { |
| |
| 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); |
| ++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) { |
| ++block_count_in_p_successors; |
| } |
| } |
| if (p_count_in_block_predecessors != block_count_in_p_successors) { |
| AddError(StringPrintf( |
| "Block %d lists %zu occurrences of block %d in its predecessors, whereas " |
| "block %d lists %zu occurrences of block %d in its successors.", |
| block->GetBlockId(), p_count_in_block_predecessors, p->GetBlockId(), |
| p->GetBlockId(), block_count_in_p_successors, block->GetBlockId())); |
| } |
| } |
| |
| // 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); |
| ++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) { |
| ++block_count_in_s_predecessors; |
| } |
| } |
| if (s_count_in_block_successors != block_count_in_s_predecessors) { |
| AddError(StringPrintf( |
| "Block %d lists %zu occurrences of block %d in its successors, whereas " |
| "block %d lists %zu occurrences of block %d in its predecessors.", |
| block->GetBlockId(), s_count_in_block_successors, s->GetBlockId(), |
| s->GetBlockId(), block_count_in_s_predecessors, block->GetBlockId())); |
| } |
| } |
| |
| // Ensure `block` ends with a branch instruction. |
| // This invariant is not enforced on non-SSA graphs. Graph built from DEX with |
| // dead code that falls out of the method will not end with a control-flow |
| // instruction. Such code is removed during the SSA-building DCE phase. |
| if (GetGraph()->IsInSsaForm() && !block->EndsWithControlFlowInstruction()) { |
| AddError(StringPrintf("Block %d does not end with a branch instruction.", |
| block->GetBlockId())); |
| } |
| |
| // 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); |
| if (predecessor->IsSingleTryBoundary() |
| && !predecessor->GetLastInstruction()->AsTryBoundary()->IsEntry()) { |
| HBasicBlock* real_predecessor = predecessor->GetSinglePredecessor(); |
| HInstruction* last_instruction = real_predecessor->GetLastInstruction(); |
| if (!last_instruction->IsThrow()) { |
| AddError(StringPrintf("Unexpected TryBoundary between %s:%d and Exit.", |
| last_instruction->DebugName(), |
| last_instruction->GetId())); |
| } |
| } else { |
| HInstruction* last_instruction = predecessor->GetLastInstruction(); |
| if (!last_instruction->IsReturn() |
| && !last_instruction->IsReturnVoid() |
| && !last_instruction->IsThrow()) { |
| AddError(StringPrintf("Unexpected instruction %s:%d jumps into the exit block.", |
| last_instruction->DebugName(), |
| last_instruction->GetId())); |
| } |
| } |
| } |
| } |
| |
| // Visit this block's list of phis. |
| for (HInstructionIterator it(block->GetPhis()); !it.Done(); it.Advance()) { |
| HInstruction* current = it.Current(); |
| // Ensure this block's list of phis contains only phis. |
| if (!current->IsPhi()) { |
| AddError(StringPrintf("Block %d has a non-phi in its phi list.", |
| current_block_->GetBlockId())); |
| } |
| if (current->GetNext() == nullptr && current != block->GetLastPhi()) { |
| AddError(StringPrintf("The recorded last phi of block %d does not match " |
| "the actual last phi %d.", |
| current_block_->GetBlockId(), |
| current->GetId())); |
| } |
| current->Accept(this); |
| } |
| |
| // Visit this block's list of instructions. |
| for (HInstructionIterator it(block->GetInstructions()); !it.Done(); it.Advance()) { |
| HInstruction* current = it.Current(); |
| // Ensure this block's list of instructions does not contains phis. |
| if (current->IsPhi()) { |
| AddError(StringPrintf("Block %d has a phi in its non-phi list.", |
| current_block_->GetBlockId())); |
| } |
| if (current->GetNext() == nullptr && current != block->GetLastInstruction()) { |
| AddError(StringPrintf("The recorded last instruction of block %d does not match " |
| "the actual last instruction %d.", |
| current_block_->GetBlockId(), |
| current->GetId())); |
| } |
| current->Accept(this); |
| } |
| } |
| |
| void GraphChecker::VisitBoundsCheck(HBoundsCheck* check) { |
| if (!GetGraph()->HasBoundsChecks()) { |
| AddError(StringPrintf("Instruction %s:%d is a HBoundsCheck, " |
| "but HasBoundsChecks() returns false", |
| check->DebugName(), |
| check->GetId())); |
| } |
| |
| // Perform the instruction base checks too. |
| VisitInstruction(check); |
| } |
| |
| void GraphChecker::VisitTryBoundary(HTryBoundary* try_boundary) { |
| // Ensure that all exception handlers are catch blocks and that handlers |
| // are not listed multiple times. |
| // Note that a normal-flow successor may be a catch block before CFG |
| // simplification. We only test normal-flow successors in SsaChecker. |
| for (HExceptionHandlerIterator it(*try_boundary); !it.Done(); it.Advance()) { |
| HBasicBlock* handler = it.Current(); |
| if (!handler->IsCatchBlock()) { |
| AddError(StringPrintf("Block %d with %s:%d has exceptional successor %d which " |
| "is not a catch block.", |
| current_block_->GetBlockId(), |
| try_boundary->DebugName(), |
| try_boundary->GetId(), |
| handler->GetBlockId())); |
| } |
| if (current_block_->GetSuccessors().Contains( |
| handler, /* start_from */ it.CurrentSuccessorIndex() + 1)) { |
| AddError(StringPrintf("Exception handler block %d of %s:%d is listed multiple times.", |
| handler->GetBlockId(), |
| try_boundary->DebugName(), |
| try_boundary->GetId())); |
| } |
| } |
| |
| VisitInstruction(try_boundary); |
| } |
| |
| void GraphChecker::VisitInstruction(HInstruction* instruction) { |
| if (seen_ids_.IsBitSet(instruction->GetId())) { |
| AddError(StringPrintf("Instruction id %d is duplicate in graph.", |
| instruction->GetId())); |
| } else { |
| seen_ids_.SetBit(instruction->GetId()); |
| } |
| |
| // Ensure `instruction` is associated with `current_block_`. |
| if (instruction->GetBlock() == nullptr) { |
| AddError(StringPrintf("%s %d in block %d not associated with any block.", |
| instruction->IsPhi() ? "Phi" : "Instruction", |
| instruction->GetId(), |
| current_block_->GetBlockId())); |
| } else if (instruction->GetBlock() != current_block_) { |
| AddError(StringPrintf("%s %d in block %d associated with block %d.", |
| instruction->IsPhi() ? "Phi" : "Instruction", |
| instruction->GetId(), |
| current_block_->GetBlockId(), |
| instruction->GetBlock()->GetBlockId())); |
| } |
| |
| // Ensure the inputs of `instruction` are defined in a block of the graph. |
| for (HInputIterator input_it(instruction); !input_it.Done(); |
| input_it.Advance()) { |
| HInstruction* input = input_it.Current(); |
| const HInstructionList& list = input->IsPhi() |
| ? input->GetBlock()->GetPhis() |
| : input->GetBlock()->GetInstructions(); |
| if (!list.Contains(input)) { |
| AddError(StringPrintf("Input %d of instruction %d is not defined " |
| "in a basic block of the control-flow graph.", |
| input->GetId(), |
| instruction->GetId())); |
| } |
| } |
| |
| // Ensure the uses of `instruction` are defined in a block of the graph, |
| // and the entry in the use list is consistent. |
| for (HUseIterator<HInstruction*> use_it(instruction->GetUses()); |
| !use_it.Done(); use_it.Advance()) { |
| HInstruction* use = use_it.Current()->GetUser(); |
| const HInstructionList& list = use->IsPhi() |
| ? use->GetBlock()->GetPhis() |
| : use->GetBlock()->GetInstructions(); |
| if (!list.Contains(use)) { |
| AddError(StringPrintf("User %s:%d of instruction %d is not defined " |
| "in a basic block of the control-flow graph.", |
| use->DebugName(), |
| use->GetId(), |
| instruction->GetId())); |
| } |
| size_t use_index = use_it.Current()->GetIndex(); |
| if ((use_index >= use->InputCount()) || (use->InputAt(use_index) != instruction)) { |
| AddError(StringPrintf("User %s:%d of instruction %d has a wrong " |
| "UseListNode index.", |
| use->DebugName(), |
| use->GetId(), |
| instruction->GetId())); |
| } |
| } |
| |
| // Ensure the environment uses entries are consistent. |
| for (HUseIterator<HEnvironment*> use_it(instruction->GetEnvUses()); |
| !use_it.Done(); use_it.Advance()) { |
| HEnvironment* use = use_it.Current()->GetUser(); |
| size_t use_index = use_it.Current()->GetIndex(); |
| if ((use_index >= use->Size()) || (use->GetInstructionAt(use_index) != instruction)) { |
| AddError(StringPrintf("Environment user of %s:%d has a wrong " |
| "UseListNode index.", |
| instruction->DebugName(), |
| instruction->GetId())); |
| } |
| } |
| |
| // Ensure 'instruction' has pointers to its inputs' use entries. |
| for (size_t i = 0, e = instruction->InputCount(); i < e; ++i) { |
| HUserRecord<HInstruction*> input_record = instruction->InputRecordAt(i); |
| HInstruction* input = input_record.GetInstruction(); |
| HUseListNode<HInstruction*>* use_node = input_record.GetUseNode(); |
| size_t use_index = use_node->GetIndex(); |
| if ((use_node == nullptr) |
| || !input->GetUses().Contains(use_node) |
| || (use_index >= e) |
| || (use_index != i)) { |
| AddError(StringPrintf("Instruction %s:%d has an invalid pointer to use entry " |
| "at input %u (%s:%d).", |
| instruction->DebugName(), |
| instruction->GetId(), |
| static_cast<unsigned>(i), |
| input->DebugName(), |
| input->GetId())); |
| } |
| } |
| } |
| |
| void GraphChecker::VisitInvokeStaticOrDirect(HInvokeStaticOrDirect* invoke) { |
| VisitInstruction(invoke); |
| |
| if (invoke->IsStaticWithExplicitClinitCheck()) { |
| size_t last_input_index = invoke->InputCount() - 1; |
| HInstruction* last_input = invoke->InputAt(last_input_index); |
| if (last_input == nullptr) { |
| AddError(StringPrintf("Static invoke %s:%d marked as having an explicit clinit check " |
| "has a null pointer as last input.", |
| invoke->DebugName(), |
| invoke->GetId())); |
| } |
| if (!last_input->IsClinitCheck() && !last_input->IsLoadClass()) { |
| AddError(StringPrintf("Static invoke %s:%d marked as having an explicit clinit check " |
| "has a last instruction (%s:%d) which is neither a clinit check " |
| "nor a load class instruction.", |
| invoke->DebugName(), |
| invoke->GetId(), |
| last_input->DebugName(), |
| last_input->GetId())); |
| } |
| } |
| } |
| |
| void GraphChecker::VisitReturn(HReturn* ret) { |
| VisitInstruction(ret); |
| if (!ret->GetBlock()->GetSingleSuccessor()->IsExitBlock()) { |
| AddError(StringPrintf("%s:%d does not jump to the exit block.", |
| ret->DebugName(), |
| ret->GetId())); |
| } |
| } |
| |
| void GraphChecker::VisitReturnVoid(HReturnVoid* ret) { |
| VisitInstruction(ret); |
| if (!ret->GetBlock()->GetSingleSuccessor()->IsExitBlock()) { |
| AddError(StringPrintf("%s:%d does not jump to the exit block.", |
| ret->DebugName(), |
| ret->GetId())); |
| } |
| } |
| |
| void GraphChecker::VisitCheckCast(HCheckCast* check) { |
| VisitInstruction(check); |
| HInstruction* input = check->InputAt(1); |
| if (!input->IsLoadClass()) { |
| AddError(StringPrintf("%s:%d expects a HLoadClass as second input, not %s:%d.", |
| check->DebugName(), |
| check->GetId(), |
| input->DebugName(), |
| input->GetId())); |
| } |
| } |
| |
| void GraphChecker::VisitInstanceOf(HInstanceOf* instruction) { |
| VisitInstruction(instruction); |
| HInstruction* input = instruction->InputAt(1); |
| if (!input->IsLoadClass()) { |
| AddError(StringPrintf("%s:%d expects a HLoadClass as second input, not %s:%d.", |
| instruction->DebugName(), |
| instruction->GetId(), |
| input->DebugName(), |
| input->GetId())); |
| } |
| } |
| |
| void SSAChecker::VisitBasicBlock(HBasicBlock* block) { |
| super_type::VisitBasicBlock(block); |
| |
| // Ensure that catch blocks are not normal successors, and normal blocks are |
| // 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); |
| 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); |
| if (!successor->IsCatchBlock()) { |
| AddError(StringPrintf("Normal block %d is an exceptional successor of block %d.", |
| successor->GetBlockId(), |
| block->GetBlockId())); |
| } |
| } |
| |
| // Ensure there is no critical edge (i.e., an edge connecting a |
| // block with multiple successors to a block with multiple |
| // predecessors). Exceptional edges are synthesized and hence |
| // 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) { |
| AddError(StringPrintf("Critical edge between blocks %d and %d.", |
| block->GetBlockId(), |
| successor->GetBlockId())); |
| } |
| } |
| } |
| |
| // Check Phi uniqueness (no two Phis with the same type refer to the same register). |
| for (HInstructionIterator it(block->GetPhis()); !it.Done(); it.Advance()) { |
| HPhi* phi = it.Current()->AsPhi(); |
| if (phi->GetNextEquivalentPhiWithSameType() != nullptr) { |
| std::stringstream type_str; |
| type_str << phi->GetType(); |
| AddError(StringPrintf("Equivalent phi (%d) found for VReg %d with type: %s", |
| phi->GetId(), phi->GetRegNumber(), type_str.str().c_str())); |
| } |
| } |
| |
| // Ensure try membership information is consistent. |
| if (block->IsCatchBlock()) { |
| if (block->IsTryBlock()) { |
| const HTryBoundary& try_entry = block->GetTryCatchInformation()->GetTryEntry(); |
| AddError(StringPrintf("Catch blocks should not be try blocks but catch block %d " |
| "has try entry %s:%d.", |
| block->GetBlockId(), |
| try_entry.DebugName(), |
| try_entry.GetId())); |
| } |
| |
| if (block->IsLoopHeader()) { |
| AddError(StringPrintf("Catch blocks should not be loop headers but catch block %d is.", |
| block->GetBlockId())); |
| } |
| } else { |
| for (size_t i = 0; i < block->GetPredecessors().Size(); ++i) { |
| HBasicBlock* predecessor = block->GetPredecessors().Get(i); |
| const HTryBoundary* incoming_try_entry = predecessor->ComputeTryEntryOfSuccessors(); |
| if (block->IsTryBlock()) { |
| const HTryBoundary& stored_try_entry = block->GetTryCatchInformation()->GetTryEntry(); |
| if (incoming_try_entry == nullptr) { |
| AddError(StringPrintf("Block %d has try entry %s:%d but no try entry follows " |
| "from predecessor %d.", |
| block->GetBlockId(), |
| stored_try_entry.DebugName(), |
| stored_try_entry.GetId(), |
| predecessor->GetBlockId())); |
| } else if (!incoming_try_entry->HasSameExceptionHandlersAs(stored_try_entry)) { |
| AddError(StringPrintf("Block %d has try entry %s:%d which is not consistent " |
| "with %s:%d that follows from predecessor %d.", |
| block->GetBlockId(), |
| stored_try_entry.DebugName(), |
| stored_try_entry.GetId(), |
| incoming_try_entry->DebugName(), |
| incoming_try_entry->GetId(), |
| predecessor->GetBlockId())); |
| } |
| } else if (incoming_try_entry != nullptr) { |
| AddError(StringPrintf("Block %d is not a try block but try entry %s:%d follows " |
| "from predecessor %d.", |
| block->GetBlockId(), |
| incoming_try_entry->DebugName(), |
| incoming_try_entry->GetId(), |
| predecessor->GetBlockId())); |
| } |
| } |
| } |
| |
| if (block->IsLoopHeader()) { |
| CheckLoop(block); |
| } |
| } |
| |
| void SSAChecker::CheckLoop(HBasicBlock* loop_header) { |
| int id = loop_header->GetBlockId(); |
| HLoopInformation* loop_information = loop_header->GetLoopInformation(); |
| |
| // Ensure the pre-header block is first in the list of |
| // predecessors of a loop header. |
| if (!loop_header->IsLoopPreHeaderFirstPredecessor()) { |
| AddError(StringPrintf( |
| "Loop pre-header is not the first predecessor of the loop header %d.", |
| id)); |
| } |
| |
| // Ensure the loop header has only one incoming branch and the remaining |
| // predecessors are back edges. |
| 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); |
| 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); |
| if (!loop_information->IsBackEdge(*predecessor)) { |
| AddError(StringPrintf( |
| "Loop header %d has multiple incoming (non back edge) blocks.", |
| id)); |
| } |
| } |
| } |
| |
| const ArenaBitVector& loop_blocks = loop_information->GetBlocks(); |
| |
| // Ensure back edges belong to the loop. |
| size_t num_back_edges = loop_information->GetBackEdges().Size(); |
| if (num_back_edges == 0) { |
| AddError(StringPrintf( |
| "Loop defined by header %d has no back edge.", |
| id)); |
| } else { |
| for (size_t i = 0; i < num_back_edges; ++i) { |
| int back_edge_id = loop_information->GetBackEdges().Get(i)->GetBlockId(); |
| if (!loop_blocks.IsBitSet(back_edge_id)) { |
| AddError(StringPrintf( |
| "Loop defined by header %d has an invalid back edge %d.", |
| id, |
| back_edge_id)); |
| } |
| } |
| } |
| |
| // Ensure all blocks in the loop are live and dominated by the loop header. |
| for (uint32_t i : loop_blocks.Indexes()) { |
| HBasicBlock* loop_block = GetGraph()->GetBlocks().Get(i); |
| if (loop_block == nullptr) { |
| AddError(StringPrintf("Loop defined by header %d contains a previously removed block %d.", |
| id, |
| i)); |
| } else if (!loop_header->Dominates(loop_block)) { |
| AddError(StringPrintf("Loop block %d not dominated by loop header %d.", |
| i, |
| id)); |
| } |
| } |
| |
| // If this is a nested loop, ensure the outer loops contain a superset of the blocks. |
| for (HLoopInformationOutwardIterator it(*loop_header); !it.Done(); it.Advance()) { |
| HLoopInformation* outer_info = it.Current(); |
| if (!loop_blocks.IsSubsetOf(&outer_info->GetBlocks())) { |
| AddError(StringPrintf("Blocks of loop defined by header %d are not a subset of blocks of " |
| "an outer loop defined by header %d.", |
| id, |
| outer_info->GetHeader()->GetBlockId())); |
| } |
| } |
| } |
| |
| void SSAChecker::VisitInstruction(HInstruction* instruction) { |
| super_type::VisitInstruction(instruction); |
| |
| // Ensure an instruction dominates all its uses. |
| for (HUseIterator<HInstruction*> use_it(instruction->GetUses()); |
| !use_it.Done(); use_it.Advance()) { |
| HInstruction* use = use_it.Current()->GetUser(); |
| if (!use->IsPhi() && !instruction->StrictlyDominates(use)) { |
| AddError(StringPrintf("Instruction %d in block %d does not dominate " |
| "use %d in block %d.", |
| instruction->GetId(), current_block_->GetBlockId(), |
| use->GetId(), use->GetBlock()->GetBlockId())); |
| } |
| } |
| |
| // Ensure an instruction having an environment is dominated by the |
| // instructions contained in the environment. |
| for (HEnvironment* environment = instruction->GetEnvironment(); |
| environment != nullptr; |
| environment = environment->GetParent()) { |
| for (size_t i = 0, e = environment->Size(); i < e; ++i) { |
| HInstruction* env_instruction = environment->GetInstructionAt(i); |
| if (env_instruction != nullptr |
| && !env_instruction->StrictlyDominates(instruction)) { |
| AddError(StringPrintf("Instruction %d in environment of instruction %d " |
| "from block %d does not dominate instruction %d.", |
| env_instruction->GetId(), |
| instruction->GetId(), |
| current_block_->GetBlockId(), |
| instruction->GetId())); |
| } |
| } |
| } |
| } |
| |
| static Primitive::Type PrimitiveKind(Primitive::Type type) { |
| switch (type) { |
| case Primitive::kPrimBoolean: |
| case Primitive::kPrimByte: |
| case Primitive::kPrimShort: |
| case Primitive::kPrimChar: |
| case Primitive::kPrimInt: |
| return Primitive::kPrimInt; |
| default: |
| return type; |
| } |
| } |
| |
| void SSAChecker::VisitPhi(HPhi* phi) { |
| VisitInstruction(phi); |
| |
| // Ensure the first input of a phi is not itself. |
| if (phi->InputAt(0) == phi) { |
| AddError(StringPrintf("Loop phi %d in block %d is its own first input.", |
| phi->GetId(), |
| phi->GetBlock()->GetBlockId())); |
| } |
| |
| // Ensure that the inputs have the same primitive kind as the phi. |
| for (size_t i = 0, e = phi->InputCount(); i < e; ++i) { |
| HInstruction* input = phi->InputAt(i); |
| if (PrimitiveKind(input->GetType()) != PrimitiveKind(phi->GetType())) { |
| AddError(StringPrintf( |
| "Input %d at index %zu of phi %d from block %d does not have the " |
| "same type as the phi: %s versus %s", |
| input->GetId(), i, phi->GetId(), phi->GetBlock()->GetBlockId(), |
| Primitive::PrettyDescriptor(input->GetType()), |
| Primitive::PrettyDescriptor(phi->GetType()))); |
| } |
| } |
| if (phi->GetType() != HPhi::ToPhiType(phi->GetType())) { |
| AddError(StringPrintf("Phi %d in block %d does not have an expected phi type: %s", |
| phi->GetId(), |
| phi->GetBlock()->GetBlockId(), |
| Primitive::PrettyDescriptor(phi->GetType()))); |
| } |
| |
| if (phi->IsCatchPhi()) { |
| // The number of inputs of a catch phi corresponds to the total number of |
| // throwing instructions caught by this catch block. |
| } 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()) { |
| 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())); |
| } 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); |
| if (!(input->GetBlock() == predecessor |
| || input->GetBlock()->Dominates(predecessor))) { |
| AddError(StringPrintf( |
| "Input %d at index %zu of phi %d from block %d is not defined in " |
| "predecessor number %zu nor in a block dominating it.", |
| input->GetId(), i, phi->GetId(), phi->GetBlock()->GetBlockId(), |
| i)); |
| } |
| } |
| } |
| } |
| } |
| |
| void SSAChecker::HandleBooleanInput(HInstruction* instruction, size_t input_index) { |
| HInstruction* input = instruction->InputAt(input_index); |
| if (input->IsIntConstant()) { |
| int32_t value = input->AsIntConstant()->GetValue(); |
| if (value != 0 && value != 1) { |
| AddError(StringPrintf( |
| "%s instruction %d has a non-Boolean constant input %d whose value is: %d.", |
| instruction->DebugName(), |
| instruction->GetId(), |
| static_cast<int>(input_index), |
| value)); |
| } |
| } else if (input->GetType() == Primitive::kPrimInt |
| && (input->IsPhi() || input->IsAnd() || input->IsOr() || input->IsXor())) { |
| // TODO: We need a data-flow analysis to determine if the Phi or |
| // binary operation is actually Boolean. Allow for now. |
| } else if (input->GetType() != Primitive::kPrimBoolean) { |
| AddError(StringPrintf( |
| "%s instruction %d has a non-Boolean input %d whose type is: %s.", |
| instruction->DebugName(), |
| instruction->GetId(), |
| static_cast<int>(input_index), |
| Primitive::PrettyDescriptor(input->GetType()))); |
| } |
| } |
| |
| void SSAChecker::VisitIf(HIf* instruction) { |
| VisitInstruction(instruction); |
| HandleBooleanInput(instruction, 0); |
| } |
| |
| void SSAChecker::VisitBooleanNot(HBooleanNot* instruction) { |
| VisitInstruction(instruction); |
| HandleBooleanInput(instruction, 0); |
| } |
| |
| void SSAChecker::VisitCondition(HCondition* op) { |
| VisitInstruction(op); |
| if (op->GetType() != Primitive::kPrimBoolean) { |
| AddError(StringPrintf( |
| "Condition %s %d has a non-Boolean result type: %s.", |
| op->DebugName(), op->GetId(), |
| Primitive::PrettyDescriptor(op->GetType()))); |
| } |
| HInstruction* lhs = op->InputAt(0); |
| HInstruction* rhs = op->InputAt(1); |
| if (PrimitiveKind(lhs->GetType()) != PrimitiveKind(rhs->GetType())) { |
| AddError(StringPrintf( |
| "Condition %s %d has inputs of different types: %s, and %s.", |
| op->DebugName(), op->GetId(), |
| Primitive::PrettyDescriptor(lhs->GetType()), |
| Primitive::PrettyDescriptor(rhs->GetType()))); |
| } |
| if (!op->IsEqual() && !op->IsNotEqual()) { |
| if ((lhs->GetType() == Primitive::kPrimNot)) { |
| AddError(StringPrintf( |
| "Condition %s %d uses an object as left-hand side input.", |
| op->DebugName(), op->GetId())); |
| } else if (rhs->GetType() == Primitive::kPrimNot) { |
| AddError(StringPrintf( |
| "Condition %s %d uses an object as right-hand side input.", |
| op->DebugName(), op->GetId())); |
| } |
| } |
| } |
| |
| void SSAChecker::VisitBinaryOperation(HBinaryOperation* op) { |
| VisitInstruction(op); |
| if (op->IsUShr() || op->IsShr() || op->IsShl()) { |
| if (PrimitiveKind(op->InputAt(1)->GetType()) != Primitive::kPrimInt) { |
| AddError(StringPrintf( |
| "Shift operation %s %d has a non-int kind second input: " |
| "%s of type %s.", |
| op->DebugName(), op->GetId(), |
| op->InputAt(1)->DebugName(), |
| Primitive::PrettyDescriptor(op->InputAt(1)->GetType()))); |
| } |
| } else { |
| if (PrimitiveKind(op->InputAt(0)->GetType()) != PrimitiveKind(op->InputAt(1)->GetType())) { |
| AddError(StringPrintf( |
| "Binary operation %s %d has inputs of different types: " |
| "%s, and %s.", |
| op->DebugName(), op->GetId(), |
| Primitive::PrettyDescriptor(op->InputAt(0)->GetType()), |
| Primitive::PrettyDescriptor(op->InputAt(1)->GetType()))); |
| } |
| } |
| |
| if (op->IsCompare()) { |
| if (op->GetType() != Primitive::kPrimInt) { |
| AddError(StringPrintf( |
| "Compare operation %d has a non-int result type: %s.", |
| op->GetId(), |
| Primitive::PrettyDescriptor(op->GetType()))); |
| } |
| } else { |
| // Use the first input, so that we can also make this check for shift operations. |
| if (PrimitiveKind(op->GetType()) != PrimitiveKind(op->InputAt(0)->GetType())) { |
| AddError(StringPrintf( |
| "Binary operation %s %d has a result type different " |
| "from its input type: %s vs %s.", |
| op->DebugName(), op->GetId(), |
| Primitive::PrettyDescriptor(op->GetType()), |
| Primitive::PrettyDescriptor(op->InputAt(0)->GetType()))); |
| } |
| } |
| } |
| |
| void SSAChecker::VisitConstant(HConstant* instruction) { |
| HBasicBlock* block = instruction->GetBlock(); |
| if (!block->IsEntryBlock()) { |
| AddError(StringPrintf( |
| "%s %d should be in the entry block but is in block %d.", |
| instruction->DebugName(), |
| instruction->GetId(), |
| block->GetBlockId())); |
| } |
| } |
| |
| } // namespace art |