builder.cc revision e6e3beaf2d35d18a79f5e7b60a21e75fac9fd15d
1/* 2 * Copyright (C) 2014 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 "builder.h" 18 19#include "art_field-inl.h" 20#include "base/logging.h" 21#include "class_linker.h" 22#include "dex/verified_method.h" 23#include "dex_file-inl.h" 24#include "dex_instruction-inl.h" 25#include "dex/verified_method.h" 26#include "driver/compiler_driver-inl.h" 27#include "driver/compiler_options.h" 28#include "mirror/class_loader.h" 29#include "mirror/dex_cache.h" 30#include "nodes.h" 31#include "primitive.h" 32#include "scoped_thread_state_change.h" 33#include "thread.h" 34#include "utils/dex_cache_arrays_layout-inl.h" 35 36namespace art { 37 38/** 39 * Helper class to add HTemporary instructions. This class is used when 40 * converting a DEX instruction to multiple HInstruction, and where those 41 * instructions do not die at the following instruction, but instead spans 42 * multiple instructions. 43 */ 44class Temporaries : public ValueObject { 45 public: 46 explicit Temporaries(HGraph* graph) : graph_(graph), index_(0) {} 47 48 void Add(HInstruction* instruction) { 49 HInstruction* temp = new (graph_->GetArena()) HTemporary(index_, instruction->GetDexPc()); 50 instruction->GetBlock()->AddInstruction(temp); 51 52 DCHECK(temp->GetPrevious() == instruction); 53 54 size_t offset; 55 if (instruction->GetType() == Primitive::kPrimLong 56 || instruction->GetType() == Primitive::kPrimDouble) { 57 offset = 2; 58 } else { 59 offset = 1; 60 } 61 index_ += offset; 62 63 graph_->UpdateTemporariesVRegSlots(index_); 64 } 65 66 private: 67 HGraph* const graph_; 68 69 // Current index in the temporary stack, updated by `Add`. 70 size_t index_; 71}; 72 73class SwitchTable : public ValueObject { 74 public: 75 SwitchTable(const Instruction& instruction, uint32_t dex_pc, bool sparse) 76 : instruction_(instruction), dex_pc_(dex_pc), sparse_(sparse) { 77 int32_t table_offset = instruction.VRegB_31t(); 78 const uint16_t* table = reinterpret_cast<const uint16_t*>(&instruction) + table_offset; 79 if (sparse) { 80 CHECK_EQ(table[0], static_cast<uint16_t>(Instruction::kSparseSwitchSignature)); 81 } else { 82 CHECK_EQ(table[0], static_cast<uint16_t>(Instruction::kPackedSwitchSignature)); 83 } 84 num_entries_ = table[1]; 85 values_ = reinterpret_cast<const int32_t*>(&table[2]); 86 } 87 88 uint16_t GetNumEntries() const { 89 return num_entries_; 90 } 91 92 void CheckIndex(size_t index) const { 93 if (sparse_) { 94 // In a sparse table, we have num_entries_ keys and num_entries_ values, in that order. 95 DCHECK_LT(index, 2 * static_cast<size_t>(num_entries_)); 96 } else { 97 // In a packed table, we have the starting key and num_entries_ values. 98 DCHECK_LT(index, 1 + static_cast<size_t>(num_entries_)); 99 } 100 } 101 102 int32_t GetEntryAt(size_t index) const { 103 CheckIndex(index); 104 return values_[index]; 105 } 106 107 uint32_t GetDexPcForIndex(size_t index) const { 108 CheckIndex(index); 109 return dex_pc_ + 110 (reinterpret_cast<const int16_t*>(values_ + index) - 111 reinterpret_cast<const int16_t*>(&instruction_)); 112 } 113 114 // Index of the first value in the table. 115 size_t GetFirstValueIndex() const { 116 if (sparse_) { 117 // In a sparse table, we have num_entries_ keys and num_entries_ values, in that order. 118 return num_entries_; 119 } else { 120 // In a packed table, we have the starting key and num_entries_ values. 121 return 1; 122 } 123 } 124 125 private: 126 const Instruction& instruction_; 127 const uint32_t dex_pc_; 128 129 // Whether this is a sparse-switch table (or a packed-switch one). 130 const bool sparse_; 131 132 // This can't be const as it needs to be computed off of the given instruction, and complicated 133 // expressions in the initializer list seemed very ugly. 134 uint16_t num_entries_; 135 136 const int32_t* values_; 137 138 DISALLOW_COPY_AND_ASSIGN(SwitchTable); 139}; 140 141void HGraphBuilder::InitializeLocals(uint16_t count) { 142 graph_->SetNumberOfVRegs(count); 143 locals_.resize(count); 144 for (int i = 0; i < count; i++) { 145 HLocal* local = new (arena_) HLocal(i); 146 entry_block_->AddInstruction(local); 147 locals_[i] = local; 148 } 149} 150 151void HGraphBuilder::InitializeParameters(uint16_t number_of_parameters) { 152 // dex_compilation_unit_ is null only when unit testing. 153 if (dex_compilation_unit_ == nullptr) { 154 return; 155 } 156 157 graph_->SetNumberOfInVRegs(number_of_parameters); 158 const char* shorty = dex_compilation_unit_->GetShorty(); 159 int locals_index = locals_.size() - number_of_parameters; 160 int parameter_index = 0; 161 162 const DexFile::MethodId& referrer_method_id = 163 dex_file_->GetMethodId(dex_compilation_unit_->GetDexMethodIndex()); 164 if (!dex_compilation_unit_->IsStatic()) { 165 // Add the implicit 'this' argument, not expressed in the signature. 166 HParameterValue* parameter = new (arena_) HParameterValue(*dex_file_, 167 referrer_method_id.class_idx_, 168 parameter_index++, 169 Primitive::kPrimNot, 170 true); 171 entry_block_->AddInstruction(parameter); 172 HLocal* local = GetLocalAt(locals_index++); 173 entry_block_->AddInstruction(new (arena_) HStoreLocal(local, parameter, local->GetDexPc())); 174 number_of_parameters--; 175 } 176 177 const DexFile::ProtoId& proto = dex_file_->GetMethodPrototype(referrer_method_id); 178 const DexFile::TypeList* arg_types = dex_file_->GetProtoParameters(proto); 179 for (int i = 0, shorty_pos = 1; i < number_of_parameters; i++) { 180 HParameterValue* parameter = new (arena_) HParameterValue( 181 *dex_file_, 182 arg_types->GetTypeItem(shorty_pos - 1).type_idx_, 183 parameter_index++, 184 Primitive::GetType(shorty[shorty_pos]), 185 false); 186 ++shorty_pos; 187 entry_block_->AddInstruction(parameter); 188 HLocal* local = GetLocalAt(locals_index++); 189 // Store the parameter value in the local that the dex code will use 190 // to reference that parameter. 191 entry_block_->AddInstruction(new (arena_) HStoreLocal(local, parameter, local->GetDexPc())); 192 bool is_wide = (parameter->GetType() == Primitive::kPrimLong) 193 || (parameter->GetType() == Primitive::kPrimDouble); 194 if (is_wide) { 195 i++; 196 locals_index++; 197 parameter_index++; 198 } 199 } 200} 201 202template<typename T> 203void HGraphBuilder::If_22t(const Instruction& instruction, uint32_t dex_pc) { 204 int32_t target_offset = instruction.GetTargetOffset(); 205 HBasicBlock* branch_target = FindBlockStartingAt(dex_pc + target_offset); 206 HBasicBlock* fallthrough_target = FindBlockStartingAt(dex_pc + instruction.SizeInCodeUnits()); 207 DCHECK(branch_target != nullptr); 208 DCHECK(fallthrough_target != nullptr); 209 PotentiallyAddSuspendCheck(branch_target, dex_pc); 210 HInstruction* first = LoadLocal(instruction.VRegA(), Primitive::kPrimInt, dex_pc); 211 HInstruction* second = LoadLocal(instruction.VRegB(), Primitive::kPrimInt, dex_pc); 212 T* comparison = new (arena_) T(first, second, dex_pc); 213 current_block_->AddInstruction(comparison); 214 HInstruction* ifinst = new (arena_) HIf(comparison, dex_pc); 215 current_block_->AddInstruction(ifinst); 216 current_block_->AddSuccessor(branch_target); 217 current_block_->AddSuccessor(fallthrough_target); 218 current_block_ = nullptr; 219} 220 221template<typename T> 222void HGraphBuilder::If_21t(const Instruction& instruction, uint32_t dex_pc) { 223 int32_t target_offset = instruction.GetTargetOffset(); 224 HBasicBlock* branch_target = FindBlockStartingAt(dex_pc + target_offset); 225 HBasicBlock* fallthrough_target = FindBlockStartingAt(dex_pc + instruction.SizeInCodeUnits()); 226 DCHECK(branch_target != nullptr); 227 DCHECK(fallthrough_target != nullptr); 228 PotentiallyAddSuspendCheck(branch_target, dex_pc); 229 HInstruction* value = LoadLocal(instruction.VRegA(), Primitive::kPrimInt, dex_pc); 230 T* comparison = new (arena_) T(value, graph_->GetIntConstant(0, dex_pc), dex_pc); 231 current_block_->AddInstruction(comparison); 232 HInstruction* ifinst = new (arena_) HIf(comparison, dex_pc); 233 current_block_->AddInstruction(ifinst); 234 current_block_->AddSuccessor(branch_target); 235 current_block_->AddSuccessor(fallthrough_target); 236 current_block_ = nullptr; 237} 238 239void HGraphBuilder::MaybeRecordStat(MethodCompilationStat compilation_stat) { 240 if (compilation_stats_ != nullptr) { 241 compilation_stats_->RecordStat(compilation_stat); 242 } 243} 244 245bool HGraphBuilder::SkipCompilation(const DexFile::CodeItem& code_item, 246 size_t number_of_branches) { 247 const CompilerOptions& compiler_options = compiler_driver_->GetCompilerOptions(); 248 CompilerOptions::CompilerFilter compiler_filter = compiler_options.GetCompilerFilter(); 249 if (compiler_filter == CompilerOptions::kEverything) { 250 return false; 251 } 252 253 if (compiler_options.IsHugeMethod(code_item.insns_size_in_code_units_)) { 254 VLOG(compiler) << "Skip compilation of huge method " 255 << PrettyMethod(dex_compilation_unit_->GetDexMethodIndex(), *dex_file_) 256 << ": " << code_item.insns_size_in_code_units_ << " code units"; 257 MaybeRecordStat(MethodCompilationStat::kNotCompiledHugeMethod); 258 return true; 259 } 260 261 // If it's large and contains no branches, it's likely to be machine generated initialization. 262 if (compiler_options.IsLargeMethod(code_item.insns_size_in_code_units_) 263 && (number_of_branches == 0)) { 264 VLOG(compiler) << "Skip compilation of large method with no branch " 265 << PrettyMethod(dex_compilation_unit_->GetDexMethodIndex(), *dex_file_) 266 << ": " << code_item.insns_size_in_code_units_ << " code units"; 267 MaybeRecordStat(MethodCompilationStat::kNotCompiledLargeMethodNoBranches); 268 return true; 269 } 270 271 return false; 272} 273 274void HGraphBuilder::CreateBlocksForTryCatch(const DexFile::CodeItem& code_item) { 275 if (code_item.tries_size_ == 0) { 276 return; 277 } 278 279 // Create branch targets at the start/end of the TryItem range. These are 280 // places where the program might fall through into/out of the a block and 281 // where TryBoundary instructions will be inserted later. Other edges which 282 // enter/exit the try blocks are a result of branches/switches. 283 for (size_t idx = 0; idx < code_item.tries_size_; ++idx) { 284 const DexFile::TryItem* try_item = DexFile::GetTryItems(code_item, idx); 285 uint32_t dex_pc_start = try_item->start_addr_; 286 uint32_t dex_pc_end = dex_pc_start + try_item->insn_count_; 287 FindOrCreateBlockStartingAt(dex_pc_start); 288 if (dex_pc_end < code_item.insns_size_in_code_units_) { 289 // TODO: Do not create block if the last instruction cannot fall through. 290 FindOrCreateBlockStartingAt(dex_pc_end); 291 } else { 292 // The TryItem spans until the very end of the CodeItem (or beyond if 293 // invalid) and therefore cannot have any code afterwards. 294 } 295 } 296 297 // Create branch targets for exception handlers. 298 const uint8_t* handlers_ptr = DexFile::GetCatchHandlerData(code_item, 0); 299 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr); 300 for (uint32_t idx = 0; idx < handlers_size; ++idx) { 301 CatchHandlerIterator iterator(handlers_ptr); 302 for (; iterator.HasNext(); iterator.Next()) { 303 uint32_t address = iterator.GetHandlerAddress(); 304 HBasicBlock* block = FindOrCreateBlockStartingAt(address); 305 block->SetTryCatchInformation( 306 new (arena_) TryCatchInformation(iterator.GetHandlerTypeIndex(), *dex_file_)); 307 } 308 handlers_ptr = iterator.EndDataPointer(); 309 } 310} 311 312// Returns the TryItem stored for `block` or nullptr if there is no info for it. 313static const DexFile::TryItem* GetTryItem( 314 HBasicBlock* block, 315 const ArenaSafeMap<uint32_t, const DexFile::TryItem*>& try_block_info) { 316 auto iterator = try_block_info.find(block->GetBlockId()); 317 return (iterator == try_block_info.end()) ? nullptr : iterator->second; 318} 319 320void HGraphBuilder::LinkToCatchBlocks(HTryBoundary* try_boundary, 321 const DexFile::CodeItem& code_item, 322 const DexFile::TryItem* try_item) { 323 for (CatchHandlerIterator it(code_item, *try_item); it.HasNext(); it.Next()) { 324 try_boundary->AddExceptionHandler(FindBlockStartingAt(it.GetHandlerAddress())); 325 } 326} 327 328void HGraphBuilder::InsertTryBoundaryBlocks(const DexFile::CodeItem& code_item) { 329 if (code_item.tries_size_ == 0) { 330 return; 331 } 332 333 // Keep a map of all try blocks and their respective TryItems. We do not use 334 // the block's pointer but rather its id to ensure deterministic iteration. 335 ArenaSafeMap<uint32_t, const DexFile::TryItem*> try_block_info( 336 std::less<uint32_t>(), arena_->Adapter(kArenaAllocGraphBuilder)); 337 338 // Obtain TryItem information for blocks with throwing instructions, and split 339 // blocks which are both try & catch to simplify the graph. 340 // NOTE: We are appending new blocks inside the loop, so we need to use index 341 // because iterators can be invalidated. We remember the initial size to avoid 342 // iterating over the new blocks which cannot throw. 343 for (size_t i = 0, e = graph_->GetBlocks().size(); i < e; ++i) { 344 HBasicBlock* block = graph_->GetBlocks()[i]; 345 346 // Do not bother creating exceptional edges for try blocks which have no 347 // throwing instructions. In that case we simply assume that the block is 348 // not covered by a TryItem. This prevents us from creating a throw-catch 349 // loop for synchronized blocks. 350 if (block->HasThrowingInstructions()) { 351 // Try to find a TryItem covering the block. 352 DCHECK_NE(block->GetDexPc(), kNoDexPc) << "Block must have a dec_pc to find its TryItem."; 353 const int32_t try_item_idx = DexFile::FindTryItem(code_item, block->GetDexPc()); 354 if (try_item_idx != -1) { 355 // Block throwing and in a TryItem. Store the try block information. 356 HBasicBlock* throwing_block = block; 357 if (block->IsCatchBlock()) { 358 // Simplify blocks which are both try and catch, otherwise we would 359 // need a strategy for splitting exceptional edges. We split the block 360 // after the move-exception (if present) and mark the first part not 361 // throwing. The normal-flow edge between them will be split later. 362 HInstruction* first_insn = block->GetFirstInstruction(); 363 if (first_insn->IsLoadException()) { 364 // Catch block starts with a LoadException. Split the block after 365 // the StoreLocal and ClearException which must come after the load. 366 DCHECK(first_insn->GetNext()->IsStoreLocal()); 367 DCHECK(first_insn->GetNext()->GetNext()->IsClearException()); 368 throwing_block = block->SplitBefore(first_insn->GetNext()->GetNext()->GetNext()); 369 } else { 370 // Catch block does not load the exception. Split at the beginning 371 // to create an empty catch block. 372 throwing_block = block->SplitBefore(first_insn); 373 } 374 } 375 376 try_block_info.Put(throwing_block->GetBlockId(), 377 DexFile::GetTryItems(code_item, try_item_idx)); 378 } 379 } 380 } 381 382 // Do a pass over the try blocks and insert entering TryBoundaries where at 383 // least one predecessor is not covered by the same TryItem as the try block. 384 // We do not split each edge separately, but rather create one boundary block 385 // that all predecessors are relinked to. This preserves loop headers (b/23895756). 386 for (auto entry : try_block_info) { 387 HBasicBlock* try_block = graph_->GetBlocks()[entry.first]; 388 for (HBasicBlock* predecessor : try_block->GetPredecessors()) { 389 if (GetTryItem(predecessor, try_block_info) != entry.second) { 390 // Found a predecessor not covered by the same TryItem. Insert entering 391 // boundary block. 392 HTryBoundary* try_entry = 393 new (arena_) HTryBoundary(HTryBoundary::kEntry, try_block->GetDexPc()); 394 try_block->CreateImmediateDominator()->AddInstruction(try_entry); 395 LinkToCatchBlocks(try_entry, code_item, entry.second); 396 break; 397 } 398 } 399 } 400 401 // Do a second pass over the try blocks and insert exit TryBoundaries where 402 // the successor is not in the same TryItem. 403 for (auto entry : try_block_info) { 404 HBasicBlock* try_block = graph_->GetBlocks()[entry.first]; 405 // NOTE: Do not use iterators because SplitEdge would invalidate them. 406 for (size_t i = 0, e = try_block->GetSuccessors().size(); i < e; ++i) { 407 HBasicBlock* successor = try_block->GetSuccessors()[i]; 408 409 // If the successor is a try block, all of its predecessors must be 410 // covered by the same TryItem. Otherwise the previous pass would have 411 // created a non-throwing boundary block. 412 if (GetTryItem(successor, try_block_info) != nullptr) { 413 DCHECK_EQ(entry.second, GetTryItem(successor, try_block_info)); 414 continue; 415 } 416 417 // Preserve the invariant that Return(Void) always jumps to Exit by moving 418 // it outside the try block if necessary. 419 HInstruction* last_instruction = try_block->GetLastInstruction(); 420 if (last_instruction->IsReturn() || last_instruction->IsReturnVoid()) { 421 DCHECK_EQ(successor, exit_block_); 422 successor = try_block->SplitBefore(last_instruction); 423 } 424 425 // Insert TryBoundary and link to catch blocks. 426 HTryBoundary* try_exit = 427 new (arena_) HTryBoundary(HTryBoundary::kExit, successor->GetDexPc()); 428 graph_->SplitEdge(try_block, successor)->AddInstruction(try_exit); 429 LinkToCatchBlocks(try_exit, code_item, entry.second); 430 } 431 } 432} 433 434bool HGraphBuilder::BuildGraph(const DexFile::CodeItem& code_item) { 435 DCHECK(graph_->GetBlocks().empty()); 436 437 const uint16_t* code_ptr = code_item.insns_; 438 const uint16_t* code_end = code_item.insns_ + code_item.insns_size_in_code_units_; 439 code_start_ = code_ptr; 440 441 // Setup the graph with the entry block and exit block. 442 entry_block_ = new (arena_) HBasicBlock(graph_, 0); 443 graph_->AddBlock(entry_block_); 444 exit_block_ = new (arena_) HBasicBlock(graph_, kNoDexPc); 445 graph_->SetEntryBlock(entry_block_); 446 graph_->SetExitBlock(exit_block_); 447 448 graph_->SetHasTryCatch(code_item.tries_size_ != 0); 449 450 InitializeLocals(code_item.registers_size_); 451 graph_->SetMaximumNumberOfOutVRegs(code_item.outs_size_); 452 453 // Compute the number of dex instructions, blocks, and branches. We will 454 // check these values against limits given to the compiler. 455 size_t number_of_branches = 0; 456 457 // To avoid splitting blocks, we compute ahead of time the instructions that 458 // start a new block, and create these blocks. 459 if (!ComputeBranchTargets(code_ptr, code_end, &number_of_branches)) { 460 MaybeRecordStat(MethodCompilationStat::kNotCompiledBranchOutsideMethodCode); 461 return false; 462 } 463 464 // Note that the compiler driver is null when unit testing. 465 if ((compiler_driver_ != nullptr) && SkipCompilation(code_item, number_of_branches)) { 466 return false; 467 } 468 469 CreateBlocksForTryCatch(code_item); 470 471 InitializeParameters(code_item.ins_size_); 472 473 size_t dex_pc = 0; 474 while (code_ptr < code_end) { 475 // Update the current block if dex_pc starts a new block. 476 MaybeUpdateCurrentBlock(dex_pc); 477 const Instruction& instruction = *Instruction::At(code_ptr); 478 if (!AnalyzeDexInstruction(instruction, dex_pc)) { 479 return false; 480 } 481 dex_pc += instruction.SizeInCodeUnits(); 482 code_ptr += instruction.SizeInCodeUnits(); 483 } 484 485 // Add Exit to the exit block. 486 exit_block_->AddInstruction(new (arena_) HExit()); 487 // Add the suspend check to the entry block. 488 entry_block_->AddInstruction(new (arena_) HSuspendCheck(0)); 489 entry_block_->AddInstruction(new (arena_) HGoto()); 490 // Add the exit block at the end. 491 graph_->AddBlock(exit_block_); 492 493 // Iterate over blocks covered by TryItems and insert TryBoundaries at entry 494 // and exit points. This requires all control-flow instructions and 495 // non-exceptional edges to have been created. 496 InsertTryBoundaryBlocks(code_item); 497 498 return true; 499} 500 501void HGraphBuilder::MaybeUpdateCurrentBlock(size_t dex_pc) { 502 HBasicBlock* block = FindBlockStartingAt(dex_pc); 503 if (block == nullptr) { 504 return; 505 } 506 507 if (current_block_ != nullptr) { 508 // Branching instructions clear current_block, so we know 509 // the last instruction of the current block is not a branching 510 // instruction. We add an unconditional goto to the found block. 511 current_block_->AddInstruction(new (arena_) HGoto(dex_pc)); 512 current_block_->AddSuccessor(block); 513 } 514 graph_->AddBlock(block); 515 current_block_ = block; 516} 517 518bool HGraphBuilder::ComputeBranchTargets(const uint16_t* code_ptr, 519 const uint16_t* code_end, 520 size_t* number_of_branches) { 521 branch_targets_.resize(code_end - code_ptr, nullptr); 522 523 // Create the first block for the dex instructions, single successor of the entry block. 524 HBasicBlock* block = new (arena_) HBasicBlock(graph_, 0); 525 branch_targets_[0] = block; 526 entry_block_->AddSuccessor(block); 527 528 // Iterate over all instructions and find branching instructions. Create blocks for 529 // the locations these instructions branch to. 530 uint32_t dex_pc = 0; 531 while (code_ptr < code_end) { 532 const Instruction& instruction = *Instruction::At(code_ptr); 533 if (instruction.IsBranch()) { 534 (*number_of_branches)++; 535 int32_t target = instruction.GetTargetOffset() + dex_pc; 536 // Create a block for the target instruction. 537 FindOrCreateBlockStartingAt(target); 538 539 dex_pc += instruction.SizeInCodeUnits(); 540 code_ptr += instruction.SizeInCodeUnits(); 541 542 if (instruction.CanFlowThrough()) { 543 if (code_ptr >= code_end) { 544 // In the normal case we should never hit this but someone can artificially forge a dex 545 // file to fall-through out the method code. In this case we bail out compilation. 546 return false; 547 } else { 548 FindOrCreateBlockStartingAt(dex_pc); 549 } 550 } 551 } else if (instruction.IsSwitch()) { 552 SwitchTable table(instruction, dex_pc, instruction.Opcode() == Instruction::SPARSE_SWITCH); 553 554 uint16_t num_entries = table.GetNumEntries(); 555 556 // In a packed-switch, the entry at index 0 is the starting key. In a sparse-switch, the 557 // entry at index 0 is the first key, and values are after *all* keys. 558 size_t offset = table.GetFirstValueIndex(); 559 560 // Use a larger loop counter type to avoid overflow issues. 561 for (size_t i = 0; i < num_entries; ++i) { 562 // The target of the case. 563 uint32_t target = dex_pc + table.GetEntryAt(i + offset); 564 FindOrCreateBlockStartingAt(target); 565 566 // Create a block for the switch-case logic. The block gets the dex_pc 567 // of the SWITCH instruction because it is part of its semantics. 568 block = new (arena_) HBasicBlock(graph_, dex_pc); 569 branch_targets_[table.GetDexPcForIndex(i)] = block; 570 } 571 572 // Fall-through. Add a block if there is more code afterwards. 573 dex_pc += instruction.SizeInCodeUnits(); 574 code_ptr += instruction.SizeInCodeUnits(); 575 if (code_ptr >= code_end) { 576 // In the normal case we should never hit this but someone can artificially forge a dex 577 // file to fall-through out the method code. In this case we bail out compilation. 578 // (A switch can fall-through so we don't need to check CanFlowThrough().) 579 return false; 580 } else { 581 FindOrCreateBlockStartingAt(dex_pc); 582 } 583 } else { 584 code_ptr += instruction.SizeInCodeUnits(); 585 dex_pc += instruction.SizeInCodeUnits(); 586 } 587 } 588 return true; 589} 590 591HBasicBlock* HGraphBuilder::FindBlockStartingAt(int32_t dex_pc) const { 592 DCHECK_GE(dex_pc, 0); 593 return branch_targets_[dex_pc]; 594} 595 596HBasicBlock* HGraphBuilder::FindOrCreateBlockStartingAt(int32_t dex_pc) { 597 HBasicBlock* block = FindBlockStartingAt(dex_pc); 598 if (block == nullptr) { 599 block = new (arena_) HBasicBlock(graph_, dex_pc); 600 branch_targets_[dex_pc] = block; 601 } 602 return block; 603} 604 605template<typename T> 606void HGraphBuilder::Unop_12x(const Instruction& instruction, 607 Primitive::Type type, 608 uint32_t dex_pc) { 609 HInstruction* first = LoadLocal(instruction.VRegB(), type, dex_pc); 610 current_block_->AddInstruction(new (arena_) T(type, first, dex_pc)); 611 UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction(), dex_pc); 612} 613 614void HGraphBuilder::Conversion_12x(const Instruction& instruction, 615 Primitive::Type input_type, 616 Primitive::Type result_type, 617 uint32_t dex_pc) { 618 HInstruction* first = LoadLocal(instruction.VRegB(), input_type, dex_pc); 619 current_block_->AddInstruction(new (arena_) HTypeConversion(result_type, first, dex_pc)); 620 UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction(), dex_pc); 621} 622 623template<typename T> 624void HGraphBuilder::Binop_23x(const Instruction& instruction, 625 Primitive::Type type, 626 uint32_t dex_pc) { 627 HInstruction* first = LoadLocal(instruction.VRegB(), type, dex_pc); 628 HInstruction* second = LoadLocal(instruction.VRegC(), type, dex_pc); 629 current_block_->AddInstruction(new (arena_) T(type, first, second, dex_pc)); 630 UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction(), dex_pc); 631} 632 633template<typename T> 634void HGraphBuilder::Binop_23x_shift(const Instruction& instruction, 635 Primitive::Type type, 636 uint32_t dex_pc) { 637 HInstruction* first = LoadLocal(instruction.VRegB(), type, dex_pc); 638 HInstruction* second = LoadLocal(instruction.VRegC(), Primitive::kPrimInt, dex_pc); 639 current_block_->AddInstruction(new (arena_) T(type, first, second, dex_pc)); 640 UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction(), dex_pc); 641} 642 643void HGraphBuilder::Binop_23x_cmp(const Instruction& instruction, 644 Primitive::Type type, 645 ComparisonBias bias, 646 uint32_t dex_pc) { 647 HInstruction* first = LoadLocal(instruction.VRegB(), type, dex_pc); 648 HInstruction* second = LoadLocal(instruction.VRegC(), type, dex_pc); 649 current_block_->AddInstruction(new (arena_) HCompare(type, first, second, bias, dex_pc)); 650 UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction(), dex_pc); 651} 652 653template<typename T> 654void HGraphBuilder::Binop_12x_shift(const Instruction& instruction, Primitive::Type type, 655 uint32_t dex_pc) { 656 HInstruction* first = LoadLocal(instruction.VRegA(), type, dex_pc); 657 HInstruction* second = LoadLocal(instruction.VRegB(), Primitive::kPrimInt, dex_pc); 658 current_block_->AddInstruction(new (arena_) T(type, first, second, dex_pc)); 659 UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction(), dex_pc); 660} 661 662template<typename T> 663void HGraphBuilder::Binop_12x(const Instruction& instruction, 664 Primitive::Type type, 665 uint32_t dex_pc) { 666 HInstruction* first = LoadLocal(instruction.VRegA(), type, dex_pc); 667 HInstruction* second = LoadLocal(instruction.VRegB(), type, dex_pc); 668 current_block_->AddInstruction(new (arena_) T(type, first, second, dex_pc)); 669 UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction(), dex_pc); 670} 671 672template<typename T> 673void HGraphBuilder::Binop_22s(const Instruction& instruction, bool reverse, uint32_t dex_pc) { 674 HInstruction* first = LoadLocal(instruction.VRegB(), Primitive::kPrimInt, dex_pc); 675 HInstruction* second = graph_->GetIntConstant(instruction.VRegC_22s(), dex_pc); 676 if (reverse) { 677 std::swap(first, second); 678 } 679 current_block_->AddInstruction(new (arena_) T(Primitive::kPrimInt, first, second, dex_pc)); 680 UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction(), dex_pc); 681} 682 683template<typename T> 684void HGraphBuilder::Binop_22b(const Instruction& instruction, bool reverse, uint32_t dex_pc) { 685 HInstruction* first = LoadLocal(instruction.VRegB(), Primitive::kPrimInt, dex_pc); 686 HInstruction* second = graph_->GetIntConstant(instruction.VRegC_22b(), dex_pc); 687 if (reverse) { 688 std::swap(first, second); 689 } 690 current_block_->AddInstruction(new (arena_) T(Primitive::kPrimInt, first, second, dex_pc)); 691 UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction(), dex_pc); 692} 693 694static bool RequiresConstructorBarrier(const DexCompilationUnit* cu, const CompilerDriver& driver) { 695 Thread* self = Thread::Current(); 696 return cu->IsConstructor() 697 && driver.RequiresConstructorBarrier(self, cu->GetDexFile(), cu->GetClassDefIndex()); 698} 699 700void HGraphBuilder::BuildReturn(const Instruction& instruction, 701 Primitive::Type type, 702 uint32_t dex_pc) { 703 if (type == Primitive::kPrimVoid) { 704 if (graph_->ShouldGenerateConstructorBarrier()) { 705 // The compilation unit is null during testing. 706 if (dex_compilation_unit_ != nullptr) { 707 DCHECK(RequiresConstructorBarrier(dex_compilation_unit_, *compiler_driver_)) 708 << "Inconsistent use of ShouldGenerateConstructorBarrier. Should not generate a barrier."; 709 } 710 current_block_->AddInstruction(new (arena_) HMemoryBarrier(kStoreStore, dex_pc)); 711 } 712 current_block_->AddInstruction(new (arena_) HReturnVoid(dex_pc)); 713 } else { 714 HInstruction* value = LoadLocal(instruction.VRegA(), type, dex_pc); 715 current_block_->AddInstruction(new (arena_) HReturn(value, dex_pc)); 716 } 717 current_block_->AddSuccessor(exit_block_); 718 current_block_ = nullptr; 719} 720 721static InvokeType GetInvokeTypeFromOpCode(Instruction::Code opcode) { 722 switch (opcode) { 723 case Instruction::INVOKE_STATIC: 724 case Instruction::INVOKE_STATIC_RANGE: 725 return kStatic; 726 case Instruction::INVOKE_DIRECT: 727 case Instruction::INVOKE_DIRECT_RANGE: 728 return kDirect; 729 case Instruction::INVOKE_VIRTUAL: 730 case Instruction::INVOKE_VIRTUAL_QUICK: 731 case Instruction::INVOKE_VIRTUAL_RANGE: 732 case Instruction::INVOKE_VIRTUAL_RANGE_QUICK: 733 return kVirtual; 734 case Instruction::INVOKE_INTERFACE: 735 case Instruction::INVOKE_INTERFACE_RANGE: 736 return kInterface; 737 case Instruction::INVOKE_SUPER_RANGE: 738 case Instruction::INVOKE_SUPER: 739 return kSuper; 740 default: 741 LOG(FATAL) << "Unexpected invoke opcode: " << opcode; 742 UNREACHABLE(); 743 } 744} 745 746bool HGraphBuilder::BuildInvoke(const Instruction& instruction, 747 uint32_t dex_pc, 748 uint32_t method_idx, 749 uint32_t number_of_vreg_arguments, 750 bool is_range, 751 uint32_t* args, 752 uint32_t register_index) { 753 InvokeType original_invoke_type = GetInvokeTypeFromOpCode(instruction.Opcode()); 754 InvokeType optimized_invoke_type = original_invoke_type; 755 const char* descriptor = dex_file_->GetMethodShorty(method_idx); 756 Primitive::Type return_type = Primitive::GetType(descriptor[0]); 757 758 // Remove the return type from the 'proto'. 759 size_t number_of_arguments = strlen(descriptor) - 1; 760 if (original_invoke_type != kStatic) { // instance call 761 // One extra argument for 'this'. 762 number_of_arguments++; 763 } 764 765 MethodReference target_method(dex_file_, method_idx); 766 int32_t table_index = 0; 767 uintptr_t direct_code = 0; 768 uintptr_t direct_method = 0; 769 770 // Special handling for string init. 771 int32_t string_init_offset = 0; 772 bool is_string_init = compiler_driver_->IsStringInit(method_idx, 773 dex_file_, 774 &string_init_offset); 775 // Replace calls to String.<init> with StringFactory. 776 if (is_string_init) { 777 HInvokeStaticOrDirect::DispatchInfo dispatch_info = ComputeDispatchInfo(is_string_init, 778 string_init_offset, 779 target_method, 780 direct_method, 781 direct_code); 782 HInvoke* invoke = new (arena_) HInvokeStaticOrDirect( 783 arena_, 784 number_of_arguments - 1, 785 Primitive::kPrimNot /*return_type */, 786 dex_pc, 787 method_idx, 788 target_method, 789 dispatch_info, 790 original_invoke_type, 791 kStatic /* optimized_invoke_type */, 792 HInvokeStaticOrDirect::ClinitCheckRequirement::kImplicit); 793 return HandleStringInit(invoke, 794 number_of_vreg_arguments, 795 args, 796 register_index, 797 is_range, 798 descriptor); 799 } 800 801 // Handle unresolved methods. 802 if (!compiler_driver_->ComputeInvokeInfo(dex_compilation_unit_, 803 dex_pc, 804 true /* update_stats */, 805 true /* enable_devirtualization */, 806 &optimized_invoke_type, 807 &target_method, 808 &table_index, 809 &direct_code, 810 &direct_method)) { 811 MaybeRecordStat(MethodCompilationStat::kUnresolvedMethod); 812 HInvoke* invoke = new (arena_) HInvokeUnresolved(arena_, 813 number_of_arguments, 814 return_type, 815 dex_pc, 816 method_idx, 817 original_invoke_type); 818 return HandleInvoke(invoke, 819 number_of_vreg_arguments, 820 args, 821 register_index, 822 is_range, 823 descriptor, 824 nullptr /* clinit_check */); 825 } 826 827 // Handle resolved methods (non string init). 828 829 DCHECK(optimized_invoke_type != kSuper); 830 831 // Potential class initialization check, in the case of a static method call. 832 HClinitCheck* clinit_check = nullptr; 833 HInvoke* invoke = nullptr; 834 835 if (optimized_invoke_type == kDirect || optimized_invoke_type == kStatic) { 836 // By default, consider that the called method implicitly requires 837 // an initialization check of its declaring method. 838 HInvokeStaticOrDirect::ClinitCheckRequirement clinit_check_requirement 839 = HInvokeStaticOrDirect::ClinitCheckRequirement::kImplicit; 840 if (optimized_invoke_type == kStatic) { 841 clinit_check = ProcessClinitCheckForInvoke(dex_pc, method_idx, &clinit_check_requirement); 842 } 843 844 HInvokeStaticOrDirect::DispatchInfo dispatch_info = ComputeDispatchInfo(is_string_init, 845 string_init_offset, 846 target_method, 847 direct_method, 848 direct_code); 849 invoke = new (arena_) HInvokeStaticOrDirect(arena_, 850 number_of_arguments, 851 return_type, 852 dex_pc, 853 method_idx, 854 target_method, 855 dispatch_info, 856 original_invoke_type, 857 optimized_invoke_type, 858 clinit_check_requirement); 859 } else if (optimized_invoke_type == kVirtual) { 860 invoke = new (arena_) HInvokeVirtual(arena_, 861 number_of_arguments, 862 return_type, 863 dex_pc, 864 method_idx, 865 table_index); 866 } else { 867 DCHECK_EQ(optimized_invoke_type, kInterface); 868 invoke = new (arena_) HInvokeInterface(arena_, 869 number_of_arguments, 870 return_type, 871 dex_pc, 872 method_idx, 873 table_index); 874 } 875 876 return HandleInvoke(invoke, 877 number_of_vreg_arguments, 878 args, 879 register_index, 880 is_range, 881 descriptor, 882 clinit_check); 883} 884 885HClinitCheck* HGraphBuilder::ProcessClinitCheckForInvoke( 886 uint32_t dex_pc, 887 uint32_t method_idx, 888 HInvokeStaticOrDirect::ClinitCheckRequirement* clinit_check_requirement) { 889 ScopedObjectAccess soa(Thread::Current()); 890 StackHandleScope<4> hs(soa.Self()); 891 Handle<mirror::DexCache> dex_cache(hs.NewHandle( 892 dex_compilation_unit_->GetClassLinker()->FindDexCache( 893 soa.Self(), *dex_compilation_unit_->GetDexFile()))); 894 Handle<mirror::ClassLoader> class_loader(hs.NewHandle( 895 soa.Decode<mirror::ClassLoader*>(dex_compilation_unit_->GetClassLoader()))); 896 ArtMethod* resolved_method = compiler_driver_->ResolveMethod( 897 soa, dex_cache, class_loader, dex_compilation_unit_, method_idx, InvokeType::kStatic); 898 899 DCHECK(resolved_method != nullptr); 900 901 const DexFile& outer_dex_file = *outer_compilation_unit_->GetDexFile(); 902 Handle<mirror::DexCache> outer_dex_cache(hs.NewHandle( 903 outer_compilation_unit_->GetClassLinker()->FindDexCache(soa.Self(), outer_dex_file))); 904 Handle<mirror::Class> outer_class(hs.NewHandle(GetOutermostCompilingClass())); 905 906 // The index at which the method's class is stored in the DexCache's type array. 907 uint32_t storage_index = DexFile::kDexNoIndex; 908 bool is_outer_class = (resolved_method->GetDeclaringClass() == outer_class.Get()); 909 if (is_outer_class) { 910 storage_index = outer_class->GetDexTypeIndex(); 911 } else if (outer_dex_cache.Get() == dex_cache.Get()) { 912 // Get `storage_index` from IsClassOfStaticMethodAvailableToReferrer. 913 compiler_driver_->IsClassOfStaticMethodAvailableToReferrer(outer_dex_cache.Get(), 914 GetCompilingClass(), 915 resolved_method, 916 method_idx, 917 &storage_index); 918 } 919 920 HClinitCheck* clinit_check = nullptr; 921 922 if (!outer_class->IsInterface() 923 && outer_class->IsSubClass(resolved_method->GetDeclaringClass())) { 924 // If the outer class is the declaring class or a subclass 925 // of the declaring class, no class initialization is needed 926 // before the static method call. 927 // Note that in case of inlining, we do not need to add clinit checks 928 // to calls that satisfy this subclass check with any inlined methods. This 929 // will be detected by the optimization passes. 930 *clinit_check_requirement = HInvokeStaticOrDirect::ClinitCheckRequirement::kNone; 931 } else if (storage_index != DexFile::kDexNoIndex) { 932 // If the method's class type index is available, check 933 // whether we should add an explicit class initialization 934 // check for its declaring class before the static method call. 935 936 // TODO: find out why this check is needed. 937 bool is_in_dex_cache = compiler_driver_->CanAssumeTypeIsPresentInDexCache( 938 *outer_compilation_unit_->GetDexFile(), storage_index); 939 bool is_initialized = 940 resolved_method->GetDeclaringClass()->IsInitialized() && is_in_dex_cache; 941 942 if (is_initialized) { 943 *clinit_check_requirement = HInvokeStaticOrDirect::ClinitCheckRequirement::kNone; 944 } else { 945 *clinit_check_requirement = HInvokeStaticOrDirect::ClinitCheckRequirement::kExplicit; 946 HLoadClass* load_class = new (arena_) HLoadClass( 947 graph_->GetCurrentMethod(), 948 storage_index, 949 *dex_compilation_unit_->GetDexFile(), 950 is_outer_class, 951 dex_pc, 952 /*needs_access_check*/ false); 953 current_block_->AddInstruction(load_class); 954 clinit_check = new (arena_) HClinitCheck(load_class, dex_pc); 955 current_block_->AddInstruction(clinit_check); 956 } 957 } 958 return clinit_check; 959} 960 961HInvokeStaticOrDirect::DispatchInfo HGraphBuilder::ComputeDispatchInfo( 962 bool is_string_init, 963 int32_t string_init_offset, 964 MethodReference target_method, 965 uintptr_t direct_method, 966 uintptr_t direct_code) { 967 HInvokeStaticOrDirect::MethodLoadKind method_load_kind; 968 HInvokeStaticOrDirect::CodePtrLocation code_ptr_location; 969 uint64_t method_load_data = 0u; 970 uint64_t direct_code_ptr = 0u; 971 972 if (is_string_init) { 973 // TODO: Use direct_method and direct_code for the appropriate StringFactory method. 974 method_load_kind = HInvokeStaticOrDirect::MethodLoadKind::kStringInit; 975 code_ptr_location = HInvokeStaticOrDirect::CodePtrLocation::kCallArtMethod; 976 method_load_data = string_init_offset; 977 } else if (target_method.dex_file == outer_compilation_unit_->GetDexFile() && 978 target_method.dex_method_index == outer_compilation_unit_->GetDexMethodIndex()) { 979 method_load_kind = HInvokeStaticOrDirect::MethodLoadKind::kRecursive; 980 code_ptr_location = HInvokeStaticOrDirect::CodePtrLocation::kCallSelf; 981 } else { 982 if (direct_method != 0u) { // Should we use a direct pointer to the method? 983 if (direct_method != static_cast<uintptr_t>(-1)) { // Is the method pointer known now? 984 method_load_kind = HInvokeStaticOrDirect::MethodLoadKind::kDirectAddress; 985 method_load_data = direct_method; 986 } else { // The direct pointer will be known at link time. 987 method_load_kind = HInvokeStaticOrDirect::MethodLoadKind::kDirectAddressWithFixup; 988 } 989 } else { // Use dex cache. 990 DCHECK(target_method.dex_file == dex_compilation_unit_->GetDexFile()); 991 DexCacheArraysLayout layout = 992 compiler_driver_->GetDexCacheArraysLayout(target_method.dex_file); 993 if (layout.Valid()) { // Can we use PC-relative access to the dex cache arrays? 994 method_load_kind = HInvokeStaticOrDirect::MethodLoadKind::kDexCachePcRelative; 995 method_load_data = layout.MethodOffset(target_method.dex_method_index); 996 } else { // We must go through the ArtMethod's pointer to resolved methods. 997 method_load_kind = HInvokeStaticOrDirect::MethodLoadKind::kDexCacheViaMethod; 998 } 999 } 1000 if (direct_code != 0u) { // Should we use a direct pointer to the code? 1001 if (direct_code != static_cast<uintptr_t>(-1)) { // Is the code pointer known now? 1002 code_ptr_location = HInvokeStaticOrDirect::CodePtrLocation::kCallDirect; 1003 direct_code_ptr = direct_code; 1004 } else if (compiler_driver_->IsImage() || 1005 target_method.dex_file == dex_compilation_unit_->GetDexFile()) { 1006 // Use PC-relative calls for invokes within a multi-dex oat file. 1007 // TODO: Recognize when the target dex file is within the current oat file for 1008 // app compilation. At the moment we recognize only the boot image as multi-dex. 1009 // NOTE: This will require changing the ARM backend which currently falls 1010 // through from kCallPCRelative to kDirectCodeFixup for different dex files. 1011 code_ptr_location = HInvokeStaticOrDirect::CodePtrLocation::kCallPCRelative; 1012 } else { // The direct pointer will be known at link time. 1013 // NOTE: This is used for app->boot calls when compiling an app against 1014 // a relocatable but not yet relocated image. 1015 code_ptr_location = HInvokeStaticOrDirect::CodePtrLocation::kCallDirectWithFixup; 1016 } 1017 } else { // We must use the code pointer from the ArtMethod. 1018 code_ptr_location = HInvokeStaticOrDirect::CodePtrLocation::kCallArtMethod; 1019 } 1020 } 1021 1022 if (graph_->IsDebuggable()) { 1023 // For debuggable apps always use the code pointer from ArtMethod 1024 // so that we don't circumvent instrumentation stubs if installed. 1025 code_ptr_location = HInvokeStaticOrDirect::CodePtrLocation::kCallArtMethod; 1026 } 1027 1028 return HInvokeStaticOrDirect::DispatchInfo { 1029 method_load_kind, code_ptr_location, method_load_data, direct_code_ptr }; 1030} 1031 1032bool HGraphBuilder::SetupInvokeArguments(HInvoke* invoke, 1033 uint32_t number_of_vreg_arguments, 1034 uint32_t* args, 1035 uint32_t register_index, 1036 bool is_range, 1037 const char* descriptor, 1038 size_t start_index, 1039 size_t* argument_index) { 1040 uint32_t descriptor_index = 1; // Skip the return type. 1041 uint32_t dex_pc = invoke->GetDexPc(); 1042 1043 for (size_t i = start_index; 1044 // Make sure we don't go over the expected arguments or over the number of 1045 // dex registers given. If the instruction was seen as dead by the verifier, 1046 // it hasn't been properly checked. 1047 (i < number_of_vreg_arguments) && (*argument_index < invoke->GetNumberOfArguments()); 1048 i++, (*argument_index)++) { 1049 Primitive::Type type = Primitive::GetType(descriptor[descriptor_index++]); 1050 bool is_wide = (type == Primitive::kPrimLong) || (type == Primitive::kPrimDouble); 1051 if (!is_range 1052 && is_wide 1053 && ((i + 1 == number_of_vreg_arguments) || (args[i] + 1 != args[i + 1]))) { 1054 // Longs and doubles should be in pairs, that is, sequential registers. The verifier should 1055 // reject any class where this is violated. However, the verifier only does these checks 1056 // on non trivially dead instructions, so we just bailout the compilation. 1057 VLOG(compiler) << "Did not compile " 1058 << PrettyMethod(dex_compilation_unit_->GetDexMethodIndex(), *dex_file_) 1059 << " because of non-sequential dex register pair in wide argument"; 1060 MaybeRecordStat(MethodCompilationStat::kNotCompiledMalformedOpcode); 1061 return false; 1062 } 1063 HInstruction* arg = LoadLocal(is_range ? register_index + i : args[i], type, dex_pc); 1064 invoke->SetArgumentAt(*argument_index, arg); 1065 if (is_wide) { 1066 i++; 1067 } 1068 } 1069 1070 if (*argument_index != invoke->GetNumberOfArguments()) { 1071 VLOG(compiler) << "Did not compile " 1072 << PrettyMethod(dex_compilation_unit_->GetDexMethodIndex(), *dex_file_) 1073 << " because of wrong number of arguments in invoke instruction"; 1074 MaybeRecordStat(MethodCompilationStat::kNotCompiledMalformedOpcode); 1075 return false; 1076 } 1077 1078 if (invoke->IsInvokeStaticOrDirect()) { 1079 invoke->SetArgumentAt(*argument_index, graph_->GetCurrentMethod()); 1080 (*argument_index)++; 1081 } 1082 1083 return true; 1084} 1085 1086bool HGraphBuilder::HandleInvoke(HInvoke* invoke, 1087 uint32_t number_of_vreg_arguments, 1088 uint32_t* args, 1089 uint32_t register_index, 1090 bool is_range, 1091 const char* descriptor, 1092 HClinitCheck* clinit_check) { 1093 DCHECK(!invoke->IsInvokeStaticOrDirect() || !invoke->AsInvokeStaticOrDirect()->IsStringInit()); 1094 1095 size_t start_index = 0; 1096 size_t argument_index = 0; 1097 if (invoke->GetOriginalInvokeType() != InvokeType::kStatic) { // Instance call. 1098 Temporaries temps(graph_); 1099 HInstruction* arg = LoadLocal( 1100 is_range ? register_index : args[0], Primitive::kPrimNot, invoke->GetDexPc()); 1101 HNullCheck* null_check = new (arena_) HNullCheck(arg, invoke->GetDexPc()); 1102 current_block_->AddInstruction(null_check); 1103 temps.Add(null_check); 1104 invoke->SetArgumentAt(0, null_check); 1105 start_index = 1; 1106 argument_index = 1; 1107 } 1108 1109 if (!SetupInvokeArguments(invoke, 1110 number_of_vreg_arguments, 1111 args, 1112 register_index, 1113 is_range, 1114 descriptor, 1115 start_index, 1116 &argument_index)) { 1117 return false; 1118 } 1119 1120 if (clinit_check != nullptr) { 1121 // Add the class initialization check as last input of `invoke`. 1122 DCHECK(invoke->IsInvokeStaticOrDirect()); 1123 DCHECK(invoke->AsInvokeStaticOrDirect()->GetClinitCheckRequirement() 1124 == HInvokeStaticOrDirect::ClinitCheckRequirement::kExplicit); 1125 invoke->SetArgumentAt(argument_index, clinit_check); 1126 argument_index++; 1127 } 1128 1129 current_block_->AddInstruction(invoke); 1130 latest_result_ = invoke; 1131 1132 return true; 1133} 1134 1135bool HGraphBuilder::HandleStringInit(HInvoke* invoke, 1136 uint32_t number_of_vreg_arguments, 1137 uint32_t* args, 1138 uint32_t register_index, 1139 bool is_range, 1140 const char* descriptor) { 1141 DCHECK(invoke->IsInvokeStaticOrDirect()); 1142 DCHECK(invoke->AsInvokeStaticOrDirect()->IsStringInit()); 1143 1144 size_t start_index = 1; 1145 size_t argument_index = 0; 1146 if (!SetupInvokeArguments(invoke, 1147 number_of_vreg_arguments, 1148 args, 1149 register_index, 1150 is_range, 1151 descriptor, 1152 start_index, 1153 &argument_index)) { 1154 return false; 1155 } 1156 1157 // Add move-result for StringFactory method. 1158 uint32_t orig_this_reg = is_range ? register_index : args[0]; 1159 HInstruction* fake_string = LoadLocal(orig_this_reg, Primitive::kPrimNot, invoke->GetDexPc()); 1160 invoke->SetArgumentAt(argument_index, fake_string); 1161 current_block_->AddInstruction(invoke); 1162 PotentiallySimplifyFakeString(orig_this_reg, invoke->GetDexPc(), invoke); 1163 1164 latest_result_ = invoke; 1165 1166 return true; 1167} 1168 1169void HGraphBuilder::PotentiallySimplifyFakeString(uint16_t original_dex_register, 1170 uint32_t dex_pc, 1171 HInvoke* actual_string) { 1172 if (!graph_->IsDebuggable()) { 1173 // Notify that we cannot compile with baseline. The dex registers aliasing 1174 // with `original_dex_register` will be handled when we optimize 1175 // (see HInstructionSimplifer::VisitFakeString). 1176 can_use_baseline_for_string_init_ = false; 1177 return; 1178 } 1179 const VerifiedMethod* verified_method = 1180 compiler_driver_->GetVerifiedMethod(dex_file_, dex_compilation_unit_->GetDexMethodIndex()); 1181 if (verified_method != nullptr) { 1182 UpdateLocal(original_dex_register, actual_string, dex_pc); 1183 const SafeMap<uint32_t, std::set<uint32_t>>& string_init_map = 1184 verified_method->GetStringInitPcRegMap(); 1185 auto map_it = string_init_map.find(dex_pc); 1186 if (map_it != string_init_map.end()) { 1187 std::set<uint32_t> reg_set = map_it->second; 1188 for (auto set_it = reg_set.begin(); set_it != reg_set.end(); ++set_it) { 1189 HInstruction* load_local = LoadLocal(original_dex_register, Primitive::kPrimNot, dex_pc); 1190 UpdateLocal(*set_it, load_local, dex_pc); 1191 } 1192 } 1193 } else { 1194 can_use_baseline_for_string_init_ = false; 1195 } 1196} 1197 1198static Primitive::Type GetFieldAccessType(const DexFile& dex_file, uint16_t field_index) { 1199 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_index); 1200 const char* type = dex_file.GetFieldTypeDescriptor(field_id); 1201 return Primitive::GetType(type[0]); 1202} 1203 1204bool HGraphBuilder::BuildInstanceFieldAccess(const Instruction& instruction, 1205 uint32_t dex_pc, 1206 bool is_put) { 1207 uint32_t source_or_dest_reg = instruction.VRegA_22c(); 1208 uint32_t obj_reg = instruction.VRegB_22c(); 1209 uint16_t field_index; 1210 if (instruction.IsQuickened()) { 1211 if (!CanDecodeQuickenedInfo()) { 1212 return false; 1213 } 1214 field_index = LookupQuickenedInfo(dex_pc); 1215 } else { 1216 field_index = instruction.VRegC_22c(); 1217 } 1218 1219 ScopedObjectAccess soa(Thread::Current()); 1220 ArtField* resolved_field = 1221 compiler_driver_->ComputeInstanceFieldInfo(field_index, dex_compilation_unit_, is_put, soa); 1222 1223 1224 HInstruction* object = LoadLocal(obj_reg, Primitive::kPrimNot, dex_pc); 1225 HInstruction* null_check = new (arena_) HNullCheck(object, dex_pc); 1226 current_block_->AddInstruction(null_check); 1227 1228 Primitive::Type field_type = (resolved_field == nullptr) 1229 ? GetFieldAccessType(*dex_file_, field_index) 1230 : resolved_field->GetTypeAsPrimitiveType(); 1231 if (is_put) { 1232 Temporaries temps(graph_); 1233 // We need one temporary for the null check. 1234 temps.Add(null_check); 1235 HInstruction* value = LoadLocal(source_or_dest_reg, field_type, dex_pc); 1236 HInstruction* field_set = nullptr; 1237 if (resolved_field == nullptr) { 1238 MaybeRecordStat(MethodCompilationStat::kUnresolvedField); 1239 field_set = new (arena_) HUnresolvedInstanceFieldSet(null_check, 1240 value, 1241 field_type, 1242 field_index, 1243 dex_pc); 1244 } else { 1245 field_set = new (arena_) HInstanceFieldSet(null_check, 1246 value, 1247 field_type, 1248 resolved_field->GetOffset(), 1249 resolved_field->IsVolatile(), 1250 field_index, 1251 *dex_file_, 1252 dex_compilation_unit_->GetDexCache(), 1253 dex_pc); 1254 } 1255 current_block_->AddInstruction(field_set); 1256 } else { 1257 HInstruction* field_get = nullptr; 1258 if (resolved_field == nullptr) { 1259 MaybeRecordStat(MethodCompilationStat::kUnresolvedField); 1260 field_get = new (arena_) HUnresolvedInstanceFieldGet(null_check, 1261 field_type, 1262 field_index, 1263 dex_pc); 1264 } else { 1265 field_get = new (arena_) HInstanceFieldGet(null_check, 1266 field_type, 1267 resolved_field->GetOffset(), 1268 resolved_field->IsVolatile(), 1269 field_index, 1270 *dex_file_, 1271 dex_compilation_unit_->GetDexCache(), 1272 dex_pc); 1273 } 1274 current_block_->AddInstruction(field_get); 1275 UpdateLocal(source_or_dest_reg, field_get, dex_pc); 1276 } 1277 1278 return true; 1279} 1280 1281static mirror::Class* GetClassFrom(CompilerDriver* driver, 1282 const DexCompilationUnit& compilation_unit) { 1283 ScopedObjectAccess soa(Thread::Current()); 1284 StackHandleScope<2> hs(soa.Self()); 1285 const DexFile& dex_file = *compilation_unit.GetDexFile(); 1286 Handle<mirror::ClassLoader> class_loader(hs.NewHandle( 1287 soa.Decode<mirror::ClassLoader*>(compilation_unit.GetClassLoader()))); 1288 Handle<mirror::DexCache> dex_cache(hs.NewHandle( 1289 compilation_unit.GetClassLinker()->FindDexCache(soa.Self(), dex_file))); 1290 1291 return driver->ResolveCompilingMethodsClass(soa, dex_cache, class_loader, &compilation_unit); 1292} 1293 1294mirror::Class* HGraphBuilder::GetOutermostCompilingClass() const { 1295 return GetClassFrom(compiler_driver_, *outer_compilation_unit_); 1296} 1297 1298mirror::Class* HGraphBuilder::GetCompilingClass() const { 1299 return GetClassFrom(compiler_driver_, *dex_compilation_unit_); 1300} 1301 1302bool HGraphBuilder::IsOutermostCompilingClass(uint16_t type_index) const { 1303 ScopedObjectAccess soa(Thread::Current()); 1304 StackHandleScope<4> hs(soa.Self()); 1305 Handle<mirror::DexCache> dex_cache(hs.NewHandle( 1306 dex_compilation_unit_->GetClassLinker()->FindDexCache( 1307 soa.Self(), *dex_compilation_unit_->GetDexFile()))); 1308 Handle<mirror::ClassLoader> class_loader(hs.NewHandle( 1309 soa.Decode<mirror::ClassLoader*>(dex_compilation_unit_->GetClassLoader()))); 1310 Handle<mirror::Class> cls(hs.NewHandle(compiler_driver_->ResolveClass( 1311 soa, dex_cache, class_loader, type_index, dex_compilation_unit_))); 1312 Handle<mirror::Class> outer_class(hs.NewHandle(GetOutermostCompilingClass())); 1313 1314 return outer_class.Get() == cls.Get(); 1315} 1316 1317void HGraphBuilder::BuildUnresolvedStaticFieldAccess(const Instruction& instruction, 1318 uint32_t dex_pc, 1319 bool is_put, 1320 Primitive::Type field_type) { 1321 uint32_t source_or_dest_reg = instruction.VRegA_21c(); 1322 uint16_t field_index = instruction.VRegB_21c(); 1323 1324 if (is_put) { 1325 HInstruction* value = LoadLocal(source_or_dest_reg, field_type, dex_pc); 1326 current_block_->AddInstruction( 1327 new (arena_) HUnresolvedStaticFieldSet(value, field_type, field_index, dex_pc)); 1328 } else { 1329 current_block_->AddInstruction( 1330 new (arena_) HUnresolvedStaticFieldGet(field_type, field_index, dex_pc)); 1331 UpdateLocal(source_or_dest_reg, current_block_->GetLastInstruction(), dex_pc); 1332 } 1333} 1334bool HGraphBuilder::BuildStaticFieldAccess(const Instruction& instruction, 1335 uint32_t dex_pc, 1336 bool is_put) { 1337 uint32_t source_or_dest_reg = instruction.VRegA_21c(); 1338 uint16_t field_index = instruction.VRegB_21c(); 1339 1340 ScopedObjectAccess soa(Thread::Current()); 1341 StackHandleScope<4> hs(soa.Self()); 1342 Handle<mirror::DexCache> dex_cache(hs.NewHandle( 1343 dex_compilation_unit_->GetClassLinker()->FindDexCache( 1344 soa.Self(), *dex_compilation_unit_->GetDexFile()))); 1345 Handle<mirror::ClassLoader> class_loader(hs.NewHandle( 1346 soa.Decode<mirror::ClassLoader*>(dex_compilation_unit_->GetClassLoader()))); 1347 ArtField* resolved_field = compiler_driver_->ResolveField( 1348 soa, dex_cache, class_loader, dex_compilation_unit_, field_index, true); 1349 1350 if (resolved_field == nullptr) { 1351 MaybeRecordStat(MethodCompilationStat::kUnresolvedField); 1352 Primitive::Type field_type = GetFieldAccessType(*dex_file_, field_index); 1353 BuildUnresolvedStaticFieldAccess(instruction, dex_pc, is_put, field_type); 1354 return true; 1355 } 1356 1357 Primitive::Type field_type = resolved_field->GetTypeAsPrimitiveType(); 1358 const DexFile& outer_dex_file = *outer_compilation_unit_->GetDexFile(); 1359 Handle<mirror::DexCache> outer_dex_cache(hs.NewHandle( 1360 outer_compilation_unit_->GetClassLinker()->FindDexCache(soa.Self(), outer_dex_file))); 1361 Handle<mirror::Class> outer_class(hs.NewHandle(GetOutermostCompilingClass())); 1362 1363 // The index at which the field's class is stored in the DexCache's type array. 1364 uint32_t storage_index; 1365 bool is_outer_class = (outer_class.Get() == resolved_field->GetDeclaringClass()); 1366 if (is_outer_class) { 1367 storage_index = outer_class->GetDexTypeIndex(); 1368 } else if (outer_dex_cache.Get() != dex_cache.Get()) { 1369 // The compiler driver cannot currently understand multiple dex caches involved. Just bailout. 1370 return false; 1371 } else { 1372 // TODO: This is rather expensive. Perf it and cache the results if needed. 1373 std::pair<bool, bool> pair = compiler_driver_->IsFastStaticField( 1374 outer_dex_cache.Get(), 1375 GetCompilingClass(), 1376 resolved_field, 1377 field_index, 1378 &storage_index); 1379 bool can_easily_access = is_put ? pair.second : pair.first; 1380 if (!can_easily_access) { 1381 MaybeRecordStat(MethodCompilationStat::kUnresolvedFieldNotAFastAccess); 1382 BuildUnresolvedStaticFieldAccess(instruction, dex_pc, is_put, field_type); 1383 return true; 1384 } 1385 } 1386 1387 // TODO: find out why this check is needed. 1388 bool is_in_dex_cache = compiler_driver_->CanAssumeTypeIsPresentInDexCache( 1389 *outer_compilation_unit_->GetDexFile(), storage_index); 1390 bool is_initialized = resolved_field->GetDeclaringClass()->IsInitialized() && is_in_dex_cache; 1391 1392 HLoadClass* constant = new (arena_) HLoadClass(graph_->GetCurrentMethod(), 1393 storage_index, 1394 *dex_compilation_unit_->GetDexFile(), 1395 is_outer_class, 1396 dex_pc, 1397 /*needs_access_check*/ false); 1398 current_block_->AddInstruction(constant); 1399 1400 HInstruction* cls = constant; 1401 if (!is_initialized && !is_outer_class) { 1402 cls = new (arena_) HClinitCheck(constant, dex_pc); 1403 current_block_->AddInstruction(cls); 1404 } 1405 if (is_put) { 1406 // We need to keep the class alive before loading the value. 1407 Temporaries temps(graph_); 1408 temps.Add(cls); 1409 HInstruction* value = LoadLocal(source_or_dest_reg, field_type, dex_pc); 1410 DCHECK_EQ(value->GetType(), field_type); 1411 current_block_->AddInstruction(new (arena_) HStaticFieldSet(cls, 1412 value, 1413 field_type, 1414 resolved_field->GetOffset(), 1415 resolved_field->IsVolatile(), 1416 field_index, 1417 *dex_file_, 1418 dex_cache_, 1419 dex_pc)); 1420 } else { 1421 current_block_->AddInstruction(new (arena_) HStaticFieldGet(cls, 1422 field_type, 1423 resolved_field->GetOffset(), 1424 resolved_field->IsVolatile(), 1425 field_index, 1426 *dex_file_, 1427 dex_cache_, 1428 dex_pc)); 1429 UpdateLocal(source_or_dest_reg, current_block_->GetLastInstruction(), dex_pc); 1430 } 1431 return true; 1432} 1433 1434void HGraphBuilder::BuildCheckedDivRem(uint16_t out_vreg, 1435 uint16_t first_vreg, 1436 int64_t second_vreg_or_constant, 1437 uint32_t dex_pc, 1438 Primitive::Type type, 1439 bool second_is_constant, 1440 bool isDiv) { 1441 DCHECK(type == Primitive::kPrimInt || type == Primitive::kPrimLong); 1442 1443 HInstruction* first = LoadLocal(first_vreg, type, dex_pc); 1444 HInstruction* second = nullptr; 1445 if (second_is_constant) { 1446 if (type == Primitive::kPrimInt) { 1447 second = graph_->GetIntConstant(second_vreg_or_constant, dex_pc); 1448 } else { 1449 second = graph_->GetLongConstant(second_vreg_or_constant, dex_pc); 1450 } 1451 } else { 1452 second = LoadLocal(second_vreg_or_constant, type, dex_pc); 1453 } 1454 1455 if (!second_is_constant 1456 || (type == Primitive::kPrimInt && second->AsIntConstant()->GetValue() == 0) 1457 || (type == Primitive::kPrimLong && second->AsLongConstant()->GetValue() == 0)) { 1458 second = new (arena_) HDivZeroCheck(second, dex_pc); 1459 Temporaries temps(graph_); 1460 current_block_->AddInstruction(second); 1461 temps.Add(current_block_->GetLastInstruction()); 1462 } 1463 1464 if (isDiv) { 1465 current_block_->AddInstruction(new (arena_) HDiv(type, first, second, dex_pc)); 1466 } else { 1467 current_block_->AddInstruction(new (arena_) HRem(type, first, second, dex_pc)); 1468 } 1469 UpdateLocal(out_vreg, current_block_->GetLastInstruction(), dex_pc); 1470} 1471 1472void HGraphBuilder::BuildArrayAccess(const Instruction& instruction, 1473 uint32_t dex_pc, 1474 bool is_put, 1475 Primitive::Type anticipated_type) { 1476 uint8_t source_or_dest_reg = instruction.VRegA_23x(); 1477 uint8_t array_reg = instruction.VRegB_23x(); 1478 uint8_t index_reg = instruction.VRegC_23x(); 1479 1480 // We need one temporary for the null check, one for the index, and one for the length. 1481 Temporaries temps(graph_); 1482 1483 HInstruction* object = LoadLocal(array_reg, Primitive::kPrimNot, dex_pc); 1484 object = new (arena_) HNullCheck(object, dex_pc); 1485 current_block_->AddInstruction(object); 1486 temps.Add(object); 1487 1488 HInstruction* length = new (arena_) HArrayLength(object, dex_pc); 1489 current_block_->AddInstruction(length); 1490 temps.Add(length); 1491 HInstruction* index = LoadLocal(index_reg, Primitive::kPrimInt, dex_pc); 1492 index = new (arena_) HBoundsCheck(index, length, dex_pc); 1493 current_block_->AddInstruction(index); 1494 temps.Add(index); 1495 if (is_put) { 1496 HInstruction* value = LoadLocal(source_or_dest_reg, anticipated_type, dex_pc); 1497 // TODO: Insert a type check node if the type is Object. 1498 current_block_->AddInstruction(new (arena_) HArraySet( 1499 object, index, value, anticipated_type, dex_pc)); 1500 } else { 1501 current_block_->AddInstruction(new (arena_) HArrayGet(object, index, anticipated_type, dex_pc)); 1502 UpdateLocal(source_or_dest_reg, current_block_->GetLastInstruction(), dex_pc); 1503 } 1504 graph_->SetHasBoundsChecks(true); 1505} 1506 1507void HGraphBuilder::BuildFilledNewArray(uint32_t dex_pc, 1508 uint32_t type_index, 1509 uint32_t number_of_vreg_arguments, 1510 bool is_range, 1511 uint32_t* args, 1512 uint32_t register_index) { 1513 HInstruction* length = graph_->GetIntConstant(number_of_vreg_arguments, dex_pc); 1514 QuickEntrypointEnum entrypoint = NeedsAccessCheck(type_index) 1515 ? kQuickAllocArrayWithAccessCheck 1516 : kQuickAllocArray; 1517 HInstruction* object = new (arena_) HNewArray(length, 1518 graph_->GetCurrentMethod(), 1519 dex_pc, 1520 type_index, 1521 *dex_compilation_unit_->GetDexFile(), 1522 entrypoint); 1523 current_block_->AddInstruction(object); 1524 1525 const char* descriptor = dex_file_->StringByTypeIdx(type_index); 1526 DCHECK_EQ(descriptor[0], '[') << descriptor; 1527 char primitive = descriptor[1]; 1528 DCHECK(primitive == 'I' 1529 || primitive == 'L' 1530 || primitive == '[') << descriptor; 1531 bool is_reference_array = (primitive == 'L') || (primitive == '['); 1532 Primitive::Type type = is_reference_array ? Primitive::kPrimNot : Primitive::kPrimInt; 1533 1534 Temporaries temps(graph_); 1535 temps.Add(object); 1536 for (size_t i = 0; i < number_of_vreg_arguments; ++i) { 1537 HInstruction* value = LoadLocal(is_range ? register_index + i : args[i], type, dex_pc); 1538 HInstruction* index = graph_->GetIntConstant(i, dex_pc); 1539 current_block_->AddInstruction( 1540 new (arena_) HArraySet(object, index, value, type, dex_pc)); 1541 } 1542 latest_result_ = object; 1543} 1544 1545template <typename T> 1546void HGraphBuilder::BuildFillArrayData(HInstruction* object, 1547 const T* data, 1548 uint32_t element_count, 1549 Primitive::Type anticipated_type, 1550 uint32_t dex_pc) { 1551 for (uint32_t i = 0; i < element_count; ++i) { 1552 HInstruction* index = graph_->GetIntConstant(i, dex_pc); 1553 HInstruction* value = graph_->GetIntConstant(data[i], dex_pc); 1554 current_block_->AddInstruction(new (arena_) HArraySet( 1555 object, index, value, anticipated_type, dex_pc)); 1556 } 1557} 1558 1559void HGraphBuilder::BuildFillArrayData(const Instruction& instruction, uint32_t dex_pc) { 1560 Temporaries temps(graph_); 1561 HInstruction* array = LoadLocal(instruction.VRegA_31t(), Primitive::kPrimNot, dex_pc); 1562 HNullCheck* null_check = new (arena_) HNullCheck(array, dex_pc); 1563 current_block_->AddInstruction(null_check); 1564 temps.Add(null_check); 1565 1566 HInstruction* length = new (arena_) HArrayLength(null_check, dex_pc); 1567 current_block_->AddInstruction(length); 1568 1569 int32_t payload_offset = instruction.VRegB_31t() + dex_pc; 1570 const Instruction::ArrayDataPayload* payload = 1571 reinterpret_cast<const Instruction::ArrayDataPayload*>(code_start_ + payload_offset); 1572 const uint8_t* data = payload->data; 1573 uint32_t element_count = payload->element_count; 1574 1575 // Implementation of this DEX instruction seems to be that the bounds check is 1576 // done before doing any stores. 1577 HInstruction* last_index = graph_->GetIntConstant(payload->element_count - 1, dex_pc); 1578 current_block_->AddInstruction(new (arena_) HBoundsCheck(last_index, length, dex_pc)); 1579 1580 switch (payload->element_width) { 1581 case 1: 1582 BuildFillArrayData(null_check, 1583 reinterpret_cast<const int8_t*>(data), 1584 element_count, 1585 Primitive::kPrimByte, 1586 dex_pc); 1587 break; 1588 case 2: 1589 BuildFillArrayData(null_check, 1590 reinterpret_cast<const int16_t*>(data), 1591 element_count, 1592 Primitive::kPrimShort, 1593 dex_pc); 1594 break; 1595 case 4: 1596 BuildFillArrayData(null_check, 1597 reinterpret_cast<const int32_t*>(data), 1598 element_count, 1599 Primitive::kPrimInt, 1600 dex_pc); 1601 break; 1602 case 8: 1603 BuildFillWideArrayData(null_check, 1604 reinterpret_cast<const int64_t*>(data), 1605 element_count, 1606 dex_pc); 1607 break; 1608 default: 1609 LOG(FATAL) << "Unknown element width for " << payload->element_width; 1610 } 1611 graph_->SetHasBoundsChecks(true); 1612} 1613 1614void HGraphBuilder::BuildFillWideArrayData(HInstruction* object, 1615 const int64_t* data, 1616 uint32_t element_count, 1617 uint32_t dex_pc) { 1618 for (uint32_t i = 0; i < element_count; ++i) { 1619 HInstruction* index = graph_->GetIntConstant(i, dex_pc); 1620 HInstruction* value = graph_->GetLongConstant(data[i], dex_pc); 1621 current_block_->AddInstruction(new (arena_) HArraySet( 1622 object, index, value, Primitive::kPrimLong, dex_pc)); 1623 } 1624} 1625 1626static TypeCheckKind ComputeTypeCheckKind(Handle<mirror::Class> cls) 1627 SHARED_REQUIRES(Locks::mutator_lock_) { 1628 if (cls.Get() == nullptr) { 1629 return TypeCheckKind::kUnresolvedCheck; 1630 } else if (cls->IsInterface()) { 1631 return TypeCheckKind::kInterfaceCheck; 1632 } else if (cls->IsArrayClass()) { 1633 if (cls->GetComponentType()->IsObjectClass()) { 1634 return TypeCheckKind::kArrayObjectCheck; 1635 } else if (cls->CannotBeAssignedFromOtherTypes()) { 1636 return TypeCheckKind::kExactCheck; 1637 } else { 1638 return TypeCheckKind::kArrayCheck; 1639 } 1640 } else if (cls->IsFinal()) { 1641 return TypeCheckKind::kExactCheck; 1642 } else if (cls->IsAbstract()) { 1643 return TypeCheckKind::kAbstractClassCheck; 1644 } else { 1645 return TypeCheckKind::kClassHierarchyCheck; 1646 } 1647} 1648 1649void HGraphBuilder::BuildTypeCheck(const Instruction& instruction, 1650 uint8_t destination, 1651 uint8_t reference, 1652 uint16_t type_index, 1653 uint32_t dex_pc) { 1654 bool type_known_final, type_known_abstract, use_declaring_class; 1655 bool can_access = compiler_driver_->CanAccessTypeWithoutChecks( 1656 dex_compilation_unit_->GetDexMethodIndex(), 1657 *dex_compilation_unit_->GetDexFile(), 1658 type_index, 1659 &type_known_final, 1660 &type_known_abstract, 1661 &use_declaring_class); 1662 1663 ScopedObjectAccess soa(Thread::Current()); 1664 StackHandleScope<2> hs(soa.Self()); 1665 Handle<mirror::DexCache> dex_cache(hs.NewHandle( 1666 dex_compilation_unit_->GetClassLinker()->FindDexCache( 1667 soa.Self(), *dex_compilation_unit_->GetDexFile()))); 1668 Handle<mirror::Class> resolved_class(hs.NewHandle(dex_cache->GetResolvedType(type_index))); 1669 1670 HInstruction* object = LoadLocal(reference, Primitive::kPrimNot, dex_pc); 1671 HLoadClass* cls = new (arena_) HLoadClass( 1672 graph_->GetCurrentMethod(), 1673 type_index, 1674 *dex_compilation_unit_->GetDexFile(), 1675 IsOutermostCompilingClass(type_index), 1676 dex_pc, 1677 !can_access); 1678 current_block_->AddInstruction(cls); 1679 1680 // The class needs a temporary before being used by the type check. 1681 Temporaries temps(graph_); 1682 temps.Add(cls); 1683 1684 TypeCheckKind check_kind = ComputeTypeCheckKind(resolved_class); 1685 if (instruction.Opcode() == Instruction::INSTANCE_OF) { 1686 current_block_->AddInstruction(new (arena_) HInstanceOf(object, cls, check_kind, dex_pc)); 1687 UpdateLocal(destination, current_block_->GetLastInstruction(), dex_pc); 1688 } else { 1689 DCHECK_EQ(instruction.Opcode(), Instruction::CHECK_CAST); 1690 current_block_->AddInstruction(new (arena_) HCheckCast(object, cls, check_kind, dex_pc)); 1691 } 1692} 1693 1694bool HGraphBuilder::NeedsAccessCheck(uint32_t type_index) const { 1695 return !compiler_driver_->CanAccessInstantiableTypeWithoutChecks( 1696 dex_compilation_unit_->GetDexMethodIndex(), *dex_file_, type_index); 1697} 1698 1699void HGraphBuilder::BuildSwitchJumpTable(const SwitchTable& table, 1700 const Instruction& instruction, 1701 HInstruction* value, 1702 uint32_t dex_pc) { 1703 // Add the successor blocks to the current block. 1704 uint16_t num_entries = table.GetNumEntries(); 1705 for (size_t i = 1; i <= num_entries; i++) { 1706 int32_t target_offset = table.GetEntryAt(i); 1707 HBasicBlock* case_target = FindBlockStartingAt(dex_pc + target_offset); 1708 DCHECK(case_target != nullptr); 1709 1710 // Add the target block as a successor. 1711 current_block_->AddSuccessor(case_target); 1712 } 1713 1714 // Add the default target block as the last successor. 1715 HBasicBlock* default_target = FindBlockStartingAt(dex_pc + instruction.SizeInCodeUnits()); 1716 DCHECK(default_target != nullptr); 1717 current_block_->AddSuccessor(default_target); 1718 1719 // Now add the Switch instruction. 1720 int32_t starting_key = table.GetEntryAt(0); 1721 current_block_->AddInstruction( 1722 new (arena_) HPackedSwitch(starting_key, num_entries, value, dex_pc)); 1723 // This block ends with control flow. 1724 current_block_ = nullptr; 1725} 1726 1727void HGraphBuilder::BuildPackedSwitch(const Instruction& instruction, uint32_t dex_pc) { 1728 // Verifier guarantees that the payload for PackedSwitch contains: 1729 // (a) number of entries (may be zero) 1730 // (b) first and lowest switch case value (entry 0, always present) 1731 // (c) list of target pcs (entries 1 <= i <= N) 1732 SwitchTable table(instruction, dex_pc, false); 1733 1734 // Value to test against. 1735 HInstruction* value = LoadLocal(instruction.VRegA(), Primitive::kPrimInt, dex_pc); 1736 1737 // Starting key value. 1738 int32_t starting_key = table.GetEntryAt(0); 1739 1740 // Retrieve number of entries. 1741 uint16_t num_entries = table.GetNumEntries(); 1742 if (num_entries == 0) { 1743 return; 1744 } 1745 1746 // Don't use a packed switch if there are very few entries. 1747 if (num_entries > kSmallSwitchThreshold) { 1748 BuildSwitchJumpTable(table, instruction, value, dex_pc); 1749 } else { 1750 // Chained cmp-and-branch, starting from starting_key. 1751 for (size_t i = 1; i <= num_entries; i++) { 1752 BuildSwitchCaseHelper(instruction, 1753 i, 1754 i == num_entries, 1755 table, 1756 value, 1757 starting_key + i - 1, 1758 table.GetEntryAt(i), 1759 dex_pc); 1760 } 1761 } 1762} 1763 1764void HGraphBuilder::BuildSparseSwitch(const Instruction& instruction, uint32_t dex_pc) { 1765 // Verifier guarantees that the payload for SparseSwitch contains: 1766 // (a) number of entries (may be zero) 1767 // (b) sorted key values (entries 0 <= i < N) 1768 // (c) target pcs corresponding to the switch values (entries N <= i < 2*N) 1769 SwitchTable table(instruction, dex_pc, true); 1770 1771 // Value to test against. 1772 HInstruction* value = LoadLocal(instruction.VRegA(), Primitive::kPrimInt, dex_pc); 1773 1774 uint16_t num_entries = table.GetNumEntries(); 1775 1776 for (size_t i = 0; i < num_entries; i++) { 1777 BuildSwitchCaseHelper(instruction, i, i == static_cast<size_t>(num_entries) - 1, table, value, 1778 table.GetEntryAt(i), table.GetEntryAt(i + num_entries), dex_pc); 1779 } 1780} 1781 1782void HGraphBuilder::BuildSwitchCaseHelper(const Instruction& instruction, size_t index, 1783 bool is_last_case, const SwitchTable& table, 1784 HInstruction* value, int32_t case_value_int, 1785 int32_t target_offset, uint32_t dex_pc) { 1786 HBasicBlock* case_target = FindBlockStartingAt(dex_pc + target_offset); 1787 DCHECK(case_target != nullptr); 1788 PotentiallyAddSuspendCheck(case_target, dex_pc); 1789 1790 // The current case's value. 1791 HInstruction* this_case_value = graph_->GetIntConstant(case_value_int, dex_pc); 1792 1793 // Compare value and this_case_value. 1794 HEqual* comparison = new (arena_) HEqual(value, this_case_value, dex_pc); 1795 current_block_->AddInstruction(comparison); 1796 HInstruction* ifinst = new (arena_) HIf(comparison, dex_pc); 1797 current_block_->AddInstruction(ifinst); 1798 1799 // Case hit: use the target offset to determine where to go. 1800 current_block_->AddSuccessor(case_target); 1801 1802 // Case miss: go to the next case (or default fall-through). 1803 // When there is a next case, we use the block stored with the table offset representing this 1804 // case (that is where we registered them in ComputeBranchTargets). 1805 // When there is no next case, we use the following instruction. 1806 // TODO: Find a good way to peel the last iteration to avoid conditional, but still have re-use. 1807 if (!is_last_case) { 1808 HBasicBlock* next_case_target = FindBlockStartingAt(table.GetDexPcForIndex(index)); 1809 DCHECK(next_case_target != nullptr); 1810 current_block_->AddSuccessor(next_case_target); 1811 1812 // Need to manually add the block, as there is no dex-pc transition for the cases. 1813 graph_->AddBlock(next_case_target); 1814 1815 current_block_ = next_case_target; 1816 } else { 1817 HBasicBlock* default_target = FindBlockStartingAt(dex_pc + instruction.SizeInCodeUnits()); 1818 DCHECK(default_target != nullptr); 1819 current_block_->AddSuccessor(default_target); 1820 current_block_ = nullptr; 1821 } 1822} 1823 1824void HGraphBuilder::PotentiallyAddSuspendCheck(HBasicBlock* target, uint32_t dex_pc) { 1825 int32_t target_offset = target->GetDexPc() - dex_pc; 1826 if (target_offset <= 0) { 1827 // DX generates back edges to the first encountered return. We can save 1828 // time of later passes by not adding redundant suspend checks. 1829 HInstruction* last_in_target = target->GetLastInstruction(); 1830 if (last_in_target != nullptr && 1831 (last_in_target->IsReturn() || last_in_target->IsReturnVoid())) { 1832 return; 1833 } 1834 1835 // Add a suspend check to backward branches which may potentially loop. We 1836 // can remove them after we recognize loops in the graph. 1837 current_block_->AddInstruction(new (arena_) HSuspendCheck(dex_pc)); 1838 } 1839} 1840 1841bool HGraphBuilder::CanDecodeQuickenedInfo() const { 1842 return interpreter_metadata_ != nullptr; 1843} 1844 1845uint16_t HGraphBuilder::LookupQuickenedInfo(uint32_t dex_pc) { 1846 DCHECK(interpreter_metadata_ != nullptr); 1847 uint32_t dex_pc_in_map = DecodeUnsignedLeb128(&interpreter_metadata_); 1848 DCHECK_EQ(dex_pc, dex_pc_in_map); 1849 return DecodeUnsignedLeb128(&interpreter_metadata_); 1850} 1851 1852bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32_t dex_pc) { 1853 if (current_block_ == nullptr) { 1854 return true; // Dead code 1855 } 1856 1857 switch (instruction.Opcode()) { 1858 case Instruction::CONST_4: { 1859 int32_t register_index = instruction.VRegA(); 1860 HIntConstant* constant = graph_->GetIntConstant(instruction.VRegB_11n(), dex_pc); 1861 UpdateLocal(register_index, constant, dex_pc); 1862 break; 1863 } 1864 1865 case Instruction::CONST_16: { 1866 int32_t register_index = instruction.VRegA(); 1867 HIntConstant* constant = graph_->GetIntConstant(instruction.VRegB_21s(), dex_pc); 1868 UpdateLocal(register_index, constant, dex_pc); 1869 break; 1870 } 1871 1872 case Instruction::CONST: { 1873 int32_t register_index = instruction.VRegA(); 1874 HIntConstant* constant = graph_->GetIntConstant(instruction.VRegB_31i(), dex_pc); 1875 UpdateLocal(register_index, constant, dex_pc); 1876 break; 1877 } 1878 1879 case Instruction::CONST_HIGH16: { 1880 int32_t register_index = instruction.VRegA(); 1881 HIntConstant* constant = graph_->GetIntConstant(instruction.VRegB_21h() << 16, dex_pc); 1882 UpdateLocal(register_index, constant, dex_pc); 1883 break; 1884 } 1885 1886 case Instruction::CONST_WIDE_16: { 1887 int32_t register_index = instruction.VRegA(); 1888 // Get 16 bits of constant value, sign extended to 64 bits. 1889 int64_t value = instruction.VRegB_21s(); 1890 value <<= 48; 1891 value >>= 48; 1892 HLongConstant* constant = graph_->GetLongConstant(value, dex_pc); 1893 UpdateLocal(register_index, constant, dex_pc); 1894 break; 1895 } 1896 1897 case Instruction::CONST_WIDE_32: { 1898 int32_t register_index = instruction.VRegA(); 1899 // Get 32 bits of constant value, sign extended to 64 bits. 1900 int64_t value = instruction.VRegB_31i(); 1901 value <<= 32; 1902 value >>= 32; 1903 HLongConstant* constant = graph_->GetLongConstant(value, dex_pc); 1904 UpdateLocal(register_index, constant, dex_pc); 1905 break; 1906 } 1907 1908 case Instruction::CONST_WIDE: { 1909 int32_t register_index = instruction.VRegA(); 1910 HLongConstant* constant = graph_->GetLongConstant(instruction.VRegB_51l(), dex_pc); 1911 UpdateLocal(register_index, constant, dex_pc); 1912 break; 1913 } 1914 1915 case Instruction::CONST_WIDE_HIGH16: { 1916 int32_t register_index = instruction.VRegA(); 1917 int64_t value = static_cast<int64_t>(instruction.VRegB_21h()) << 48; 1918 HLongConstant* constant = graph_->GetLongConstant(value, dex_pc); 1919 UpdateLocal(register_index, constant, dex_pc); 1920 break; 1921 } 1922 1923 // Note that the SSA building will refine the types. 1924 case Instruction::MOVE: 1925 case Instruction::MOVE_FROM16: 1926 case Instruction::MOVE_16: { 1927 HInstruction* value = LoadLocal(instruction.VRegB(), Primitive::kPrimInt, dex_pc); 1928 UpdateLocal(instruction.VRegA(), value, dex_pc); 1929 break; 1930 } 1931 1932 // Note that the SSA building will refine the types. 1933 case Instruction::MOVE_WIDE: 1934 case Instruction::MOVE_WIDE_FROM16: 1935 case Instruction::MOVE_WIDE_16: { 1936 HInstruction* value = LoadLocal(instruction.VRegB(), Primitive::kPrimLong, dex_pc); 1937 UpdateLocal(instruction.VRegA(), value, dex_pc); 1938 break; 1939 } 1940 1941 case Instruction::MOVE_OBJECT: 1942 case Instruction::MOVE_OBJECT_16: 1943 case Instruction::MOVE_OBJECT_FROM16: { 1944 HInstruction* value = LoadLocal(instruction.VRegB(), Primitive::kPrimNot, dex_pc); 1945 UpdateLocal(instruction.VRegA(), value, dex_pc); 1946 break; 1947 } 1948 1949 case Instruction::RETURN_VOID_NO_BARRIER: 1950 case Instruction::RETURN_VOID: { 1951 BuildReturn(instruction, Primitive::kPrimVoid, dex_pc); 1952 break; 1953 } 1954 1955#define IF_XX(comparison, cond) \ 1956 case Instruction::IF_##cond: If_22t<comparison>(instruction, dex_pc); break; \ 1957 case Instruction::IF_##cond##Z: If_21t<comparison>(instruction, dex_pc); break 1958 1959 IF_XX(HEqual, EQ); 1960 IF_XX(HNotEqual, NE); 1961 IF_XX(HLessThan, LT); 1962 IF_XX(HLessThanOrEqual, LE); 1963 IF_XX(HGreaterThan, GT); 1964 IF_XX(HGreaterThanOrEqual, GE); 1965 1966 case Instruction::GOTO: 1967 case Instruction::GOTO_16: 1968 case Instruction::GOTO_32: { 1969 int32_t offset = instruction.GetTargetOffset(); 1970 HBasicBlock* target = FindBlockStartingAt(offset + dex_pc); 1971 DCHECK(target != nullptr); 1972 PotentiallyAddSuspendCheck(target, dex_pc); 1973 current_block_->AddInstruction(new (arena_) HGoto(dex_pc)); 1974 current_block_->AddSuccessor(target); 1975 current_block_ = nullptr; 1976 break; 1977 } 1978 1979 case Instruction::RETURN: { 1980 BuildReturn(instruction, return_type_, dex_pc); 1981 break; 1982 } 1983 1984 case Instruction::RETURN_OBJECT: { 1985 BuildReturn(instruction, return_type_, dex_pc); 1986 break; 1987 } 1988 1989 case Instruction::RETURN_WIDE: { 1990 BuildReturn(instruction, return_type_, dex_pc); 1991 break; 1992 } 1993 1994 case Instruction::INVOKE_DIRECT: 1995 case Instruction::INVOKE_INTERFACE: 1996 case Instruction::INVOKE_STATIC: 1997 case Instruction::INVOKE_SUPER: 1998 case Instruction::INVOKE_VIRTUAL: 1999 case Instruction::INVOKE_VIRTUAL_QUICK: { 2000 uint16_t method_idx; 2001 if (instruction.Opcode() == Instruction::INVOKE_VIRTUAL_QUICK) { 2002 if (!CanDecodeQuickenedInfo()) { 2003 return false; 2004 } 2005 method_idx = LookupQuickenedInfo(dex_pc); 2006 } else { 2007 method_idx = instruction.VRegB_35c(); 2008 } 2009 uint32_t number_of_vreg_arguments = instruction.VRegA_35c(); 2010 uint32_t args[5]; 2011 instruction.GetVarArgs(args); 2012 if (!BuildInvoke(instruction, dex_pc, method_idx, 2013 number_of_vreg_arguments, false, args, -1)) { 2014 return false; 2015 } 2016 break; 2017 } 2018 2019 case Instruction::INVOKE_DIRECT_RANGE: 2020 case Instruction::INVOKE_INTERFACE_RANGE: 2021 case Instruction::INVOKE_STATIC_RANGE: 2022 case Instruction::INVOKE_SUPER_RANGE: 2023 case Instruction::INVOKE_VIRTUAL_RANGE: 2024 case Instruction::INVOKE_VIRTUAL_RANGE_QUICK: { 2025 uint16_t method_idx; 2026 if (instruction.Opcode() == Instruction::INVOKE_VIRTUAL_RANGE_QUICK) { 2027 if (!CanDecodeQuickenedInfo()) { 2028 return false; 2029 } 2030 method_idx = LookupQuickenedInfo(dex_pc); 2031 } else { 2032 method_idx = instruction.VRegB_3rc(); 2033 } 2034 uint32_t number_of_vreg_arguments = instruction.VRegA_3rc(); 2035 uint32_t register_index = instruction.VRegC(); 2036 if (!BuildInvoke(instruction, dex_pc, method_idx, 2037 number_of_vreg_arguments, true, nullptr, register_index)) { 2038 return false; 2039 } 2040 break; 2041 } 2042 2043 case Instruction::NEG_INT: { 2044 Unop_12x<HNeg>(instruction, Primitive::kPrimInt, dex_pc); 2045 break; 2046 } 2047 2048 case Instruction::NEG_LONG: { 2049 Unop_12x<HNeg>(instruction, Primitive::kPrimLong, dex_pc); 2050 break; 2051 } 2052 2053 case Instruction::NEG_FLOAT: { 2054 Unop_12x<HNeg>(instruction, Primitive::kPrimFloat, dex_pc); 2055 break; 2056 } 2057 2058 case Instruction::NEG_DOUBLE: { 2059 Unop_12x<HNeg>(instruction, Primitive::kPrimDouble, dex_pc); 2060 break; 2061 } 2062 2063 case Instruction::NOT_INT: { 2064 Unop_12x<HNot>(instruction, Primitive::kPrimInt, dex_pc); 2065 break; 2066 } 2067 2068 case Instruction::NOT_LONG: { 2069 Unop_12x<HNot>(instruction, Primitive::kPrimLong, dex_pc); 2070 break; 2071 } 2072 2073 case Instruction::INT_TO_LONG: { 2074 Conversion_12x(instruction, Primitive::kPrimInt, Primitive::kPrimLong, dex_pc); 2075 break; 2076 } 2077 2078 case Instruction::INT_TO_FLOAT: { 2079 Conversion_12x(instruction, Primitive::kPrimInt, Primitive::kPrimFloat, dex_pc); 2080 break; 2081 } 2082 2083 case Instruction::INT_TO_DOUBLE: { 2084 Conversion_12x(instruction, Primitive::kPrimInt, Primitive::kPrimDouble, dex_pc); 2085 break; 2086 } 2087 2088 case Instruction::LONG_TO_INT: { 2089 Conversion_12x(instruction, Primitive::kPrimLong, Primitive::kPrimInt, dex_pc); 2090 break; 2091 } 2092 2093 case Instruction::LONG_TO_FLOAT: { 2094 Conversion_12x(instruction, Primitive::kPrimLong, Primitive::kPrimFloat, dex_pc); 2095 break; 2096 } 2097 2098 case Instruction::LONG_TO_DOUBLE: { 2099 Conversion_12x(instruction, Primitive::kPrimLong, Primitive::kPrimDouble, dex_pc); 2100 break; 2101 } 2102 2103 case Instruction::FLOAT_TO_INT: { 2104 Conversion_12x(instruction, Primitive::kPrimFloat, Primitive::kPrimInt, dex_pc); 2105 break; 2106 } 2107 2108 case Instruction::FLOAT_TO_LONG: { 2109 Conversion_12x(instruction, Primitive::kPrimFloat, Primitive::kPrimLong, dex_pc); 2110 break; 2111 } 2112 2113 case Instruction::FLOAT_TO_DOUBLE: { 2114 Conversion_12x(instruction, Primitive::kPrimFloat, Primitive::kPrimDouble, dex_pc); 2115 break; 2116 } 2117 2118 case Instruction::DOUBLE_TO_INT: { 2119 Conversion_12x(instruction, Primitive::kPrimDouble, Primitive::kPrimInt, dex_pc); 2120 break; 2121 } 2122 2123 case Instruction::DOUBLE_TO_LONG: { 2124 Conversion_12x(instruction, Primitive::kPrimDouble, Primitive::kPrimLong, dex_pc); 2125 break; 2126 } 2127 2128 case Instruction::DOUBLE_TO_FLOAT: { 2129 Conversion_12x(instruction, Primitive::kPrimDouble, Primitive::kPrimFloat, dex_pc); 2130 break; 2131 } 2132 2133 case Instruction::INT_TO_BYTE: { 2134 Conversion_12x(instruction, Primitive::kPrimInt, Primitive::kPrimByte, dex_pc); 2135 break; 2136 } 2137 2138 case Instruction::INT_TO_SHORT: { 2139 Conversion_12x(instruction, Primitive::kPrimInt, Primitive::kPrimShort, dex_pc); 2140 break; 2141 } 2142 2143 case Instruction::INT_TO_CHAR: { 2144 Conversion_12x(instruction, Primitive::kPrimInt, Primitive::kPrimChar, dex_pc); 2145 break; 2146 } 2147 2148 case Instruction::ADD_INT: { 2149 Binop_23x<HAdd>(instruction, Primitive::kPrimInt, dex_pc); 2150 break; 2151 } 2152 2153 case Instruction::ADD_LONG: { 2154 Binop_23x<HAdd>(instruction, Primitive::kPrimLong, dex_pc); 2155 break; 2156 } 2157 2158 case Instruction::ADD_DOUBLE: { 2159 Binop_23x<HAdd>(instruction, Primitive::kPrimDouble, dex_pc); 2160 break; 2161 } 2162 2163 case Instruction::ADD_FLOAT: { 2164 Binop_23x<HAdd>(instruction, Primitive::kPrimFloat, dex_pc); 2165 break; 2166 } 2167 2168 case Instruction::SUB_INT: { 2169 Binop_23x<HSub>(instruction, Primitive::kPrimInt, dex_pc); 2170 break; 2171 } 2172 2173 case Instruction::SUB_LONG: { 2174 Binop_23x<HSub>(instruction, Primitive::kPrimLong, dex_pc); 2175 break; 2176 } 2177 2178 case Instruction::SUB_FLOAT: { 2179 Binop_23x<HSub>(instruction, Primitive::kPrimFloat, dex_pc); 2180 break; 2181 } 2182 2183 case Instruction::SUB_DOUBLE: { 2184 Binop_23x<HSub>(instruction, Primitive::kPrimDouble, dex_pc); 2185 break; 2186 } 2187 2188 case Instruction::ADD_INT_2ADDR: { 2189 Binop_12x<HAdd>(instruction, Primitive::kPrimInt, dex_pc); 2190 break; 2191 } 2192 2193 case Instruction::MUL_INT: { 2194 Binop_23x<HMul>(instruction, Primitive::kPrimInt, dex_pc); 2195 break; 2196 } 2197 2198 case Instruction::MUL_LONG: { 2199 Binop_23x<HMul>(instruction, Primitive::kPrimLong, dex_pc); 2200 break; 2201 } 2202 2203 case Instruction::MUL_FLOAT: { 2204 Binop_23x<HMul>(instruction, Primitive::kPrimFloat, dex_pc); 2205 break; 2206 } 2207 2208 case Instruction::MUL_DOUBLE: { 2209 Binop_23x<HMul>(instruction, Primitive::kPrimDouble, dex_pc); 2210 break; 2211 } 2212 2213 case Instruction::DIV_INT: { 2214 BuildCheckedDivRem(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(), 2215 dex_pc, Primitive::kPrimInt, false, true); 2216 break; 2217 } 2218 2219 case Instruction::DIV_LONG: { 2220 BuildCheckedDivRem(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(), 2221 dex_pc, Primitive::kPrimLong, false, true); 2222 break; 2223 } 2224 2225 case Instruction::DIV_FLOAT: { 2226 Binop_23x<HDiv>(instruction, Primitive::kPrimFloat, dex_pc); 2227 break; 2228 } 2229 2230 case Instruction::DIV_DOUBLE: { 2231 Binop_23x<HDiv>(instruction, Primitive::kPrimDouble, dex_pc); 2232 break; 2233 } 2234 2235 case Instruction::REM_INT: { 2236 BuildCheckedDivRem(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(), 2237 dex_pc, Primitive::kPrimInt, false, false); 2238 break; 2239 } 2240 2241 case Instruction::REM_LONG: { 2242 BuildCheckedDivRem(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(), 2243 dex_pc, Primitive::kPrimLong, false, false); 2244 break; 2245 } 2246 2247 case Instruction::REM_FLOAT: { 2248 Binop_23x<HRem>(instruction, Primitive::kPrimFloat, dex_pc); 2249 break; 2250 } 2251 2252 case Instruction::REM_DOUBLE: { 2253 Binop_23x<HRem>(instruction, Primitive::kPrimDouble, dex_pc); 2254 break; 2255 } 2256 2257 case Instruction::AND_INT: { 2258 Binop_23x<HAnd>(instruction, Primitive::kPrimInt, dex_pc); 2259 break; 2260 } 2261 2262 case Instruction::AND_LONG: { 2263 Binop_23x<HAnd>(instruction, Primitive::kPrimLong, dex_pc); 2264 break; 2265 } 2266 2267 case Instruction::SHL_INT: { 2268 Binop_23x_shift<HShl>(instruction, Primitive::kPrimInt, dex_pc); 2269 break; 2270 } 2271 2272 case Instruction::SHL_LONG: { 2273 Binop_23x_shift<HShl>(instruction, Primitive::kPrimLong, dex_pc); 2274 break; 2275 } 2276 2277 case Instruction::SHR_INT: { 2278 Binop_23x_shift<HShr>(instruction, Primitive::kPrimInt, dex_pc); 2279 break; 2280 } 2281 2282 case Instruction::SHR_LONG: { 2283 Binop_23x_shift<HShr>(instruction, Primitive::kPrimLong, dex_pc); 2284 break; 2285 } 2286 2287 case Instruction::USHR_INT: { 2288 Binop_23x_shift<HUShr>(instruction, Primitive::kPrimInt, dex_pc); 2289 break; 2290 } 2291 2292 case Instruction::USHR_LONG: { 2293 Binop_23x_shift<HUShr>(instruction, Primitive::kPrimLong, dex_pc); 2294 break; 2295 } 2296 2297 case Instruction::OR_INT: { 2298 Binop_23x<HOr>(instruction, Primitive::kPrimInt, dex_pc); 2299 break; 2300 } 2301 2302 case Instruction::OR_LONG: { 2303 Binop_23x<HOr>(instruction, Primitive::kPrimLong, dex_pc); 2304 break; 2305 } 2306 2307 case Instruction::XOR_INT: { 2308 Binop_23x<HXor>(instruction, Primitive::kPrimInt, dex_pc); 2309 break; 2310 } 2311 2312 case Instruction::XOR_LONG: { 2313 Binop_23x<HXor>(instruction, Primitive::kPrimLong, dex_pc); 2314 break; 2315 } 2316 2317 case Instruction::ADD_LONG_2ADDR: { 2318 Binop_12x<HAdd>(instruction, Primitive::kPrimLong, dex_pc); 2319 break; 2320 } 2321 2322 case Instruction::ADD_DOUBLE_2ADDR: { 2323 Binop_12x<HAdd>(instruction, Primitive::kPrimDouble, dex_pc); 2324 break; 2325 } 2326 2327 case Instruction::ADD_FLOAT_2ADDR: { 2328 Binop_12x<HAdd>(instruction, Primitive::kPrimFloat, dex_pc); 2329 break; 2330 } 2331 2332 case Instruction::SUB_INT_2ADDR: { 2333 Binop_12x<HSub>(instruction, Primitive::kPrimInt, dex_pc); 2334 break; 2335 } 2336 2337 case Instruction::SUB_LONG_2ADDR: { 2338 Binop_12x<HSub>(instruction, Primitive::kPrimLong, dex_pc); 2339 break; 2340 } 2341 2342 case Instruction::SUB_FLOAT_2ADDR: { 2343 Binop_12x<HSub>(instruction, Primitive::kPrimFloat, dex_pc); 2344 break; 2345 } 2346 2347 case Instruction::SUB_DOUBLE_2ADDR: { 2348 Binop_12x<HSub>(instruction, Primitive::kPrimDouble, dex_pc); 2349 break; 2350 } 2351 2352 case Instruction::MUL_INT_2ADDR: { 2353 Binop_12x<HMul>(instruction, Primitive::kPrimInt, dex_pc); 2354 break; 2355 } 2356 2357 case Instruction::MUL_LONG_2ADDR: { 2358 Binop_12x<HMul>(instruction, Primitive::kPrimLong, dex_pc); 2359 break; 2360 } 2361 2362 case Instruction::MUL_FLOAT_2ADDR: { 2363 Binop_12x<HMul>(instruction, Primitive::kPrimFloat, dex_pc); 2364 break; 2365 } 2366 2367 case Instruction::MUL_DOUBLE_2ADDR: { 2368 Binop_12x<HMul>(instruction, Primitive::kPrimDouble, dex_pc); 2369 break; 2370 } 2371 2372 case Instruction::DIV_INT_2ADDR: { 2373 BuildCheckedDivRem(instruction.VRegA(), instruction.VRegA(), instruction.VRegB(), 2374 dex_pc, Primitive::kPrimInt, false, true); 2375 break; 2376 } 2377 2378 case Instruction::DIV_LONG_2ADDR: { 2379 BuildCheckedDivRem(instruction.VRegA(), instruction.VRegA(), instruction.VRegB(), 2380 dex_pc, Primitive::kPrimLong, false, true); 2381 break; 2382 } 2383 2384 case Instruction::REM_INT_2ADDR: { 2385 BuildCheckedDivRem(instruction.VRegA(), instruction.VRegA(), instruction.VRegB(), 2386 dex_pc, Primitive::kPrimInt, false, false); 2387 break; 2388 } 2389 2390 case Instruction::REM_LONG_2ADDR: { 2391 BuildCheckedDivRem(instruction.VRegA(), instruction.VRegA(), instruction.VRegB(), 2392 dex_pc, Primitive::kPrimLong, false, false); 2393 break; 2394 } 2395 2396 case Instruction::REM_FLOAT_2ADDR: { 2397 Binop_12x<HRem>(instruction, Primitive::kPrimFloat, dex_pc); 2398 break; 2399 } 2400 2401 case Instruction::REM_DOUBLE_2ADDR: { 2402 Binop_12x<HRem>(instruction, Primitive::kPrimDouble, dex_pc); 2403 break; 2404 } 2405 2406 case Instruction::SHL_INT_2ADDR: { 2407 Binop_12x_shift<HShl>(instruction, Primitive::kPrimInt, dex_pc); 2408 break; 2409 } 2410 2411 case Instruction::SHL_LONG_2ADDR: { 2412 Binop_12x_shift<HShl>(instruction, Primitive::kPrimLong, dex_pc); 2413 break; 2414 } 2415 2416 case Instruction::SHR_INT_2ADDR: { 2417 Binop_12x_shift<HShr>(instruction, Primitive::kPrimInt, dex_pc); 2418 break; 2419 } 2420 2421 case Instruction::SHR_LONG_2ADDR: { 2422 Binop_12x_shift<HShr>(instruction, Primitive::kPrimLong, dex_pc); 2423 break; 2424 } 2425 2426 case Instruction::USHR_INT_2ADDR: { 2427 Binop_12x_shift<HUShr>(instruction, Primitive::kPrimInt, dex_pc); 2428 break; 2429 } 2430 2431 case Instruction::USHR_LONG_2ADDR: { 2432 Binop_12x_shift<HUShr>(instruction, Primitive::kPrimLong, dex_pc); 2433 break; 2434 } 2435 2436 case Instruction::DIV_FLOAT_2ADDR: { 2437 Binop_12x<HDiv>(instruction, Primitive::kPrimFloat, dex_pc); 2438 break; 2439 } 2440 2441 case Instruction::DIV_DOUBLE_2ADDR: { 2442 Binop_12x<HDiv>(instruction, Primitive::kPrimDouble, dex_pc); 2443 break; 2444 } 2445 2446 case Instruction::AND_INT_2ADDR: { 2447 Binop_12x<HAnd>(instruction, Primitive::kPrimInt, dex_pc); 2448 break; 2449 } 2450 2451 case Instruction::AND_LONG_2ADDR: { 2452 Binop_12x<HAnd>(instruction, Primitive::kPrimLong, dex_pc); 2453 break; 2454 } 2455 2456 case Instruction::OR_INT_2ADDR: { 2457 Binop_12x<HOr>(instruction, Primitive::kPrimInt, dex_pc); 2458 break; 2459 } 2460 2461 case Instruction::OR_LONG_2ADDR: { 2462 Binop_12x<HOr>(instruction, Primitive::kPrimLong, dex_pc); 2463 break; 2464 } 2465 2466 case Instruction::XOR_INT_2ADDR: { 2467 Binop_12x<HXor>(instruction, Primitive::kPrimInt, dex_pc); 2468 break; 2469 } 2470 2471 case Instruction::XOR_LONG_2ADDR: { 2472 Binop_12x<HXor>(instruction, Primitive::kPrimLong, dex_pc); 2473 break; 2474 } 2475 2476 case Instruction::ADD_INT_LIT16: { 2477 Binop_22s<HAdd>(instruction, false, dex_pc); 2478 break; 2479 } 2480 2481 case Instruction::AND_INT_LIT16: { 2482 Binop_22s<HAnd>(instruction, false, dex_pc); 2483 break; 2484 } 2485 2486 case Instruction::OR_INT_LIT16: { 2487 Binop_22s<HOr>(instruction, false, dex_pc); 2488 break; 2489 } 2490 2491 case Instruction::XOR_INT_LIT16: { 2492 Binop_22s<HXor>(instruction, false, dex_pc); 2493 break; 2494 } 2495 2496 case Instruction::RSUB_INT: { 2497 Binop_22s<HSub>(instruction, true, dex_pc); 2498 break; 2499 } 2500 2501 case Instruction::MUL_INT_LIT16: { 2502 Binop_22s<HMul>(instruction, false, dex_pc); 2503 break; 2504 } 2505 2506 case Instruction::ADD_INT_LIT8: { 2507 Binop_22b<HAdd>(instruction, false, dex_pc); 2508 break; 2509 } 2510 2511 case Instruction::AND_INT_LIT8: { 2512 Binop_22b<HAnd>(instruction, false, dex_pc); 2513 break; 2514 } 2515 2516 case Instruction::OR_INT_LIT8: { 2517 Binop_22b<HOr>(instruction, false, dex_pc); 2518 break; 2519 } 2520 2521 case Instruction::XOR_INT_LIT8: { 2522 Binop_22b<HXor>(instruction, false, dex_pc); 2523 break; 2524 } 2525 2526 case Instruction::RSUB_INT_LIT8: { 2527 Binop_22b<HSub>(instruction, true, dex_pc); 2528 break; 2529 } 2530 2531 case Instruction::MUL_INT_LIT8: { 2532 Binop_22b<HMul>(instruction, false, dex_pc); 2533 break; 2534 } 2535 2536 case Instruction::DIV_INT_LIT16: 2537 case Instruction::DIV_INT_LIT8: { 2538 BuildCheckedDivRem(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(), 2539 dex_pc, Primitive::kPrimInt, true, true); 2540 break; 2541 } 2542 2543 case Instruction::REM_INT_LIT16: 2544 case Instruction::REM_INT_LIT8: { 2545 BuildCheckedDivRem(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(), 2546 dex_pc, Primitive::kPrimInt, true, false); 2547 break; 2548 } 2549 2550 case Instruction::SHL_INT_LIT8: { 2551 Binop_22b<HShl>(instruction, false, dex_pc); 2552 break; 2553 } 2554 2555 case Instruction::SHR_INT_LIT8: { 2556 Binop_22b<HShr>(instruction, false, dex_pc); 2557 break; 2558 } 2559 2560 case Instruction::USHR_INT_LIT8: { 2561 Binop_22b<HUShr>(instruction, false, dex_pc); 2562 break; 2563 } 2564 2565 case Instruction::NEW_INSTANCE: { 2566 uint16_t type_index = instruction.VRegB_21c(); 2567 if (compiler_driver_->IsStringTypeIndex(type_index, dex_file_)) { 2568 int32_t register_index = instruction.VRegA(); 2569 HFakeString* fake_string = new (arena_) HFakeString(dex_pc); 2570 current_block_->AddInstruction(fake_string); 2571 UpdateLocal(register_index, fake_string, dex_pc); 2572 } else { 2573 QuickEntrypointEnum entrypoint = NeedsAccessCheck(type_index) 2574 ? kQuickAllocObjectWithAccessCheck 2575 : kQuickAllocObject; 2576 2577 current_block_->AddInstruction(new (arena_) HNewInstance( 2578 graph_->GetCurrentMethod(), 2579 dex_pc, 2580 type_index, 2581 *dex_compilation_unit_->GetDexFile(), 2582 entrypoint)); 2583 UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction(), dex_pc); 2584 } 2585 break; 2586 } 2587 2588 case Instruction::NEW_ARRAY: { 2589 uint16_t type_index = instruction.VRegC_22c(); 2590 HInstruction* length = LoadLocal(instruction.VRegB_22c(), Primitive::kPrimInt, dex_pc); 2591 QuickEntrypointEnum entrypoint = NeedsAccessCheck(type_index) 2592 ? kQuickAllocArrayWithAccessCheck 2593 : kQuickAllocArray; 2594 current_block_->AddInstruction(new (arena_) HNewArray(length, 2595 graph_->GetCurrentMethod(), 2596 dex_pc, 2597 type_index, 2598 *dex_compilation_unit_->GetDexFile(), 2599 entrypoint)); 2600 UpdateLocal(instruction.VRegA_22c(), current_block_->GetLastInstruction(), dex_pc); 2601 break; 2602 } 2603 2604 case Instruction::FILLED_NEW_ARRAY: { 2605 uint32_t number_of_vreg_arguments = instruction.VRegA_35c(); 2606 uint32_t type_index = instruction.VRegB_35c(); 2607 uint32_t args[5]; 2608 instruction.GetVarArgs(args); 2609 BuildFilledNewArray(dex_pc, type_index, number_of_vreg_arguments, false, args, 0); 2610 break; 2611 } 2612 2613 case Instruction::FILLED_NEW_ARRAY_RANGE: { 2614 uint32_t number_of_vreg_arguments = instruction.VRegA_3rc(); 2615 uint32_t type_index = instruction.VRegB_3rc(); 2616 uint32_t register_index = instruction.VRegC_3rc(); 2617 BuildFilledNewArray( 2618 dex_pc, type_index, number_of_vreg_arguments, true, nullptr, register_index); 2619 break; 2620 } 2621 2622 case Instruction::FILL_ARRAY_DATA: { 2623 BuildFillArrayData(instruction, dex_pc); 2624 break; 2625 } 2626 2627 case Instruction::MOVE_RESULT: 2628 case Instruction::MOVE_RESULT_WIDE: 2629 case Instruction::MOVE_RESULT_OBJECT: { 2630 if (latest_result_ == nullptr) { 2631 // Only dead code can lead to this situation, where the verifier 2632 // does not reject the method. 2633 } else { 2634 // An Invoke/FilledNewArray and its MoveResult could have landed in 2635 // different blocks if there was a try/catch block boundary between 2636 // them. For Invoke, we insert a StoreLocal after the instruction. For 2637 // FilledNewArray, the local needs to be updated after the array was 2638 // filled, otherwise we might overwrite an input vreg. 2639 HStoreLocal* update_local = 2640 new (arena_) HStoreLocal(GetLocalAt(instruction.VRegA()), latest_result_, dex_pc); 2641 HBasicBlock* block = latest_result_->GetBlock(); 2642 if (block == current_block_) { 2643 // MoveResult and the previous instruction are in the same block. 2644 current_block_->AddInstruction(update_local); 2645 } else { 2646 // The two instructions are in different blocks. Insert the MoveResult 2647 // before the final control-flow instruction of the previous block. 2648 DCHECK(block->EndsWithControlFlowInstruction()); 2649 DCHECK(current_block_->GetInstructions().IsEmpty()); 2650 block->InsertInstructionBefore(update_local, block->GetLastInstruction()); 2651 } 2652 latest_result_ = nullptr; 2653 } 2654 break; 2655 } 2656 2657 case Instruction::CMP_LONG: { 2658 Binop_23x_cmp(instruction, Primitive::kPrimLong, ComparisonBias::kNoBias, dex_pc); 2659 break; 2660 } 2661 2662 case Instruction::CMPG_FLOAT: { 2663 Binop_23x_cmp(instruction, Primitive::kPrimFloat, ComparisonBias::kGtBias, dex_pc); 2664 break; 2665 } 2666 2667 case Instruction::CMPG_DOUBLE: { 2668 Binop_23x_cmp(instruction, Primitive::kPrimDouble, ComparisonBias::kGtBias, dex_pc); 2669 break; 2670 } 2671 2672 case Instruction::CMPL_FLOAT: { 2673 Binop_23x_cmp(instruction, Primitive::kPrimFloat, ComparisonBias::kLtBias, dex_pc); 2674 break; 2675 } 2676 2677 case Instruction::CMPL_DOUBLE: { 2678 Binop_23x_cmp(instruction, Primitive::kPrimDouble, ComparisonBias::kLtBias, dex_pc); 2679 break; 2680 } 2681 2682 case Instruction::NOP: 2683 break; 2684 2685 case Instruction::IGET: 2686 case Instruction::IGET_QUICK: 2687 case Instruction::IGET_WIDE: 2688 case Instruction::IGET_WIDE_QUICK: 2689 case Instruction::IGET_OBJECT: 2690 case Instruction::IGET_OBJECT_QUICK: 2691 case Instruction::IGET_BOOLEAN: 2692 case Instruction::IGET_BOOLEAN_QUICK: 2693 case Instruction::IGET_BYTE: 2694 case Instruction::IGET_BYTE_QUICK: 2695 case Instruction::IGET_CHAR: 2696 case Instruction::IGET_CHAR_QUICK: 2697 case Instruction::IGET_SHORT: 2698 case Instruction::IGET_SHORT_QUICK: { 2699 if (!BuildInstanceFieldAccess(instruction, dex_pc, false)) { 2700 return false; 2701 } 2702 break; 2703 } 2704 2705 case Instruction::IPUT: 2706 case Instruction::IPUT_QUICK: 2707 case Instruction::IPUT_WIDE: 2708 case Instruction::IPUT_WIDE_QUICK: 2709 case Instruction::IPUT_OBJECT: 2710 case Instruction::IPUT_OBJECT_QUICK: 2711 case Instruction::IPUT_BOOLEAN: 2712 case Instruction::IPUT_BOOLEAN_QUICK: 2713 case Instruction::IPUT_BYTE: 2714 case Instruction::IPUT_BYTE_QUICK: 2715 case Instruction::IPUT_CHAR: 2716 case Instruction::IPUT_CHAR_QUICK: 2717 case Instruction::IPUT_SHORT: 2718 case Instruction::IPUT_SHORT_QUICK: { 2719 if (!BuildInstanceFieldAccess(instruction, dex_pc, true)) { 2720 return false; 2721 } 2722 break; 2723 } 2724 2725 case Instruction::SGET: 2726 case Instruction::SGET_WIDE: 2727 case Instruction::SGET_OBJECT: 2728 case Instruction::SGET_BOOLEAN: 2729 case Instruction::SGET_BYTE: 2730 case Instruction::SGET_CHAR: 2731 case Instruction::SGET_SHORT: { 2732 if (!BuildStaticFieldAccess(instruction, dex_pc, false)) { 2733 return false; 2734 } 2735 break; 2736 } 2737 2738 case Instruction::SPUT: 2739 case Instruction::SPUT_WIDE: 2740 case Instruction::SPUT_OBJECT: 2741 case Instruction::SPUT_BOOLEAN: 2742 case Instruction::SPUT_BYTE: 2743 case Instruction::SPUT_CHAR: 2744 case Instruction::SPUT_SHORT: { 2745 if (!BuildStaticFieldAccess(instruction, dex_pc, true)) { 2746 return false; 2747 } 2748 break; 2749 } 2750 2751#define ARRAY_XX(kind, anticipated_type) \ 2752 case Instruction::AGET##kind: { \ 2753 BuildArrayAccess(instruction, dex_pc, false, anticipated_type); \ 2754 break; \ 2755 } \ 2756 case Instruction::APUT##kind: { \ 2757 BuildArrayAccess(instruction, dex_pc, true, anticipated_type); \ 2758 break; \ 2759 } 2760 2761 ARRAY_XX(, Primitive::kPrimInt); 2762 ARRAY_XX(_WIDE, Primitive::kPrimLong); 2763 ARRAY_XX(_OBJECT, Primitive::kPrimNot); 2764 ARRAY_XX(_BOOLEAN, Primitive::kPrimBoolean); 2765 ARRAY_XX(_BYTE, Primitive::kPrimByte); 2766 ARRAY_XX(_CHAR, Primitive::kPrimChar); 2767 ARRAY_XX(_SHORT, Primitive::kPrimShort); 2768 2769 case Instruction::ARRAY_LENGTH: { 2770 HInstruction* object = LoadLocal(instruction.VRegB_12x(), Primitive::kPrimNot, dex_pc); 2771 // No need for a temporary for the null check, it is the only input of the following 2772 // instruction. 2773 object = new (arena_) HNullCheck(object, dex_pc); 2774 current_block_->AddInstruction(object); 2775 current_block_->AddInstruction(new (arena_) HArrayLength(object, dex_pc)); 2776 UpdateLocal(instruction.VRegA_12x(), current_block_->GetLastInstruction(), dex_pc); 2777 break; 2778 } 2779 2780 case Instruction::CONST_STRING: { 2781 current_block_->AddInstruction( 2782 new (arena_) HLoadString(graph_->GetCurrentMethod(), instruction.VRegB_21c(), dex_pc)); 2783 UpdateLocal(instruction.VRegA_21c(), current_block_->GetLastInstruction(), dex_pc); 2784 break; 2785 } 2786 2787 case Instruction::CONST_STRING_JUMBO: { 2788 current_block_->AddInstruction( 2789 new (arena_) HLoadString(graph_->GetCurrentMethod(), instruction.VRegB_31c(), dex_pc)); 2790 UpdateLocal(instruction.VRegA_31c(), current_block_->GetLastInstruction(), dex_pc); 2791 break; 2792 } 2793 2794 case Instruction::CONST_CLASS: { 2795 uint16_t type_index = instruction.VRegB_21c(); 2796 bool type_known_final; 2797 bool type_known_abstract; 2798 bool dont_use_is_referrers_class; 2799 // `CanAccessTypeWithoutChecks` will tell whether the method being 2800 // built is trying to access its own class, so that the generated 2801 // code can optimize for this case. However, the optimization does not 2802 // work for inlining, so we use `IsOutermostCompilingClass` instead. 2803 bool can_access = compiler_driver_->CanAccessTypeWithoutChecks( 2804 dex_compilation_unit_->GetDexMethodIndex(), *dex_file_, type_index, 2805 &type_known_final, &type_known_abstract, &dont_use_is_referrers_class); 2806 current_block_->AddInstruction(new (arena_) HLoadClass( 2807 graph_->GetCurrentMethod(), 2808 type_index, 2809 *dex_compilation_unit_->GetDexFile(), 2810 IsOutermostCompilingClass(type_index), 2811 dex_pc, 2812 !can_access)); 2813 UpdateLocal(instruction.VRegA_21c(), current_block_->GetLastInstruction(), dex_pc); 2814 break; 2815 } 2816 2817 case Instruction::MOVE_EXCEPTION: { 2818 current_block_->AddInstruction(new (arena_) HLoadException(dex_pc)); 2819 UpdateLocal(instruction.VRegA_11x(), current_block_->GetLastInstruction(), dex_pc); 2820 current_block_->AddInstruction(new (arena_) HClearException(dex_pc)); 2821 break; 2822 } 2823 2824 case Instruction::THROW: { 2825 HInstruction* exception = LoadLocal(instruction.VRegA_11x(), Primitive::kPrimNot, dex_pc); 2826 current_block_->AddInstruction(new (arena_) HThrow(exception, dex_pc)); 2827 // A throw instruction must branch to the exit block. 2828 current_block_->AddSuccessor(exit_block_); 2829 // We finished building this block. Set the current block to null to avoid 2830 // adding dead instructions to it. 2831 current_block_ = nullptr; 2832 break; 2833 } 2834 2835 case Instruction::INSTANCE_OF: { 2836 uint8_t destination = instruction.VRegA_22c(); 2837 uint8_t reference = instruction.VRegB_22c(); 2838 uint16_t type_index = instruction.VRegC_22c(); 2839 BuildTypeCheck(instruction, destination, reference, type_index, dex_pc); 2840 break; 2841 } 2842 2843 case Instruction::CHECK_CAST: { 2844 uint8_t reference = instruction.VRegA_21c(); 2845 uint16_t type_index = instruction.VRegB_21c(); 2846 BuildTypeCheck(instruction, -1, reference, type_index, dex_pc); 2847 break; 2848 } 2849 2850 case Instruction::MONITOR_ENTER: { 2851 current_block_->AddInstruction(new (arena_) HMonitorOperation( 2852 LoadLocal(instruction.VRegA_11x(), Primitive::kPrimNot, dex_pc), 2853 HMonitorOperation::kEnter, 2854 dex_pc)); 2855 break; 2856 } 2857 2858 case Instruction::MONITOR_EXIT: { 2859 current_block_->AddInstruction(new (arena_) HMonitorOperation( 2860 LoadLocal(instruction.VRegA_11x(), Primitive::kPrimNot, dex_pc), 2861 HMonitorOperation::kExit, 2862 dex_pc)); 2863 break; 2864 } 2865 2866 case Instruction::PACKED_SWITCH: { 2867 BuildPackedSwitch(instruction, dex_pc); 2868 break; 2869 } 2870 2871 case Instruction::SPARSE_SWITCH: { 2872 BuildSparseSwitch(instruction, dex_pc); 2873 break; 2874 } 2875 2876 default: 2877 VLOG(compiler) << "Did not compile " 2878 << PrettyMethod(dex_compilation_unit_->GetDexMethodIndex(), *dex_file_) 2879 << " because of unhandled instruction " 2880 << instruction.Name(); 2881 MaybeRecordStat(MethodCompilationStat::kNotCompiledUnhandledInstruction); 2882 return false; 2883 } 2884 return true; 2885} // NOLINT(readability/fn_size) 2886 2887HLocal* HGraphBuilder::GetLocalAt(uint32_t register_index) const { 2888 return locals_[register_index]; 2889} 2890 2891void HGraphBuilder::UpdateLocal(uint32_t register_index, 2892 HInstruction* instruction, 2893 uint32_t dex_pc) const { 2894 HLocal* local = GetLocalAt(register_index); 2895 current_block_->AddInstruction(new (arena_) HStoreLocal(local, instruction, dex_pc)); 2896} 2897 2898HInstruction* HGraphBuilder::LoadLocal(uint32_t register_index, 2899 Primitive::Type type, 2900 uint32_t dex_pc) const { 2901 HLocal* local = GetLocalAt(register_index); 2902 current_block_->AddInstruction(new (arena_) HLoadLocal(local, type, dex_pc)); 2903 return current_block_->GetLastInstruction(); 2904} 2905 2906} // namespace art 2907