From 2ab40eb3c23559205ac7b9b039bd749458e8a761 Mon Sep 17 00:00:00 2001 From: Jean Christophe Beyler Date: Mon, 2 Jun 2014 09:03:14 -0700 Subject: ART: Add Invokes to DecodedInstruction Add a method Invokes to test for the kInvoke flag. Also moved IsPseudoMirOp to DecodedInstruction to use it for the various querry methods. Change-Id: I59a2056b7b802b8393fa2b0d977304d252b38c89 Signed-off-by: Jean Christophe Beyler --- compiler/dex/frontend.cc | 2 +- compiler/dex/mir_analysis.cc | 2 +- compiler/dex/mir_dataflow.cc | 2 +- compiler/dex/mir_graph.cc | 9 ++++--- compiler/dex/mir_graph.h | 36 +++++++++++++++------------ compiler/dex/mir_optimization.cc | 6 ++--- compiler/dex/quick/dex_file_method_inliner.cc | 4 +-- compiler/dex/quick/mir_to_lir.cc | 2 +- compiler/dex/quick/x86/utility_x86.cc | 2 +- compiler/dex/vreg_analysis.cc | 3 ++- 10 files changed, 37 insertions(+), 31 deletions(-) diff --git a/compiler/dex/frontend.cc b/compiler/dex/frontend.cc index f3ef796480..7238bfb745 100644 --- a/compiler/dex/frontend.cc +++ b/compiler/dex/frontend.cc @@ -575,7 +575,7 @@ static bool CanCompileMethod(uint32_t method_idx, const DexFile& dex_file, // Check if we support the byte code. if (std::find(unsupport_list, unsupport_list + unsupport_list_size, opcode) != unsupport_list + unsupport_list_size) { - if (!cu.mir_graph->IsPseudoMirOp(opcode)) { + if (!MIR::DecodedInstruction::IsPseudoMirOp(opcode)) { VLOG(compiler) << "Unsupported dalvik byte code : " << mir->dalvikInsn.opcode; } else { diff --git a/compiler/dex/mir_analysis.cc b/compiler/dex/mir_analysis.cc index e372206228..3de448344a 100644 --- a/compiler/dex/mir_analysis.cc +++ b/compiler/dex/mir_analysis.cc @@ -902,7 +902,7 @@ void MIRGraph::AnalyzeBlock(BasicBlock* bb, MethodStats* stats) { while (!done) { tbb->visited = true; for (MIR* mir = tbb->first_mir_insn; mir != NULL; mir = mir->next) { - if (IsPseudoMirOp(mir->dalvikInsn.opcode)) { + if (MIR::DecodedInstruction::IsPseudoMirOp(mir->dalvikInsn.opcode)) { // Skip any MIR pseudo-op. continue; } diff --git a/compiler/dex/mir_dataflow.cc b/compiler/dex/mir_dataflow.cc index b5fdcf0628..b82c5c7f00 100644 --- a/compiler/dex/mir_dataflow.cc +++ b/compiler/dex/mir_dataflow.cc @@ -1084,7 +1084,7 @@ bool MIRGraph::DoSSAConversion(BasicBlock* bb) { uint64_t df_attributes = GetDataFlowAttributes(mir); // If not a pseudo-op, note non-leaf or can throw - if (!IsPseudoMirOp(mir->dalvikInsn.opcode)) { + if (!MIR::DecodedInstruction::IsPseudoMirOp(mir->dalvikInsn.opcode)) { int flags = Instruction::FlagsOf(mir->dalvikInsn.opcode); if ((flags & Instruction::kInvoke) != 0 && (mir->optimization_flags & MIR_INLINED) == 0) { diff --git a/compiler/dex/mir_graph.cc b/compiler/dex/mir_graph.cc index 1fbf450f6f..f3c2834d65 100644 --- a/compiler/dex/mir_graph.cc +++ b/compiler/dex/mir_graph.cc @@ -224,7 +224,7 @@ BasicBlock* MIRGraph::SplitBlock(DexOffset code_offset, DCHECK(insn == bottom_block->first_mir_insn); DCHECK_EQ(insn->offset, bottom_block->start_offset); DCHECK(static_cast(insn->dalvikInsn.opcode) == kMirOpCheck || - !IsPseudoMirOp(insn->dalvikInsn.opcode)); + !MIR::DecodedInstruction::IsPseudoMirOp(insn->dalvikInsn.opcode)); DCHECK_EQ(dex_pc_to_block_map_.Get(insn->offset), orig_block->id); MIR* p = insn; dex_pc_to_block_map_.Put(p->offset, bottom_block->id); @@ -239,7 +239,7 @@ BasicBlock* MIRGraph::SplitBlock(DexOffset code_offset, * CHECK and work portions. Since the 2nd half of a split operation is always * the first in a BasicBlock, we can't hit it here. */ - if ((opcode == kMirOpCheck) || !IsPseudoMirOp(opcode)) { + if ((opcode == kMirOpCheck) || !MIR::DecodedInstruction::IsPseudoMirOp(opcode)) { DCHECK_EQ(dex_pc_to_block_map_.Get(p->offset), orig_block->id); dex_pc_to_block_map_.Put(p->offset, bottom_block->id); } @@ -918,7 +918,8 @@ void MIRGraph::DumpCFG(const char* dir_prefix, bool all_blocks, const char *suff } else { fprintf(file, " {%04x %s %s %s %s\\l}%s\\\n", mir->offset, mir->ssa_rep ? GetDalvikDisassembly(mir) : - !IsPseudoMirOp(opcode) ? Instruction::Name(mir->dalvikInsn.opcode) : + !MIR::DecodedInstruction::IsPseudoMirOp(opcode) ? + Instruction::Name(mir->dalvikInsn.opcode) : extended_mir_op_names_[opcode - kMirOpFirst], (mir->optimization_flags & MIR_IGNORE_RANGE_CHECK) != 0 ? " no_rangecheck" : " ", (mir->optimization_flags & MIR_IGNORE_NULL_CHECK) != 0 ? " no_nullcheck" : " ", @@ -1224,7 +1225,7 @@ char* MIRGraph::GetDalvikDisassembly(const MIR* mir) { nop = true; } - if (IsPseudoMirOp(opcode)) { + if (MIR::DecodedInstruction::IsPseudoMirOp(opcode)) { str.append(extended_mir_op_names_[opcode - kMirOpFirst]); } else { dalvik_format = Instruction::FormatOf(insn.opcode); diff --git a/compiler/dex/mir_graph.h b/compiler/dex/mir_graph.h index 43c9c3c15c..1556a19da7 100644 --- a/compiler/dex/mir_graph.h +++ b/compiler/dex/mir_graph.h @@ -286,34 +286,46 @@ struct MIR { */ bool GetConstant(int64_t* ptr_value, bool* wide) const; + static bool IsPseudoMirOp(Instruction::Code opcode) { + return static_cast(opcode) >= static_cast(kMirOpFirst); + } + + static bool IsPseudoMirOp(int opcode) { + return opcode >= static_cast(kMirOpFirst); + } + + bool IsInvoke() const { + return !IsPseudoMirOp(opcode) && ((Instruction::FlagsOf(opcode) & Instruction::kInvoke) == Instruction::kInvoke); + } + bool IsStore() const { - return ((Instruction::FlagsOf(opcode) & Instruction::kStore) == Instruction::kStore); + return !IsPseudoMirOp(opcode) && ((Instruction::FlagsOf(opcode) & Instruction::kStore) == Instruction::kStore); } bool IsLoad() const { - return ((Instruction::FlagsOf(opcode) & Instruction::kLoad) == Instruction::kLoad); + return !IsPseudoMirOp(opcode) && ((Instruction::FlagsOf(opcode) & Instruction::kLoad) == Instruction::kLoad); } bool IsConditionalBranch() const { - return (Instruction::FlagsOf(opcode) == (Instruction::kContinue | Instruction::kBranch)); + return !IsPseudoMirOp(opcode) && (Instruction::FlagsOf(opcode) == (Instruction::kContinue | Instruction::kBranch)); } /** * @brief Is the register C component of the decoded instruction a constant? */ bool IsCFieldOrConstant() const { - return ((Instruction::FlagsOf(opcode) & Instruction::kRegCFieldOrConstant) == Instruction::kRegCFieldOrConstant); + return !IsPseudoMirOp(opcode) && ((Instruction::FlagsOf(opcode) & Instruction::kRegCFieldOrConstant) == Instruction::kRegCFieldOrConstant); } /** * @brief Is the register C component of the decoded instruction a constant? */ bool IsBFieldOrConstant() const { - return ((Instruction::FlagsOf(opcode) & Instruction::kRegBFieldOrConstant) == Instruction::kRegBFieldOrConstant); + return !IsPseudoMirOp(opcode) && ((Instruction::FlagsOf(opcode) & Instruction::kRegBFieldOrConstant) == Instruction::kRegBFieldOrConstant); } bool IsCast() const { - return ((Instruction::FlagsOf(opcode) & Instruction::kCast) == Instruction::kCast); + return !IsPseudoMirOp(opcode) && ((Instruction::FlagsOf(opcode) & Instruction::kCast) == Instruction::kCast); } /** @@ -323,11 +335,11 @@ struct MIR { * when crossing such an instruction. */ bool Clobbers() const { - return ((Instruction::FlagsOf(opcode) & Instruction::kClobber) == Instruction::kClobber); + return !IsPseudoMirOp(opcode) && ((Instruction::FlagsOf(opcode) & Instruction::kClobber) == Instruction::kClobber); } bool IsLinear() const { - return (Instruction::FlagsOf(opcode) & (Instruction::kAdd | Instruction::kSubtract)) != 0; + return !IsPseudoMirOp(opcode) && (Instruction::FlagsOf(opcode) & (Instruction::kAdd | Instruction::kSubtract)) != 0; } } dalvikInsn; @@ -879,14 +891,6 @@ class MIRGraph { return backward_branches_ + forward_branches_; } - static bool IsPseudoMirOp(Instruction::Code opcode) { - return static_cast(opcode) >= static_cast(kMirOpFirst); - } - - static bool IsPseudoMirOp(int opcode) { - return opcode >= static_cast(kMirOpFirst); - } - // Is this vreg in the in set? bool IsInVReg(int vreg) { return (vreg >= cu_->num_regs); diff --git a/compiler/dex/mir_optimization.cc b/compiler/dex/mir_optimization.cc index 8a474f09d9..869c48f66c 100644 --- a/compiler/dex/mir_optimization.cc +++ b/compiler/dex/mir_optimization.cc @@ -137,7 +137,7 @@ MIR* MIRGraph::FindMoveResult(BasicBlock* bb, MIR* mir) { break; } // Keep going if pseudo op, otherwise terminate - if (IsPseudoMirOp(mir->dalvikInsn.opcode)) { + if (MIR::DecodedInstruction::IsPseudoMirOp(mir->dalvikInsn.opcode)) { mir = AdvanceMIR(&tbb, mir); } else { mir = NULL; @@ -877,7 +877,7 @@ bool MIRGraph::EliminateNullChecksAndInferTypes(BasicBlock* bb) { struct BasicBlock* next_bb = GetBasicBlock(bb->fall_through); for (MIR* tmir = next_bb->first_mir_insn; tmir != NULL; tmir =tmir->next) { - if (IsPseudoMirOp(tmir->dalvikInsn.opcode)) { + if (MIR::DecodedInstruction::IsPseudoMirOp(tmir->dalvikInsn.opcode)) { continue; } // First non-pseudo should be MOVE_RESULT_OBJECT @@ -1251,7 +1251,7 @@ void MIRGraph::InlineSpecialMethods(BasicBlock* bb) { return; } for (MIR* mir = bb->first_mir_insn; mir != NULL; mir = mir->next) { - if (IsPseudoMirOp(mir->dalvikInsn.opcode)) { + if (MIR::DecodedInstruction::IsPseudoMirOp(mir->dalvikInsn.opcode)) { continue; } if (!(Instruction::FlagsOf(mir->dalvikInsn.opcode) & Instruction::kInvoke)) { diff --git a/compiler/dex/quick/dex_file_method_inliner.cc b/compiler/dex/quick/dex_file_method_inliner.cc index 6191e4b0a1..45dd7f08a6 100644 --- a/compiler/dex/quick/dex_file_method_inliner.cc +++ b/compiler/dex/quick/dex_file_method_inliner.cc @@ -96,7 +96,7 @@ MIR* AllocReplacementMIR(MIRGraph* mir_graph, MIR* invoke, MIR* move_return) { uint32_t GetInvokeReg(MIR* invoke, uint32_t arg) { DCHECK_LT(arg, invoke->dalvikInsn.vA); - DCHECK(!MIRGraph::IsPseudoMirOp(invoke->dalvikInsn.opcode)); + DCHECK(!MIR::DecodedInstruction::IsPseudoMirOp(invoke->dalvikInsn.opcode)); if (Instruction::FormatOf(invoke->dalvikInsn.opcode) == Instruction::k3rc) { return invoke->dalvikInsn.vC + arg; // Non-range invoke. } else { @@ -107,7 +107,7 @@ uint32_t GetInvokeReg(MIR* invoke, uint32_t arg) { bool WideArgIsInConsecutiveDalvikRegs(MIR* invoke, uint32_t arg) { DCHECK_LT(arg + 1, invoke->dalvikInsn.vA); - DCHECK(!MIRGraph::IsPseudoMirOp(invoke->dalvikInsn.opcode)); + DCHECK(!MIR::DecodedInstruction::IsPseudoMirOp(invoke->dalvikInsn.opcode)); return Instruction::FormatOf(invoke->dalvikInsn.opcode) == Instruction::k3rc || invoke->dalvikInsn.arg[arg + 1u] == invoke->dalvikInsn.arg[arg] + 1u; } diff --git a/compiler/dex/quick/mir_to_lir.cc b/compiler/dex/quick/mir_to_lir.cc index caadc0ad89..07c615f342 100644 --- a/compiler/dex/quick/mir_to_lir.cc +++ b/compiler/dex/quick/mir_to_lir.cc @@ -1185,7 +1185,7 @@ bool Mir2Lir::MethodBlockCodeGen(BasicBlock* bb) { work_half->meta.throw_insn = mir; } - if (MIRGraph::IsPseudoMirOp(opcode)) { + if (MIR::DecodedInstruction::IsPseudoMirOp(opcode)) { HandleExtendedMethodMIR(bb, mir); continue; } diff --git a/compiler/dex/quick/x86/utility_x86.cc b/compiler/dex/quick/x86/utility_x86.cc index 657160ffd1..5c7c91b5b5 100644 --- a/compiler/dex/quick/x86/utility_x86.cc +++ b/compiler/dex/quick/x86/utility_x86.cc @@ -917,7 +917,7 @@ void X86Mir2Lir::AnalyzeBB(BasicBlock * bb) { for (MIR *mir = bb->first_mir_insn; mir != NULL; mir = mir->next) { int opcode = mir->dalvikInsn.opcode; - if (MIRGraph::IsPseudoMirOp(opcode)) { + if (MIR::DecodedInstruction::IsPseudoMirOp(opcode)) { AnalyzeExtendedMIR(opcode, bb, mir); } else { AnalyzeMIR(opcode, bb, mir); diff --git a/compiler/dex/vreg_analysis.cc b/compiler/dex/vreg_analysis.cc index db383c4d0b..892b30284f 100644 --- a/compiler/dex/vreg_analysis.cc +++ b/compiler/dex/vreg_analysis.cc @@ -251,7 +251,8 @@ bool MIRGraph::InferTypeAndSize(BasicBlock* bb, MIR* mir, bool changed) { // Special-case handling for format 35c/3rc invokes Instruction::Code opcode = mir->dalvikInsn.opcode; - int flags = IsPseudoMirOp(opcode) ? 0 : Instruction::FlagsOf(mir->dalvikInsn.opcode); + int flags = MIR::DecodedInstruction::IsPseudoMirOp(opcode) ? + 0 : Instruction::FlagsOf(mir->dalvikInsn.opcode); if ((flags & Instruction::kInvoke) && (attrs & (DF_FORMAT_35C | DF_FORMAT_3RC))) { DCHECK_EQ(next, 0); -- cgit v1.2.3-59-g8ed1b