mir_graph.cc revision d65c51a556e6649db4e18bd083c8fec37607a442
1/* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include "mir_graph.h" 18 19#include <inttypes.h> 20 21#include "base/stl_util.h" 22#include "compiler_internals.h" 23#include "dex_file-inl.h" 24#include "dex_instruction-inl.h" 25#include "dex/quick/dex_file_to_method_inliner_map.h" 26#include "dex/quick/dex_file_method_inliner.h" 27#include "leb128.h" 28 29namespace art { 30 31#define MAX_PATTERN_LEN 5 32 33const char* MIRGraph::extended_mir_op_names_[kMirOpLast - kMirOpFirst] = { 34 "Phi", 35 "Copy", 36 "FusedCmplFloat", 37 "FusedCmpgFloat", 38 "FusedCmplDouble", 39 "FusedCmpgDouble", 40 "FusedCmpLong", 41 "Nop", 42 "OpNullCheck", 43 "OpRangeCheck", 44 "OpDivZeroCheck", 45 "Check1", 46 "Check2", 47 "Select", 48 "ConstVector", 49 "MoveVector", 50 "PackedMultiply", 51 "PackedAddition", 52 "PackedSubtract", 53 "PackedShiftLeft", 54 "PackedSignedShiftRight", 55 "PackedUnsignedShiftRight", 56 "PackedAnd", 57 "PackedOr", 58 "PackedXor", 59 "PackedAddReduce", 60 "PackedReduce", 61 "PackedSet", 62}; 63 64MIRGraph::MIRGraph(CompilationUnit* cu, ArenaAllocator* arena) 65 : reg_location_(NULL), 66 cu_(cu), 67 ssa_base_vregs_(NULL), 68 ssa_subscripts_(NULL), 69 vreg_to_ssa_map_(NULL), 70 ssa_last_defs_(NULL), 71 is_constant_v_(NULL), 72 constant_values_(NULL), 73 use_counts_(arena, 256, kGrowableArrayMisc), 74 raw_use_counts_(arena, 256, kGrowableArrayMisc), 75 num_reachable_blocks_(0), 76 dfs_order_(NULL), 77 dfs_post_order_(NULL), 78 dom_post_order_traversal_(NULL), 79 i_dom_list_(NULL), 80 def_block_matrix_(NULL), 81 temp_dalvik_register_v_(NULL), 82 temp_scoped_alloc_(), 83 temp_insn_data_(nullptr), 84 temp_bit_vector_size_(0u), 85 temp_bit_vector_(nullptr), 86 block_list_(arena, 100, kGrowableArrayBlockList), 87 try_block_addr_(NULL), 88 entry_block_(NULL), 89 exit_block_(NULL), 90 num_blocks_(0), 91 current_code_item_(NULL), 92 dex_pc_to_block_map_(arena, 0, kGrowableArrayMisc), 93 current_method_(kInvalidEntry), 94 current_offset_(kInvalidEntry), 95 def_count_(0), 96 opcode_count_(NULL), 97 num_ssa_regs_(0), 98 method_sreg_(0), 99 attributes_(METHOD_IS_LEAF), // Start with leaf assumption, change on encountering invoke. 100 checkstats_(NULL), 101 arena_(arena), 102 backward_branches_(0), 103 forward_branches_(0), 104 compiler_temps_(arena, 6, kGrowableArrayMisc), 105 num_non_special_compiler_temps_(0), 106 max_available_non_special_compiler_temps_(0), 107 punt_to_interpreter_(false), 108 merged_df_flags_(0u), 109 ifield_lowering_infos_(arena, 0u), 110 sfield_lowering_infos_(arena, 0u), 111 method_lowering_infos_(arena, 0u) { 112 try_block_addr_ = new (arena_) ArenaBitVector(arena_, 0, true /* expandable */); 113 max_available_special_compiler_temps_ = std::abs(static_cast<int>(kVRegNonSpecialTempBaseReg)) 114 - std::abs(static_cast<int>(kVRegTempBaseReg)); 115} 116 117MIRGraph::~MIRGraph() { 118 STLDeleteElements(&m_units_); 119} 120 121/* 122 * Parse an instruction, return the length of the instruction 123 */ 124int MIRGraph::ParseInsn(const uint16_t* code_ptr, MIR::DecodedInstruction* decoded_instruction) { 125 const Instruction* inst = Instruction::At(code_ptr); 126 decoded_instruction->opcode = inst->Opcode(); 127 decoded_instruction->vA = inst->HasVRegA() ? inst->VRegA() : 0; 128 decoded_instruction->vB = inst->HasVRegB() ? inst->VRegB() : 0; 129 decoded_instruction->vB_wide = inst->HasWideVRegB() ? inst->WideVRegB() : 0; 130 decoded_instruction->vC = inst->HasVRegC() ? inst->VRegC() : 0; 131 if (inst->HasVarArgs()) { 132 inst->GetVarArgs(decoded_instruction->arg); 133 } 134 return inst->SizeInCodeUnits(); 135} 136 137 138/* Split an existing block from the specified code offset into two */ 139BasicBlock* MIRGraph::SplitBlock(DexOffset code_offset, 140 BasicBlock* orig_block, BasicBlock** immed_pred_block_p) { 141 DCHECK_GT(code_offset, orig_block->start_offset); 142 MIR* insn = orig_block->first_mir_insn; 143 MIR* prev = NULL; 144 while (insn) { 145 if (insn->offset == code_offset) break; 146 prev = insn; 147 insn = insn->next; 148 } 149 if (insn == NULL) { 150 LOG(FATAL) << "Break split failed"; 151 } 152 BasicBlock *bottom_block = NewMemBB(kDalvikByteCode, num_blocks_++); 153 block_list_.Insert(bottom_block); 154 155 bottom_block->start_offset = code_offset; 156 bottom_block->first_mir_insn = insn; 157 bottom_block->last_mir_insn = orig_block->last_mir_insn; 158 159 /* If this block was terminated by a return, the flag needs to go with the bottom block */ 160 bottom_block->terminated_by_return = orig_block->terminated_by_return; 161 orig_block->terminated_by_return = false; 162 163 /* Handle the taken path */ 164 bottom_block->taken = orig_block->taken; 165 if (bottom_block->taken != NullBasicBlockId) { 166 orig_block->taken = NullBasicBlockId; 167 BasicBlock* bb_taken = GetBasicBlock(bottom_block->taken); 168 bb_taken->predecessors->Delete(orig_block->id); 169 bb_taken->predecessors->Insert(bottom_block->id); 170 } 171 172 /* Handle the fallthrough path */ 173 bottom_block->fall_through = orig_block->fall_through; 174 orig_block->fall_through = bottom_block->id; 175 bottom_block->predecessors->Insert(orig_block->id); 176 if (bottom_block->fall_through != NullBasicBlockId) { 177 BasicBlock* bb_fall_through = GetBasicBlock(bottom_block->fall_through); 178 bb_fall_through->predecessors->Delete(orig_block->id); 179 bb_fall_through->predecessors->Insert(bottom_block->id); 180 } 181 182 /* Handle the successor list */ 183 if (orig_block->successor_block_list_type != kNotUsed) { 184 bottom_block->successor_block_list_type = orig_block->successor_block_list_type; 185 bottom_block->successor_blocks = orig_block->successor_blocks; 186 orig_block->successor_block_list_type = kNotUsed; 187 orig_block->successor_blocks = NULL; 188 GrowableArray<SuccessorBlockInfo*>::Iterator iterator(bottom_block->successor_blocks); 189 while (true) { 190 SuccessorBlockInfo *successor_block_info = iterator.Next(); 191 if (successor_block_info == NULL) break; 192 BasicBlock *bb = GetBasicBlock(successor_block_info->block); 193 bb->predecessors->Delete(orig_block->id); 194 bb->predecessors->Insert(bottom_block->id); 195 } 196 } 197 198 orig_block->last_mir_insn = prev; 199 prev->next = NULL; 200 201 /* 202 * Update the immediate predecessor block pointer so that outgoing edges 203 * can be applied to the proper block. 204 */ 205 if (immed_pred_block_p) { 206 DCHECK_EQ(*immed_pred_block_p, orig_block); 207 *immed_pred_block_p = bottom_block; 208 } 209 210 // Associate dex instructions in the bottom block with the new container. 211 DCHECK(insn != nullptr); 212 DCHECK(insn != orig_block->first_mir_insn); 213 DCHECK(insn == bottom_block->first_mir_insn); 214 DCHECK_EQ(insn->offset, bottom_block->start_offset); 215 DCHECK(static_cast<int>(insn->dalvikInsn.opcode) == kMirOpCheck || 216 !IsPseudoMirOp(insn->dalvikInsn.opcode)); 217 DCHECK_EQ(dex_pc_to_block_map_.Get(insn->offset), orig_block->id); 218 MIR* p = insn; 219 dex_pc_to_block_map_.Put(p->offset, bottom_block->id); 220 while (p != bottom_block->last_mir_insn) { 221 p = p->next; 222 DCHECK(p != nullptr); 223 int opcode = p->dalvikInsn.opcode; 224 /* 225 * Some messiness here to ensure that we only enter real opcodes and only the 226 * first half of a potentially throwing instruction that has been split into 227 * CHECK and work portions. Since the 2nd half of a split operation is always 228 * the first in a BasicBlock, we can't hit it here. 229 */ 230 if ((opcode == kMirOpCheck) || !IsPseudoMirOp(opcode)) { 231 DCHECK_EQ(dex_pc_to_block_map_.Get(p->offset), orig_block->id); 232 dex_pc_to_block_map_.Put(p->offset, bottom_block->id); 233 } 234 } 235 236 return bottom_block; 237} 238 239/* 240 * Given a code offset, find out the block that starts with it. If the offset 241 * is in the middle of an existing block, split it into two. If immed_pred_block_p 242 * is not non-null and is the block being split, update *immed_pred_block_p to 243 * point to the bottom block so that outgoing edges can be set up properly 244 * (by the caller) 245 * Utilizes a map for fast lookup of the typical cases. 246 */ 247BasicBlock* MIRGraph::FindBlock(DexOffset code_offset, bool split, bool create, 248 BasicBlock** immed_pred_block_p) { 249 if (code_offset >= cu_->code_item->insns_size_in_code_units_) { 250 return NULL; 251 } 252 253 int block_id = dex_pc_to_block_map_.Get(code_offset); 254 BasicBlock* bb = (block_id == 0) ? NULL : block_list_.Get(block_id); 255 256 if ((bb != NULL) && (bb->start_offset == code_offset)) { 257 // Does this containing block start with the desired instruction? 258 return bb; 259 } 260 261 // No direct hit. 262 if (!create) { 263 return NULL; 264 } 265 266 if (bb != NULL) { 267 // The target exists somewhere in an existing block. 268 return SplitBlock(code_offset, bb, bb == *immed_pred_block_p ? immed_pred_block_p : NULL); 269 } 270 271 // Create a new block. 272 bb = NewMemBB(kDalvikByteCode, num_blocks_++); 273 block_list_.Insert(bb); 274 bb->start_offset = code_offset; 275 dex_pc_to_block_map_.Put(bb->start_offset, bb->id); 276 return bb; 277} 278 279 280/* Identify code range in try blocks and set up the empty catch blocks */ 281void MIRGraph::ProcessTryCatchBlocks() { 282 int tries_size = current_code_item_->tries_size_; 283 DexOffset offset; 284 285 if (tries_size == 0) { 286 return; 287 } 288 289 for (int i = 0; i < tries_size; i++) { 290 const DexFile::TryItem* pTry = 291 DexFile::GetTryItems(*current_code_item_, i); 292 DexOffset start_offset = pTry->start_addr_; 293 DexOffset end_offset = start_offset + pTry->insn_count_; 294 for (offset = start_offset; offset < end_offset; offset++) { 295 try_block_addr_->SetBit(offset); 296 } 297 } 298 299 // Iterate over each of the handlers to enqueue the empty Catch blocks 300 const byte* handlers_ptr = DexFile::GetCatchHandlerData(*current_code_item_, 0); 301 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr); 302 for (uint32_t idx = 0; idx < handlers_size; idx++) { 303 CatchHandlerIterator iterator(handlers_ptr); 304 for (; iterator.HasNext(); iterator.Next()) { 305 uint32_t address = iterator.GetHandlerAddress(); 306 FindBlock(address, false /* split */, true /*create*/, 307 /* immed_pred_block_p */ NULL); 308 } 309 handlers_ptr = iterator.EndDataPointer(); 310 } 311} 312 313/* Process instructions with the kBranch flag */ 314BasicBlock* MIRGraph::ProcessCanBranch(BasicBlock* cur_block, MIR* insn, DexOffset cur_offset, 315 int width, int flags, const uint16_t* code_ptr, 316 const uint16_t* code_end) { 317 DexOffset target = cur_offset; 318 switch (insn->dalvikInsn.opcode) { 319 case Instruction::GOTO: 320 case Instruction::GOTO_16: 321 case Instruction::GOTO_32: 322 target += insn->dalvikInsn.vA; 323 break; 324 case Instruction::IF_EQ: 325 case Instruction::IF_NE: 326 case Instruction::IF_LT: 327 case Instruction::IF_GE: 328 case Instruction::IF_GT: 329 case Instruction::IF_LE: 330 cur_block->conditional_branch = true; 331 target += insn->dalvikInsn.vC; 332 break; 333 case Instruction::IF_EQZ: 334 case Instruction::IF_NEZ: 335 case Instruction::IF_LTZ: 336 case Instruction::IF_GEZ: 337 case Instruction::IF_GTZ: 338 case Instruction::IF_LEZ: 339 cur_block->conditional_branch = true; 340 target += insn->dalvikInsn.vB; 341 break; 342 default: 343 LOG(FATAL) << "Unexpected opcode(" << insn->dalvikInsn.opcode << ") with kBranch set"; 344 } 345 CountBranch(target); 346 BasicBlock *taken_block = FindBlock(target, /* split */ true, /* create */ true, 347 /* immed_pred_block_p */ &cur_block); 348 cur_block->taken = taken_block->id; 349 taken_block->predecessors->Insert(cur_block->id); 350 351 /* Always terminate the current block for conditional branches */ 352 if (flags & Instruction::kContinue) { 353 BasicBlock *fallthrough_block = FindBlock(cur_offset + width, 354 /* 355 * If the method is processed 356 * in sequential order from the 357 * beginning, we don't need to 358 * specify split for continue 359 * blocks. However, this 360 * routine can be called by 361 * compileLoop, which starts 362 * parsing the method from an 363 * arbitrary address in the 364 * method body. 365 */ 366 true, 367 /* create */ 368 true, 369 /* immed_pred_block_p */ 370 &cur_block); 371 cur_block->fall_through = fallthrough_block->id; 372 fallthrough_block->predecessors->Insert(cur_block->id); 373 } else if (code_ptr < code_end) { 374 FindBlock(cur_offset + width, /* split */ false, /* create */ true, 375 /* immed_pred_block_p */ NULL); 376 } 377 return cur_block; 378} 379 380/* Process instructions with the kSwitch flag */ 381BasicBlock* MIRGraph::ProcessCanSwitch(BasicBlock* cur_block, MIR* insn, DexOffset cur_offset, 382 int width, int flags) { 383 const uint16_t* switch_data = 384 reinterpret_cast<const uint16_t*>(GetCurrentInsns() + cur_offset + insn->dalvikInsn.vB); 385 int size; 386 const int* keyTable; 387 const int* target_table; 388 int i; 389 int first_key; 390 391 /* 392 * Packed switch data format: 393 * ushort ident = 0x0100 magic value 394 * ushort size number of entries in the table 395 * int first_key first (and lowest) switch case value 396 * int targets[size] branch targets, relative to switch opcode 397 * 398 * Total size is (4+size*2) 16-bit code units. 399 */ 400 if (insn->dalvikInsn.opcode == Instruction::PACKED_SWITCH) { 401 DCHECK_EQ(static_cast<int>(switch_data[0]), 402 static_cast<int>(Instruction::kPackedSwitchSignature)); 403 size = switch_data[1]; 404 first_key = switch_data[2] | (switch_data[3] << 16); 405 target_table = reinterpret_cast<const int*>(&switch_data[4]); 406 keyTable = NULL; // Make the compiler happy 407 /* 408 * Sparse switch data format: 409 * ushort ident = 0x0200 magic value 410 * ushort size number of entries in the table; > 0 411 * int keys[size] keys, sorted low-to-high; 32-bit aligned 412 * int targets[size] branch targets, relative to switch opcode 413 * 414 * Total size is (2+size*4) 16-bit code units. 415 */ 416 } else { 417 DCHECK_EQ(static_cast<int>(switch_data[0]), 418 static_cast<int>(Instruction::kSparseSwitchSignature)); 419 size = switch_data[1]; 420 keyTable = reinterpret_cast<const int*>(&switch_data[2]); 421 target_table = reinterpret_cast<const int*>(&switch_data[2 + size*2]); 422 first_key = 0; // To make the compiler happy 423 } 424 425 if (cur_block->successor_block_list_type != kNotUsed) { 426 LOG(FATAL) << "Successor block list already in use: " 427 << static_cast<int>(cur_block->successor_block_list_type); 428 } 429 cur_block->successor_block_list_type = 430 (insn->dalvikInsn.opcode == Instruction::PACKED_SWITCH) ? kPackedSwitch : kSparseSwitch; 431 cur_block->successor_blocks = 432 new (arena_) GrowableArray<SuccessorBlockInfo*>(arena_, size, kGrowableArraySuccessorBlocks); 433 434 for (i = 0; i < size; i++) { 435 BasicBlock *case_block = FindBlock(cur_offset + target_table[i], /* split */ true, 436 /* create */ true, /* immed_pred_block_p */ &cur_block); 437 SuccessorBlockInfo *successor_block_info = 438 static_cast<SuccessorBlockInfo*>(arena_->Alloc(sizeof(SuccessorBlockInfo), 439 kArenaAllocSuccessor)); 440 successor_block_info->block = case_block->id; 441 successor_block_info->key = 442 (insn->dalvikInsn.opcode == Instruction::PACKED_SWITCH) ? 443 first_key + i : keyTable[i]; 444 cur_block->successor_blocks->Insert(successor_block_info); 445 case_block->predecessors->Insert(cur_block->id); 446 } 447 448 /* Fall-through case */ 449 BasicBlock* fallthrough_block = FindBlock(cur_offset + width, /* split */ false, 450 /* create */ true, /* immed_pred_block_p */ NULL); 451 cur_block->fall_through = fallthrough_block->id; 452 fallthrough_block->predecessors->Insert(cur_block->id); 453 return cur_block; 454} 455 456/* Process instructions with the kThrow flag */ 457BasicBlock* MIRGraph::ProcessCanThrow(BasicBlock* cur_block, MIR* insn, DexOffset cur_offset, 458 int width, int flags, ArenaBitVector* try_block_addr, 459 const uint16_t* code_ptr, const uint16_t* code_end) { 460 bool in_try_block = try_block_addr->IsBitSet(cur_offset); 461 bool is_throw = (insn->dalvikInsn.opcode == Instruction::THROW); 462 bool build_all_edges = 463 (cu_->disable_opt & (1 << kSuppressExceptionEdges)) || is_throw || in_try_block; 464 465 /* In try block */ 466 if (in_try_block) { 467 CatchHandlerIterator iterator(*current_code_item_, cur_offset); 468 469 if (cur_block->successor_block_list_type != kNotUsed) { 470 LOG(INFO) << PrettyMethod(cu_->method_idx, *cu_->dex_file); 471 LOG(FATAL) << "Successor block list already in use: " 472 << static_cast<int>(cur_block->successor_block_list_type); 473 } 474 475 cur_block->successor_block_list_type = kCatch; 476 cur_block->successor_blocks = 477 new (arena_) GrowableArray<SuccessorBlockInfo*>(arena_, 2, kGrowableArraySuccessorBlocks); 478 479 for (; iterator.HasNext(); iterator.Next()) { 480 BasicBlock *catch_block = FindBlock(iterator.GetHandlerAddress(), false /* split*/, 481 false /* creat */, NULL /* immed_pred_block_p */); 482 catch_block->catch_entry = true; 483 if (kIsDebugBuild) { 484 catches_.insert(catch_block->start_offset); 485 } 486 SuccessorBlockInfo *successor_block_info = reinterpret_cast<SuccessorBlockInfo*> 487 (arena_->Alloc(sizeof(SuccessorBlockInfo), kArenaAllocSuccessor)); 488 successor_block_info->block = catch_block->id; 489 successor_block_info->key = iterator.GetHandlerTypeIndex(); 490 cur_block->successor_blocks->Insert(successor_block_info); 491 catch_block->predecessors->Insert(cur_block->id); 492 } 493 } else if (build_all_edges) { 494 BasicBlock *eh_block = NewMemBB(kExceptionHandling, num_blocks_++); 495 cur_block->taken = eh_block->id; 496 block_list_.Insert(eh_block); 497 eh_block->start_offset = cur_offset; 498 eh_block->predecessors->Insert(cur_block->id); 499 } 500 501 if (is_throw) { 502 cur_block->explicit_throw = true; 503 if (code_ptr < code_end) { 504 // Force creation of new block following THROW via side-effect 505 FindBlock(cur_offset + width, /* split */ false, /* create */ true, 506 /* immed_pred_block_p */ NULL); 507 } 508 if (!in_try_block) { 509 // Don't split a THROW that can't rethrow - we're done. 510 return cur_block; 511 } 512 } 513 514 if (!build_all_edges) { 515 /* 516 * Even though there is an exception edge here, control cannot return to this 517 * method. Thus, for the purposes of dataflow analysis and optimization, we can 518 * ignore the edge. Doing this reduces compile time, and increases the scope 519 * of the basic-block level optimization pass. 520 */ 521 return cur_block; 522 } 523 524 /* 525 * Split the potentially-throwing instruction into two parts. 526 * The first half will be a pseudo-op that captures the exception 527 * edges and terminates the basic block. It always falls through. 528 * Then, create a new basic block that begins with the throwing instruction 529 * (minus exceptions). Note: this new basic block must NOT be entered into 530 * the block_map. If the potentially-throwing instruction is the target of a 531 * future branch, we need to find the check psuedo half. The new 532 * basic block containing the work portion of the instruction should 533 * only be entered via fallthrough from the block containing the 534 * pseudo exception edge MIR. Note also that this new block is 535 * not automatically terminated after the work portion, and may 536 * contain following instructions. 537 * 538 * Note also that the dex_pc_to_block_map_ entry for the potentially 539 * throwing instruction will refer to the original basic block. 540 */ 541 BasicBlock *new_block = NewMemBB(kDalvikByteCode, num_blocks_++); 542 block_list_.Insert(new_block); 543 new_block->start_offset = insn->offset; 544 cur_block->fall_through = new_block->id; 545 new_block->predecessors->Insert(cur_block->id); 546 MIR* new_insn = static_cast<MIR*>(arena_->Alloc(sizeof(MIR), kArenaAllocMIR)); 547 *new_insn = *insn; 548 insn->dalvikInsn.opcode = 549 static_cast<Instruction::Code>(kMirOpCheck); 550 // Associate the two halves 551 insn->meta.throw_insn = new_insn; 552 new_block->AppendMIR(new_insn); 553 return new_block; 554} 555 556/* Parse a Dex method and insert it into the MIRGraph at the current insert point. */ 557void MIRGraph::InlineMethod(const DexFile::CodeItem* code_item, uint32_t access_flags, 558 InvokeType invoke_type, uint16_t class_def_idx, 559 uint32_t method_idx, jobject class_loader, const DexFile& dex_file) { 560 current_code_item_ = code_item; 561 method_stack_.push_back(std::make_pair(current_method_, current_offset_)); 562 current_method_ = m_units_.size(); 563 current_offset_ = 0; 564 // TODO: will need to snapshot stack image and use that as the mir context identification. 565 m_units_.push_back(new DexCompilationUnit(cu_, class_loader, Runtime::Current()->GetClassLinker(), 566 dex_file, current_code_item_, class_def_idx, method_idx, access_flags, 567 cu_->compiler_driver->GetVerifiedMethod(&dex_file, method_idx))); 568 const uint16_t* code_ptr = current_code_item_->insns_; 569 const uint16_t* code_end = 570 current_code_item_->insns_ + current_code_item_->insns_size_in_code_units_; 571 572 // TODO: need to rework expansion of block list & try_block_addr when inlining activated. 573 // TUNING: use better estimate of basic blocks for following resize. 574 block_list_.Resize(block_list_.Size() + current_code_item_->insns_size_in_code_units_); 575 dex_pc_to_block_map_.SetSize(dex_pc_to_block_map_.Size() + current_code_item_->insns_size_in_code_units_); 576 577 // TODO: replace with explicit resize routine. Using automatic extension side effect for now. 578 try_block_addr_->SetBit(current_code_item_->insns_size_in_code_units_); 579 try_block_addr_->ClearBit(current_code_item_->insns_size_in_code_units_); 580 581 // If this is the first method, set up default entry and exit blocks. 582 if (current_method_ == 0) { 583 DCHECK(entry_block_ == NULL); 584 DCHECK(exit_block_ == NULL); 585 DCHECK_EQ(num_blocks_, 0); 586 // Use id 0 to represent a null block. 587 BasicBlock* null_block = NewMemBB(kNullBlock, num_blocks_++); 588 DCHECK_EQ(null_block->id, NullBasicBlockId); 589 null_block->hidden = true; 590 block_list_.Insert(null_block); 591 entry_block_ = NewMemBB(kEntryBlock, num_blocks_++); 592 block_list_.Insert(entry_block_); 593 exit_block_ = NewMemBB(kExitBlock, num_blocks_++); 594 block_list_.Insert(exit_block_); 595 // TODO: deprecate all "cu->" fields; move what's left to wherever CompilationUnit is allocated. 596 cu_->dex_file = &dex_file; 597 cu_->class_def_idx = class_def_idx; 598 cu_->method_idx = method_idx; 599 cu_->access_flags = access_flags; 600 cu_->invoke_type = invoke_type; 601 cu_->shorty = dex_file.GetMethodShorty(dex_file.GetMethodId(method_idx)); 602 cu_->num_ins = current_code_item_->ins_size_; 603 cu_->num_regs = current_code_item_->registers_size_ - cu_->num_ins; 604 cu_->num_outs = current_code_item_->outs_size_; 605 cu_->num_dalvik_registers = current_code_item_->registers_size_; 606 cu_->insns = current_code_item_->insns_; 607 cu_->code_item = current_code_item_; 608 } else { 609 UNIMPLEMENTED(FATAL) << "Nested inlining not implemented."; 610 /* 611 * Will need to manage storage for ins & outs, push prevous state and update 612 * insert point. 613 */ 614 } 615 616 /* Current block to record parsed instructions */ 617 BasicBlock *cur_block = NewMemBB(kDalvikByteCode, num_blocks_++); 618 DCHECK_EQ(current_offset_, 0U); 619 cur_block->start_offset = current_offset_; 620 block_list_.Insert(cur_block); 621 // TODO: for inlining support, insert at the insert point rather than entry block. 622 entry_block_->fall_through = cur_block->id; 623 cur_block->predecessors->Insert(entry_block_->id); 624 625 /* Identify code range in try blocks and set up the empty catch blocks */ 626 ProcessTryCatchBlocks(); 627 628 uint64_t merged_df_flags = 0u; 629 630 /* Parse all instructions and put them into containing basic blocks */ 631 while (code_ptr < code_end) { 632 MIR *insn = static_cast<MIR *>(arena_->Alloc(sizeof(MIR), kArenaAllocMIR)); 633 insn->offset = current_offset_; 634 insn->m_unit_index = current_method_; 635 int width = ParseInsn(code_ptr, &insn->dalvikInsn); 636 insn->width = width; 637 Instruction::Code opcode = insn->dalvikInsn.opcode; 638 if (opcode_count_ != NULL) { 639 opcode_count_[static_cast<int>(opcode)]++; 640 } 641 642 int flags = Instruction::FlagsOf(insn->dalvikInsn.opcode); 643 int verify_flags = Instruction::VerifyFlagsOf(insn->dalvikInsn.opcode); 644 645 uint64_t df_flags = GetDataFlowAttributes(insn); 646 merged_df_flags |= df_flags; 647 648 if (df_flags & DF_HAS_DEFS) { 649 def_count_ += (df_flags & DF_A_WIDE) ? 2 : 1; 650 } 651 652 if (df_flags & DF_LVN) { 653 cur_block->use_lvn = true; // Run local value numbering on this basic block. 654 } 655 656 // Check for inline data block signatures 657 if (opcode == Instruction::NOP) { 658 // A simple NOP will have a width of 1 at this point, embedded data NOP > 1. 659 if ((width == 1) && ((current_offset_ & 0x1) == 0x1) && ((code_end - code_ptr) > 1)) { 660 // Could be an aligning nop. If an embedded data NOP follows, treat pair as single unit. 661 uint16_t following_raw_instruction = code_ptr[1]; 662 if ((following_raw_instruction == Instruction::kSparseSwitchSignature) || 663 (following_raw_instruction == Instruction::kPackedSwitchSignature) || 664 (following_raw_instruction == Instruction::kArrayDataSignature)) { 665 width += Instruction::At(code_ptr + 1)->SizeInCodeUnits(); 666 } 667 } 668 if (width == 1) { 669 // It is a simple nop - treat normally. 670 cur_block->AppendMIR(insn); 671 } else { 672 DCHECK(cur_block->fall_through == NullBasicBlockId); 673 DCHECK(cur_block->taken == NullBasicBlockId); 674 // Unreachable instruction, mark for no continuation. 675 flags &= ~Instruction::kContinue; 676 } 677 } else { 678 cur_block->AppendMIR(insn); 679 } 680 681 // Associate the starting dex_pc for this opcode with its containing basic block. 682 dex_pc_to_block_map_.Put(insn->offset, cur_block->id); 683 684 code_ptr += width; 685 686 if (flags & Instruction::kBranch) { 687 cur_block = ProcessCanBranch(cur_block, insn, current_offset_, 688 width, flags, code_ptr, code_end); 689 } else if (flags & Instruction::kReturn) { 690 cur_block->terminated_by_return = true; 691 cur_block->fall_through = exit_block_->id; 692 exit_block_->predecessors->Insert(cur_block->id); 693 /* 694 * Terminate the current block if there are instructions 695 * afterwards. 696 */ 697 if (code_ptr < code_end) { 698 /* 699 * Create a fallthrough block for real instructions 700 * (incl. NOP). 701 */ 702 FindBlock(current_offset_ + width, /* split */ false, /* create */ true, 703 /* immed_pred_block_p */ NULL); 704 } 705 } else if (flags & Instruction::kThrow) { 706 cur_block = ProcessCanThrow(cur_block, insn, current_offset_, width, flags, try_block_addr_, 707 code_ptr, code_end); 708 } else if (flags & Instruction::kSwitch) { 709 cur_block = ProcessCanSwitch(cur_block, insn, current_offset_, width, flags); 710 } 711 if (verify_flags & Instruction::kVerifyVarArgRange) { 712 /* 713 * The Quick backend's runtime model includes a gap between a method's 714 * argument ("in") vregs and the rest of its vregs. Handling a range instruction 715 * which spans the gap is somewhat complicated, and should not happen 716 * in normal usage of dx. Punt to the interpreter. 717 */ 718 int first_reg_in_range = insn->dalvikInsn.vC; 719 int last_reg_in_range = first_reg_in_range + insn->dalvikInsn.vA - 1; 720 if (IsInVReg(first_reg_in_range) != IsInVReg(last_reg_in_range)) { 721 punt_to_interpreter_ = true; 722 } 723 } 724 current_offset_ += width; 725 BasicBlock *next_block = FindBlock(current_offset_, /* split */ false, /* create */ 726 false, /* immed_pred_block_p */ NULL); 727 if (next_block) { 728 /* 729 * The next instruction could be the target of a previously parsed 730 * forward branch so a block is already created. If the current 731 * instruction is not an unconditional branch, connect them through 732 * the fall-through link. 733 */ 734 DCHECK(cur_block->fall_through == NullBasicBlockId || 735 GetBasicBlock(cur_block->fall_through) == next_block || 736 GetBasicBlock(cur_block->fall_through) == exit_block_); 737 738 if ((cur_block->fall_through == NullBasicBlockId) && (flags & Instruction::kContinue)) { 739 cur_block->fall_through = next_block->id; 740 next_block->predecessors->Insert(cur_block->id); 741 } 742 cur_block = next_block; 743 } 744 } 745 merged_df_flags_ = merged_df_flags; 746 747 if (cu_->enable_debug & (1 << kDebugDumpCFG)) { 748 DumpCFG("/sdcard/1_post_parse_cfg/", true); 749 } 750 751 if (cu_->verbose) { 752 DumpMIRGraph(); 753 } 754} 755 756void MIRGraph::ShowOpcodeStats() { 757 DCHECK(opcode_count_ != NULL); 758 LOG(INFO) << "Opcode Count"; 759 for (int i = 0; i < kNumPackedOpcodes; i++) { 760 if (opcode_count_[i] != 0) { 761 LOG(INFO) << "-C- " << Instruction::Name(static_cast<Instruction::Code>(i)) 762 << " " << opcode_count_[i]; 763 } 764 } 765} 766 767uint64_t MIRGraph::GetDataFlowAttributes(Instruction::Code opcode) { 768 DCHECK_LT((size_t) opcode, (sizeof(oat_data_flow_attributes_) / sizeof(oat_data_flow_attributes_[0]))); 769 return oat_data_flow_attributes_[opcode]; 770} 771 772uint64_t MIRGraph::GetDataFlowAttributes(MIR* mir) { 773 DCHECK(mir != nullptr); 774 Instruction::Code opcode = mir->dalvikInsn.opcode; 775 return GetDataFlowAttributes(opcode); 776} 777 778// TODO: use a configurable base prefix, and adjust callers to supply pass name. 779/* Dump the CFG into a DOT graph */ 780void MIRGraph::DumpCFG(const char* dir_prefix, bool all_blocks, const char *suffix) { 781 FILE* file; 782 std::string fname(PrettyMethod(cu_->method_idx, *cu_->dex_file)); 783 ReplaceSpecialChars(fname); 784 fname = StringPrintf("%s%s%x%s.dot", dir_prefix, fname.c_str(), 785 GetBasicBlock(GetEntryBlock()->fall_through)->start_offset, 786 suffix == nullptr ? "" : suffix); 787 file = fopen(fname.c_str(), "w"); 788 if (file == NULL) { 789 return; 790 } 791 fprintf(file, "digraph G {\n"); 792 793 fprintf(file, " rankdir=TB\n"); 794 795 int num_blocks = all_blocks ? GetNumBlocks() : num_reachable_blocks_; 796 int idx; 797 798 for (idx = 0; idx < num_blocks; idx++) { 799 int block_idx = all_blocks ? idx : dfs_order_->Get(idx); 800 BasicBlock *bb = GetBasicBlock(block_idx); 801 if (bb == NULL) continue; 802 if (bb->block_type == kDead) continue; 803 if (bb->block_type == kEntryBlock) { 804 fprintf(file, " entry_%d [shape=Mdiamond];\n", bb->id); 805 } else if (bb->block_type == kExitBlock) { 806 fprintf(file, " exit_%d [shape=Mdiamond];\n", bb->id); 807 } else if (bb->block_type == kDalvikByteCode) { 808 fprintf(file, " block%04x_%d [shape=record,label = \"{ \\\n", 809 bb->start_offset, bb->id); 810 const MIR *mir; 811 fprintf(file, " {block id %d\\l}%s\\\n", bb->id, 812 bb->first_mir_insn ? " | " : " "); 813 for (mir = bb->first_mir_insn; mir; mir = mir->next) { 814 int opcode = mir->dalvikInsn.opcode; 815 if (opcode > kMirOpSelect && opcode < kMirOpLast) { 816 if (opcode == kMirOpConstVector) { 817 fprintf(file, " {%04x %s %d %d %d %d %d %d\\l}%s\\\n", mir->offset, 818 extended_mir_op_names_[kMirOpConstVector - kMirOpFirst], 819 mir->dalvikInsn.vA, 820 mir->dalvikInsn.vB, 821 mir->dalvikInsn.arg[0], 822 mir->dalvikInsn.arg[1], 823 mir->dalvikInsn.arg[2], 824 mir->dalvikInsn.arg[3], 825 mir->next ? " | " : " "); 826 } else { 827 fprintf(file, " {%04x %s %d %d %d\\l}%s\\\n", mir->offset, 828 extended_mir_op_names_[opcode - kMirOpFirst], 829 mir->dalvikInsn.vA, 830 mir->dalvikInsn.vB, 831 mir->dalvikInsn.vC, 832 mir->next ? " | " : " "); 833 } 834 } else { 835 fprintf(file, " {%04x %s %s %s\\l}%s\\\n", mir->offset, 836 mir->ssa_rep ? GetDalvikDisassembly(mir) : 837 (opcode < kMirOpFirst) ? 838 Instruction::Name(mir->dalvikInsn.opcode) : 839 extended_mir_op_names_[opcode - kMirOpFirst], 840 (mir->optimization_flags & MIR_IGNORE_RANGE_CHECK) != 0 ? " no_rangecheck" : " ", 841 (mir->optimization_flags & MIR_IGNORE_NULL_CHECK) != 0 ? " no_nullcheck" : " ", 842 mir->next ? " | " : " "); 843 } 844 } 845 fprintf(file, " }\"];\n\n"); 846 } else if (bb->block_type == kExceptionHandling) { 847 char block_name[BLOCK_NAME_LEN]; 848 849 GetBlockName(bb, block_name); 850 fprintf(file, " %s [shape=invhouse];\n", block_name); 851 } 852 853 char block_name1[BLOCK_NAME_LEN], block_name2[BLOCK_NAME_LEN]; 854 855 if (bb->taken != NullBasicBlockId) { 856 GetBlockName(bb, block_name1); 857 GetBlockName(GetBasicBlock(bb->taken), block_name2); 858 fprintf(file, " %s:s -> %s:n [style=dotted]\n", 859 block_name1, block_name2); 860 } 861 if (bb->fall_through != NullBasicBlockId) { 862 GetBlockName(bb, block_name1); 863 GetBlockName(GetBasicBlock(bb->fall_through), block_name2); 864 fprintf(file, " %s:s -> %s:n\n", block_name1, block_name2); 865 } 866 867 if (bb->successor_block_list_type != kNotUsed) { 868 fprintf(file, " succ%04x_%d [shape=%s,label = \"{ \\\n", 869 bb->start_offset, bb->id, 870 (bb->successor_block_list_type == kCatch) ? "Mrecord" : "record"); 871 GrowableArray<SuccessorBlockInfo*>::Iterator iterator(bb->successor_blocks); 872 SuccessorBlockInfo *successor_block_info = iterator.Next(); 873 874 int succ_id = 0; 875 while (true) { 876 if (successor_block_info == NULL) break; 877 878 BasicBlock *dest_block = GetBasicBlock(successor_block_info->block); 879 SuccessorBlockInfo *next_successor_block_info = iterator.Next(); 880 881 fprintf(file, " {<f%d> %04x: %04x\\l}%s\\\n", 882 succ_id++, 883 successor_block_info->key, 884 dest_block->start_offset, 885 (next_successor_block_info != NULL) ? " | " : " "); 886 887 successor_block_info = next_successor_block_info; 888 } 889 fprintf(file, " }\"];\n\n"); 890 891 GetBlockName(bb, block_name1); 892 fprintf(file, " %s:s -> succ%04x_%d:n [style=dashed]\n", 893 block_name1, bb->start_offset, bb->id); 894 895 // Link the successor pseudo-block with all of its potential targets. 896 GrowableArray<SuccessorBlockInfo*>::Iterator iter(bb->successor_blocks); 897 898 succ_id = 0; 899 while (true) { 900 SuccessorBlockInfo *successor_block_info = iter.Next(); 901 if (successor_block_info == NULL) break; 902 903 BasicBlock* dest_block = GetBasicBlock(successor_block_info->block); 904 905 GetBlockName(dest_block, block_name2); 906 fprintf(file, " succ%04x_%d:f%d:e -> %s:n\n", bb->start_offset, 907 bb->id, succ_id++, block_name2); 908 } 909 } 910 fprintf(file, "\n"); 911 912 if (cu_->verbose) { 913 /* Display the dominator tree */ 914 GetBlockName(bb, block_name1); 915 fprintf(file, " cfg%s [label=\"%s\", shape=none];\n", 916 block_name1, block_name1); 917 if (bb->i_dom) { 918 GetBlockName(GetBasicBlock(bb->i_dom), block_name2); 919 fprintf(file, " cfg%s:s -> cfg%s:n\n\n", block_name2, block_name1); 920 } 921 } 922 } 923 fprintf(file, "}\n"); 924 fclose(file); 925} 926 927/* Insert an MIR instruction to the end of a basic block */ 928void BasicBlock::AppendMIR(MIR* mir) { 929 if (first_mir_insn == nullptr) { 930 DCHECK(last_mir_insn == nullptr); 931 last_mir_insn = first_mir_insn = mir; 932 mir->next = nullptr; 933 } else { 934 last_mir_insn->next = mir; 935 mir->next = nullptr; 936 last_mir_insn = mir; 937 } 938} 939 940/* Insert an MIR instruction to the head of a basic block */ 941void BasicBlock::PrependMIR(MIR* mir) { 942 if (first_mir_insn == nullptr) { 943 DCHECK(last_mir_insn == nullptr); 944 last_mir_insn = first_mir_insn = mir; 945 mir->next = nullptr; 946 } else { 947 mir->next = first_mir_insn; 948 first_mir_insn = mir; 949 } 950} 951 952/* Insert a MIR instruction after the specified MIR */ 953void BasicBlock::InsertMIRAfter(MIR* current_mir, MIR* new_mir) { 954 new_mir->next = current_mir->next; 955 current_mir->next = new_mir; 956 957 if (last_mir_insn == current_mir) { 958 /* Is the last MIR in the block */ 959 last_mir_insn = new_mir; 960 } 961} 962 963MIR* BasicBlock::GetNextUnconditionalMir(MIRGraph* mir_graph, MIR* current) { 964 MIR* next_mir = nullptr; 965 966 if (current != nullptr) { 967 next_mir = current->next; 968 } 969 970 if (next_mir == nullptr) { 971 // Only look for next MIR that follows unconditionally. 972 if ((taken == NullBasicBlockId) && (fall_through != NullBasicBlockId)) { 973 next_mir = mir_graph->GetBasicBlock(fall_through)->first_mir_insn; 974 } 975 } 976 977 return next_mir; 978} 979 980char* MIRGraph::GetDalvikDisassembly(const MIR* mir) { 981 MIR::DecodedInstruction insn = mir->dalvikInsn; 982 std::string str; 983 int flags = 0; 984 int opcode = insn.opcode; 985 char* ret; 986 bool nop = false; 987 SSARepresentation* ssa_rep = mir->ssa_rep; 988 Instruction::Format dalvik_format = Instruction::k10x; // Default to no-operand format 989 int defs = (ssa_rep != NULL) ? ssa_rep->num_defs : 0; 990 int uses = (ssa_rep != NULL) ? ssa_rep->num_uses : 0; 991 992 // Handle special cases. 993 if ((opcode == kMirOpCheck) || (opcode == kMirOpCheckPart2)) { 994 str.append(extended_mir_op_names_[opcode - kMirOpFirst]); 995 str.append(": "); 996 // Recover the original Dex instruction 997 insn = mir->meta.throw_insn->dalvikInsn; 998 ssa_rep = mir->meta.throw_insn->ssa_rep; 999 defs = ssa_rep->num_defs; 1000 uses = ssa_rep->num_uses; 1001 opcode = insn.opcode; 1002 } else if (opcode == kMirOpNop) { 1003 str.append("["); 1004 // Recover original opcode. 1005 insn.opcode = Instruction::At(current_code_item_->insns_ + mir->offset)->Opcode(); 1006 opcode = insn.opcode; 1007 nop = true; 1008 } 1009 1010 if (opcode >= kMirOpFirst) { 1011 str.append(extended_mir_op_names_[opcode - kMirOpFirst]); 1012 } else { 1013 dalvik_format = Instruction::FormatOf(insn.opcode); 1014 flags = Instruction::FlagsOf(insn.opcode); 1015 str.append(Instruction::Name(insn.opcode)); 1016 } 1017 1018 if (opcode == kMirOpPhi) { 1019 BasicBlockId* incoming = mir->meta.phi_incoming; 1020 str.append(StringPrintf(" %s = (%s", 1021 GetSSANameWithConst(ssa_rep->defs[0], true).c_str(), 1022 GetSSANameWithConst(ssa_rep->uses[0], true).c_str())); 1023 str.append(StringPrintf(":%d", incoming[0])); 1024 int i; 1025 for (i = 1; i < uses; i++) { 1026 str.append(StringPrintf(", %s:%d", 1027 GetSSANameWithConst(ssa_rep->uses[i], true).c_str(), 1028 incoming[i])); 1029 } 1030 str.append(")"); 1031 } else if ((flags & Instruction::kBranch) != 0) { 1032 // For branches, decode the instructions to print out the branch targets. 1033 int offset = 0; 1034 switch (dalvik_format) { 1035 case Instruction::k21t: 1036 str.append(StringPrintf(" %s,", GetSSANameWithConst(ssa_rep->uses[0], false).c_str())); 1037 offset = insn.vB; 1038 break; 1039 case Instruction::k22t: 1040 str.append(StringPrintf(" %s, %s,", GetSSANameWithConst(ssa_rep->uses[0], false).c_str(), 1041 GetSSANameWithConst(ssa_rep->uses[1], false).c_str())); 1042 offset = insn.vC; 1043 break; 1044 case Instruction::k10t: 1045 case Instruction::k20t: 1046 case Instruction::k30t: 1047 offset = insn.vA; 1048 break; 1049 default: 1050 LOG(FATAL) << "Unexpected branch format " << dalvik_format << " from " << insn.opcode; 1051 } 1052 str.append(StringPrintf(" 0x%x (%c%x)", mir->offset + offset, 1053 offset > 0 ? '+' : '-', offset > 0 ? offset : -offset)); 1054 } else { 1055 // For invokes-style formats, treat wide regs as a pair of singles 1056 bool show_singles = ((dalvik_format == Instruction::k35c) || 1057 (dalvik_format == Instruction::k3rc)); 1058 if (defs != 0) { 1059 str.append(StringPrintf(" %s", GetSSANameWithConst(ssa_rep->defs[0], false).c_str())); 1060 if (uses != 0) { 1061 str.append(", "); 1062 } 1063 } 1064 for (int i = 0; i < uses; i++) { 1065 str.append( 1066 StringPrintf(" %s", GetSSANameWithConst(ssa_rep->uses[i], show_singles).c_str())); 1067 if (!show_singles && (reg_location_ != NULL) && reg_location_[i].wide) { 1068 // For the listing, skip the high sreg. 1069 i++; 1070 } 1071 if (i != (uses -1)) { 1072 str.append(","); 1073 } 1074 } 1075 switch (dalvik_format) { 1076 case Instruction::k11n: // Add one immediate from vB 1077 case Instruction::k21s: 1078 case Instruction::k31i: 1079 case Instruction::k21h: 1080 str.append(StringPrintf(", #%d", insn.vB)); 1081 break; 1082 case Instruction::k51l: // Add one wide immediate 1083 str.append(StringPrintf(", #%" PRId64, insn.vB_wide)); 1084 break; 1085 case Instruction::k21c: // One register, one string/type/method index 1086 case Instruction::k31c: 1087 str.append(StringPrintf(", index #%d", insn.vB)); 1088 break; 1089 case Instruction::k22c: // Two registers, one string/type/method index 1090 str.append(StringPrintf(", index #%d", insn.vC)); 1091 break; 1092 case Instruction::k22s: // Add one immediate from vC 1093 case Instruction::k22b: 1094 str.append(StringPrintf(", #%d", insn.vC)); 1095 break; 1096 default: { 1097 // Nothing left to print 1098 } 1099 } 1100 } 1101 if (nop) { 1102 str.append("]--optimized away"); 1103 } 1104 int length = str.length() + 1; 1105 ret = static_cast<char*>(arena_->Alloc(length, kArenaAllocDFInfo)); 1106 strncpy(ret, str.c_str(), length); 1107 return ret; 1108} 1109 1110/* Turn method name into a legal Linux file name */ 1111void MIRGraph::ReplaceSpecialChars(std::string& str) { 1112 static const struct { const char before; const char after; } match[] = { 1113 {'/', '-'}, {';', '#'}, {' ', '#'}, {'$', '+'}, 1114 {'(', '@'}, {')', '@'}, {'<', '='}, {'>', '='} 1115 }; 1116 for (unsigned int i = 0; i < sizeof(match)/sizeof(match[0]); i++) { 1117 std::replace(str.begin(), str.end(), match[i].before, match[i].after); 1118 } 1119} 1120 1121std::string MIRGraph::GetSSAName(int ssa_reg) { 1122 // TODO: This value is needed for LLVM and debugging. Currently, we compute this and then copy to 1123 // the arena. We should be smarter and just place straight into the arena, or compute the 1124 // value more lazily. 1125 return StringPrintf("v%d_%d", SRegToVReg(ssa_reg), GetSSASubscript(ssa_reg)); 1126} 1127 1128// Similar to GetSSAName, but if ssa name represents an immediate show that as well. 1129std::string MIRGraph::GetSSANameWithConst(int ssa_reg, bool singles_only) { 1130 if (reg_location_ == NULL) { 1131 // Pre-SSA - just use the standard name 1132 return GetSSAName(ssa_reg); 1133 } 1134 if (IsConst(reg_location_[ssa_reg])) { 1135 if (!singles_only && reg_location_[ssa_reg].wide) { 1136 return StringPrintf("v%d_%d#0x%" PRIx64, SRegToVReg(ssa_reg), GetSSASubscript(ssa_reg), 1137 ConstantValueWide(reg_location_[ssa_reg])); 1138 } else { 1139 return StringPrintf("v%d_%d#0x%x", SRegToVReg(ssa_reg), GetSSASubscript(ssa_reg), 1140 ConstantValue(reg_location_[ssa_reg])); 1141 } 1142 } else { 1143 return StringPrintf("v%d_%d", SRegToVReg(ssa_reg), GetSSASubscript(ssa_reg)); 1144 } 1145} 1146 1147void MIRGraph::GetBlockName(BasicBlock* bb, char* name) { 1148 switch (bb->block_type) { 1149 case kEntryBlock: 1150 snprintf(name, BLOCK_NAME_LEN, "entry_%d", bb->id); 1151 break; 1152 case kExitBlock: 1153 snprintf(name, BLOCK_NAME_LEN, "exit_%d", bb->id); 1154 break; 1155 case kDalvikByteCode: 1156 snprintf(name, BLOCK_NAME_LEN, "block%04x_%d", bb->start_offset, bb->id); 1157 break; 1158 case kExceptionHandling: 1159 snprintf(name, BLOCK_NAME_LEN, "exception%04x_%d", bb->start_offset, 1160 bb->id); 1161 break; 1162 default: 1163 snprintf(name, BLOCK_NAME_LEN, "_%d", bb->id); 1164 break; 1165 } 1166} 1167 1168const char* MIRGraph::GetShortyFromTargetIdx(int target_idx) { 1169 // TODO: for inlining support, use current code unit. 1170 const DexFile::MethodId& method_id = cu_->dex_file->GetMethodId(target_idx); 1171 return cu_->dex_file->GetShorty(method_id.proto_idx_); 1172} 1173 1174/* Debug Utility - dump a compilation unit */ 1175void MIRGraph::DumpMIRGraph() { 1176 BasicBlock* bb; 1177 const char* block_type_names[] = { 1178 "Null Block", 1179 "Entry Block", 1180 "Code Block", 1181 "Exit Block", 1182 "Exception Handling", 1183 "Catch Block" 1184 }; 1185 1186 LOG(INFO) << "Compiling " << PrettyMethod(cu_->method_idx, *cu_->dex_file); 1187 LOG(INFO) << cu_->insns << " insns"; 1188 LOG(INFO) << GetNumBlocks() << " blocks in total"; 1189 GrowableArray<BasicBlock*>::Iterator iterator(&block_list_); 1190 1191 while (true) { 1192 bb = iterator.Next(); 1193 if (bb == NULL) break; 1194 LOG(INFO) << StringPrintf("Block %d (%s) (insn %04x - %04x%s)", 1195 bb->id, 1196 block_type_names[bb->block_type], 1197 bb->start_offset, 1198 bb->last_mir_insn ? bb->last_mir_insn->offset : bb->start_offset, 1199 bb->last_mir_insn ? "" : " empty"); 1200 if (bb->taken != NullBasicBlockId) { 1201 LOG(INFO) << " Taken branch: block " << bb->taken 1202 << "(0x" << std::hex << GetBasicBlock(bb->taken)->start_offset << ")"; 1203 } 1204 if (bb->fall_through != NullBasicBlockId) { 1205 LOG(INFO) << " Fallthrough : block " << bb->fall_through 1206 << " (0x" << std::hex << GetBasicBlock(bb->fall_through)->start_offset << ")"; 1207 } 1208 } 1209} 1210 1211/* 1212 * Build an array of location records for the incoming arguments. 1213 * Note: one location record per word of arguments, with dummy 1214 * high-word loc for wide arguments. Also pull up any following 1215 * MOVE_RESULT and incorporate it into the invoke. 1216 */ 1217CallInfo* MIRGraph::NewMemCallInfo(BasicBlock* bb, MIR* mir, InvokeType type, 1218 bool is_range) { 1219 CallInfo* info = static_cast<CallInfo*>(arena_->Alloc(sizeof(CallInfo), 1220 kArenaAllocMisc)); 1221 MIR* move_result_mir = FindMoveResult(bb, mir); 1222 if (move_result_mir == NULL) { 1223 info->result.location = kLocInvalid; 1224 } else { 1225 info->result = GetRawDest(move_result_mir); 1226 move_result_mir->dalvikInsn.opcode = static_cast<Instruction::Code>(kMirOpNop); 1227 } 1228 info->num_arg_words = mir->ssa_rep->num_uses; 1229 info->args = (info->num_arg_words == 0) ? NULL : static_cast<RegLocation*> 1230 (arena_->Alloc(sizeof(RegLocation) * info->num_arg_words, kArenaAllocMisc)); 1231 for (int i = 0; i < info->num_arg_words; i++) { 1232 info->args[i] = GetRawSrc(mir, i); 1233 } 1234 info->opt_flags = mir->optimization_flags; 1235 info->type = type; 1236 info->is_range = is_range; 1237 info->index = mir->dalvikInsn.vB; 1238 info->offset = mir->offset; 1239 info->mir = mir; 1240 return info; 1241} 1242 1243// Allocate a new basic block. 1244BasicBlock* MIRGraph::NewMemBB(BBType block_type, int block_id) { 1245 BasicBlock* bb = static_cast<BasicBlock*>(arena_->Alloc(sizeof(BasicBlock), 1246 kArenaAllocBB)); 1247 bb->block_type = block_type; 1248 bb->id = block_id; 1249 // TUNING: better estimate of the exit block predecessors? 1250 bb->predecessors = new (arena_) GrowableArray<BasicBlockId>(arena_, 1251 (block_type == kExitBlock) ? 2048 : 2, 1252 kGrowableArrayPredecessors); 1253 bb->successor_block_list_type = kNotUsed; 1254 block_id_map_.Put(block_id, block_id); 1255 return bb; 1256} 1257 1258void MIRGraph::InitializeConstantPropagation() { 1259 is_constant_v_ = new (arena_) ArenaBitVector(arena_, GetNumSSARegs(), false); 1260 constant_values_ = static_cast<int*>(arena_->Alloc(sizeof(int) * GetNumSSARegs(), kArenaAllocDFInfo)); 1261} 1262 1263void MIRGraph::InitializeMethodUses() { 1264 // The gate starts by initializing the use counts 1265 int num_ssa_regs = GetNumSSARegs(); 1266 use_counts_.Resize(num_ssa_regs + 32); 1267 raw_use_counts_.Resize(num_ssa_regs + 32); 1268 // Initialize list 1269 for (int i = 0; i < num_ssa_regs; i++) { 1270 use_counts_.Insert(0); 1271 raw_use_counts_.Insert(0); 1272 } 1273} 1274 1275void MIRGraph::InitializeSSATransformation() { 1276 /* Compute the DFS order */ 1277 ComputeDFSOrders(); 1278 1279 /* Compute the dominator info */ 1280 ComputeDominators(); 1281 1282 /* Allocate data structures in preparation for SSA conversion */ 1283 CompilerInitializeSSAConversion(); 1284 1285 /* Find out the "Dalvik reg def x block" relation */ 1286 ComputeDefBlockMatrix(); 1287 1288 /* Insert phi nodes to dominance frontiers for all variables */ 1289 InsertPhiNodes(); 1290 1291 /* Rename register names by local defs and phi nodes */ 1292 ClearAllVisitedFlags(); 1293 DoDFSPreOrderSSARename(GetEntryBlock()); 1294} 1295 1296ChildBlockIterator::ChildBlockIterator(BasicBlock* bb, MIRGraph* mir_graph) 1297 : basic_block_(bb), mir_graph_(mir_graph), visited_fallthrough_(false), 1298 visited_taken_(false), have_successors_(false) { 1299 // Check if we actually do have successors. 1300 if (basic_block_ != 0 && basic_block_->successor_block_list_type != kNotUsed) { 1301 have_successors_ = true; 1302 successor_iter_.Reset(basic_block_->successor_blocks); 1303 } 1304} 1305 1306BasicBlock* ChildBlockIterator::Next() { 1307 // We check if we have a basic block. If we don't we cannot get next child. 1308 if (basic_block_ == nullptr) { 1309 return nullptr; 1310 } 1311 1312 // If we haven't visited fallthrough, return that. 1313 if (visited_fallthrough_ == false) { 1314 visited_fallthrough_ = true; 1315 1316 BasicBlock* result = mir_graph_->GetBasicBlock(basic_block_->fall_through); 1317 if (result != nullptr) { 1318 return result; 1319 } 1320 } 1321 1322 // If we haven't visited taken, return that. 1323 if (visited_taken_ == false) { 1324 visited_taken_ = true; 1325 1326 BasicBlock* result = mir_graph_->GetBasicBlock(basic_block_->taken); 1327 if (result != nullptr) { 1328 return result; 1329 } 1330 } 1331 1332 // We visited both taken and fallthrough. Now check if we have successors we need to visit. 1333 if (have_successors_ == true) { 1334 // Get information about next successor block. 1335 SuccessorBlockInfo* successor_block_info = successor_iter_.Next(); 1336 1337 // If we don't have anymore successors, return nullptr. 1338 if (successor_block_info != nullptr) { 1339 return mir_graph_->GetBasicBlock(successor_block_info->block); 1340 } 1341 } 1342 1343 // We do not have anything. 1344 return nullptr; 1345} 1346 1347} // namespace art 1348