1 /* 2 * 3 * Copyright (C) 2014 The Android Open Source Project 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 #include "builder.h" 19 20 #include "class_linker.h" 21 #include "dex_file.h" 22 #include "dex_file-inl.h" 23 #include "dex_instruction.h" 24 #include "dex_instruction-inl.h" 25 #include "driver/compiler_driver-inl.h" 26 #include "mirror/art_field.h" 27 #include "mirror/art_field-inl.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 35 namespace art { 36 37 /** 38 * Helper class to add HTemporary instructions. This class is used when 39 * converting a DEX instruction to multiple HInstruction, and where those 40 * instructions do not die at the following instruction, but instead spans 41 * multiple instructions. 42 */ 43 class Temporaries : public ValueObject { 44 public: 45 Temporaries(HGraph* graph, size_t count) : graph_(graph), count_(count), index_(0) { 46 graph_->UpdateNumberOfTemporaries(count_); 47 } 48 49 void Add(HInstruction* instruction) { 50 // We currently only support vreg size temps. 51 DCHECK(instruction->GetType() != Primitive::kPrimLong 52 && instruction->GetType() != Primitive::kPrimDouble); 53 HInstruction* temp = new (graph_->GetArena()) HTemporary(index_++); 54 instruction->GetBlock()->AddInstruction(temp); 55 DCHECK(temp->GetPrevious() == instruction); 56 } 57 58 private: 59 HGraph* const graph_; 60 61 // The total number of temporaries that will be used. 62 const size_t count_; 63 64 // Current index in the temporary stack, updated by `Add`. 65 size_t index_; 66 }; 67 68 static bool IsTypeSupported(Primitive::Type type) { 69 return type != Primitive::kPrimFloat && type != Primitive::kPrimDouble; 70 } 71 72 void HGraphBuilder::InitializeLocals(uint16_t count) { 73 graph_->SetNumberOfVRegs(count); 74 locals_.SetSize(count); 75 for (int i = 0; i < count; i++) { 76 HLocal* local = new (arena_) HLocal(i); 77 entry_block_->AddInstruction(local); 78 locals_.Put(i, local); 79 } 80 } 81 82 bool HGraphBuilder::InitializeParameters(uint16_t number_of_parameters) { 83 // dex_compilation_unit_ is null only when unit testing. 84 if (dex_compilation_unit_ == nullptr) { 85 return true; 86 } 87 88 graph_->SetNumberOfInVRegs(number_of_parameters); 89 const char* shorty = dex_compilation_unit_->GetShorty(); 90 int locals_index = locals_.Size() - number_of_parameters; 91 int parameter_index = 0; 92 93 if (!dex_compilation_unit_->IsStatic()) { 94 // Add the implicit 'this' argument, not expressed in the signature. 95 HParameterValue* parameter = 96 new (arena_) HParameterValue(parameter_index++, Primitive::kPrimNot); 97 entry_block_->AddInstruction(parameter); 98 HLocal* local = GetLocalAt(locals_index++); 99 entry_block_->AddInstruction(new (arena_) HStoreLocal(local, parameter)); 100 number_of_parameters--; 101 } 102 103 uint32_t pos = 1; 104 for (int i = 0; i < number_of_parameters; i++) { 105 switch (shorty[pos++]) { 106 case 'F': 107 case 'D': { 108 return false; 109 } 110 111 default: { 112 // integer and reference parameters. 113 HParameterValue* parameter = 114 new (arena_) HParameterValue(parameter_index++, Primitive::GetType(shorty[pos - 1])); 115 entry_block_->AddInstruction(parameter); 116 HLocal* local = GetLocalAt(locals_index++); 117 // Store the parameter value in the local that the dex code will use 118 // to reference that parameter. 119 entry_block_->AddInstruction(new (arena_) HStoreLocal(local, parameter)); 120 if (parameter->GetType() == Primitive::kPrimLong) { 121 i++; 122 locals_index++; 123 parameter_index++; 124 } 125 break; 126 } 127 } 128 } 129 return true; 130 } 131 132 static bool CanHandleCodeItem(const DexFile::CodeItem& code_item) { 133 if (code_item.tries_size_ > 0) { 134 return false; 135 } 136 return true; 137 } 138 139 template<typename T> 140 void HGraphBuilder::If_22t(const Instruction& instruction, uint32_t dex_offset) { 141 HInstruction* first = LoadLocal(instruction.VRegA(), Primitive::kPrimInt); 142 HInstruction* second = LoadLocal(instruction.VRegB(), Primitive::kPrimInt); 143 T* comparison = new (arena_) T(first, second); 144 current_block_->AddInstruction(comparison); 145 HInstruction* ifinst = new (arena_) HIf(comparison); 146 current_block_->AddInstruction(ifinst); 147 HBasicBlock* target = FindBlockStartingAt(dex_offset + instruction.GetTargetOffset()); 148 DCHECK(target != nullptr); 149 current_block_->AddSuccessor(target); 150 target = FindBlockStartingAt(dex_offset + instruction.SizeInCodeUnits()); 151 DCHECK(target != nullptr); 152 current_block_->AddSuccessor(target); 153 current_block_ = nullptr; 154 } 155 156 template<typename T> 157 void HGraphBuilder::If_21t(const Instruction& instruction, uint32_t dex_offset) { 158 HInstruction* value = LoadLocal(instruction.VRegA(), Primitive::kPrimInt); 159 T* comparison = new (arena_) T(value, GetIntConstant(0)); 160 current_block_->AddInstruction(comparison); 161 HInstruction* ifinst = new (arena_) HIf(comparison); 162 current_block_->AddInstruction(ifinst); 163 HBasicBlock* target = FindBlockStartingAt(dex_offset + instruction.GetTargetOffset()); 164 DCHECK(target != nullptr); 165 current_block_->AddSuccessor(target); 166 target = FindBlockStartingAt(dex_offset + instruction.SizeInCodeUnits()); 167 DCHECK(target != nullptr); 168 current_block_->AddSuccessor(target); 169 current_block_ = nullptr; 170 } 171 172 HGraph* HGraphBuilder::BuildGraph(const DexFile::CodeItem& code_item) { 173 if (!CanHandleCodeItem(code_item)) { 174 return nullptr; 175 } 176 177 const uint16_t* code_ptr = code_item.insns_; 178 const uint16_t* code_end = code_item.insns_ + code_item.insns_size_in_code_units_; 179 180 // Setup the graph with the entry block and exit block. 181 graph_ = new (arena_) HGraph(arena_); 182 entry_block_ = new (arena_) HBasicBlock(graph_); 183 graph_->AddBlock(entry_block_); 184 exit_block_ = new (arena_) HBasicBlock(graph_); 185 graph_->SetEntryBlock(entry_block_); 186 graph_->SetExitBlock(exit_block_); 187 188 InitializeLocals(code_item.registers_size_); 189 graph_->UpdateMaximumNumberOfOutVRegs(code_item.outs_size_); 190 191 // To avoid splitting blocks, we compute ahead of time the instructions that 192 // start a new block, and create these blocks. 193 ComputeBranchTargets(code_ptr, code_end); 194 195 if (!InitializeParameters(code_item.ins_size_)) { 196 return nullptr; 197 } 198 199 size_t dex_offset = 0; 200 while (code_ptr < code_end) { 201 // Update the current block if dex_offset starts a new block. 202 MaybeUpdateCurrentBlock(dex_offset); 203 const Instruction& instruction = *Instruction::At(code_ptr); 204 if (!AnalyzeDexInstruction(instruction, dex_offset)) return nullptr; 205 dex_offset += instruction.SizeInCodeUnits(); 206 code_ptr += instruction.SizeInCodeUnits(); 207 } 208 209 // Add the exit block at the end to give it the highest id. 210 graph_->AddBlock(exit_block_); 211 exit_block_->AddInstruction(new (arena_) HExit()); 212 entry_block_->AddInstruction(new (arena_) HGoto()); 213 return graph_; 214 } 215 216 void HGraphBuilder::MaybeUpdateCurrentBlock(size_t index) { 217 HBasicBlock* block = FindBlockStartingAt(index); 218 if (block == nullptr) { 219 return; 220 } 221 222 if (current_block_ != nullptr) { 223 // Branching instructions clear current_block, so we know 224 // the last instruction of the current block is not a branching 225 // instruction. We add an unconditional goto to the found block. 226 current_block_->AddInstruction(new (arena_) HGoto()); 227 current_block_->AddSuccessor(block); 228 } 229 graph_->AddBlock(block); 230 current_block_ = block; 231 } 232 233 void HGraphBuilder::ComputeBranchTargets(const uint16_t* code_ptr, const uint16_t* code_end) { 234 // TODO: Support switch instructions. 235 branch_targets_.SetSize(code_end - code_ptr); 236 237 // Create the first block for the dex instructions, single successor of the entry block. 238 HBasicBlock* block = new (arena_) HBasicBlock(graph_); 239 branch_targets_.Put(0, block); 240 entry_block_->AddSuccessor(block); 241 242 // Iterate over all instructions and find branching instructions. Create blocks for 243 // the locations these instructions branch to. 244 size_t dex_offset = 0; 245 while (code_ptr < code_end) { 246 const Instruction& instruction = *Instruction::At(code_ptr); 247 if (instruction.IsBranch()) { 248 int32_t target = instruction.GetTargetOffset() + dex_offset; 249 // Create a block for the target instruction. 250 if (FindBlockStartingAt(target) == nullptr) { 251 block = new (arena_) HBasicBlock(graph_); 252 branch_targets_.Put(target, block); 253 } 254 dex_offset += instruction.SizeInCodeUnits(); 255 code_ptr += instruction.SizeInCodeUnits(); 256 if ((code_ptr < code_end) && (FindBlockStartingAt(dex_offset) == nullptr)) { 257 block = new (arena_) HBasicBlock(graph_); 258 branch_targets_.Put(dex_offset, block); 259 } 260 } else { 261 code_ptr += instruction.SizeInCodeUnits(); 262 dex_offset += instruction.SizeInCodeUnits(); 263 } 264 } 265 } 266 267 HBasicBlock* HGraphBuilder::FindBlockStartingAt(int32_t index) const { 268 DCHECK_GE(index, 0); 269 return branch_targets_.Get(index); 270 } 271 272 template<typename T> 273 void HGraphBuilder::Binop_23x(const Instruction& instruction, Primitive::Type type) { 274 HInstruction* first = LoadLocal(instruction.VRegB(), type); 275 HInstruction* second = LoadLocal(instruction.VRegC(), type); 276 current_block_->AddInstruction(new (arena_) T(type, first, second)); 277 UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction()); 278 } 279 280 template<typename T> 281 void HGraphBuilder::Binop_12x(const Instruction& instruction, Primitive::Type type) { 282 HInstruction* first = LoadLocal(instruction.VRegA(), type); 283 HInstruction* second = LoadLocal(instruction.VRegB(), type); 284 current_block_->AddInstruction(new (arena_) T(type, first, second)); 285 UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction()); 286 } 287 288 template<typename T> 289 void HGraphBuilder::Binop_22s(const Instruction& instruction, bool reverse) { 290 HInstruction* first = LoadLocal(instruction.VRegB(), Primitive::kPrimInt); 291 HInstruction* second = GetIntConstant(instruction.VRegC_22s()); 292 if (reverse) { 293 std::swap(first, second); 294 } 295 current_block_->AddInstruction(new (arena_) T(Primitive::kPrimInt, first, second)); 296 UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction()); 297 } 298 299 template<typename T> 300 void HGraphBuilder::Binop_22b(const Instruction& instruction, bool reverse) { 301 HInstruction* first = LoadLocal(instruction.VRegB(), Primitive::kPrimInt); 302 HInstruction* second = GetIntConstant(instruction.VRegC_22b()); 303 if (reverse) { 304 std::swap(first, second); 305 } 306 current_block_->AddInstruction(new (arena_) T(Primitive::kPrimInt, first, second)); 307 UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction()); 308 } 309 310 void HGraphBuilder::BuildReturn(const Instruction& instruction, Primitive::Type type) { 311 if (type == Primitive::kPrimVoid) { 312 current_block_->AddInstruction(new (arena_) HReturnVoid()); 313 } else { 314 HInstruction* value = LoadLocal(instruction.VRegA(), type); 315 current_block_->AddInstruction(new (arena_) HReturn(value)); 316 } 317 current_block_->AddSuccessor(exit_block_); 318 current_block_ = nullptr; 319 } 320 321 bool HGraphBuilder::BuildInvoke(const Instruction& instruction, 322 uint32_t dex_offset, 323 uint32_t method_idx, 324 uint32_t number_of_vreg_arguments, 325 bool is_range, 326 uint32_t* args, 327 uint32_t register_index) { 328 const DexFile::MethodId& method_id = dex_file_->GetMethodId(method_idx); 329 const DexFile::ProtoId& proto_id = dex_file_->GetProtoId(method_id.proto_idx_); 330 const char* descriptor = dex_file_->StringDataByIdx(proto_id.shorty_idx_); 331 Primitive::Type return_type = Primitive::GetType(descriptor[0]); 332 bool is_instance_call = 333 instruction.Opcode() != Instruction::INVOKE_STATIC 334 && instruction.Opcode() != Instruction::INVOKE_STATIC_RANGE; 335 const size_t number_of_arguments = strlen(descriptor) - (is_instance_call ? 0 : 1); 336 337 // Treat invoke-direct like static calls for now. 338 HInvoke* invoke = new (arena_) HInvokeStatic( 339 arena_, number_of_arguments, return_type, dex_offset, method_idx); 340 341 size_t start_index = 0; 342 Temporaries temps(graph_, is_instance_call ? 1 : 0); 343 if (is_instance_call) { 344 HInstruction* arg = LoadLocal(is_range ? register_index : args[0], Primitive::kPrimNot); 345 HNullCheck* null_check = new (arena_) HNullCheck(arg, dex_offset); 346 current_block_->AddInstruction(null_check); 347 temps.Add(null_check); 348 invoke->SetArgumentAt(0, null_check); 349 start_index = 1; 350 } 351 352 uint32_t descriptor_index = 1; 353 uint32_t argument_index = start_index; 354 for (size_t i = start_index; i < number_of_vreg_arguments; i++, argument_index++) { 355 Primitive::Type type = Primitive::GetType(descriptor[descriptor_index++]); 356 if (!IsTypeSupported(type)) { 357 return false; 358 } 359 if (!is_range && type == Primitive::kPrimLong && args[i] + 1 != args[i + 1]) { 360 LOG(WARNING) << "Non sequential register pair in " << dex_compilation_unit_->GetSymbol() 361 << " at " << dex_offset; 362 // We do not implement non sequential register pair. 363 return false; 364 } 365 HInstruction* arg = LoadLocal(is_range ? register_index + i : args[i], type); 366 invoke->SetArgumentAt(argument_index, arg); 367 if (type == Primitive::kPrimLong) { 368 i++; 369 } 370 } 371 372 if (!IsTypeSupported(return_type)) { 373 return false; 374 } 375 376 DCHECK_EQ(argument_index, number_of_arguments); 377 current_block_->AddInstruction(invoke); 378 return true; 379 } 380 381 bool HGraphBuilder::BuildFieldAccess(const Instruction& instruction, 382 uint32_t dex_offset, 383 bool is_put) { 384 uint32_t source_or_dest_reg = instruction.VRegA_22c(); 385 uint32_t obj_reg = instruction.VRegB_22c(); 386 uint16_t field_index = instruction.VRegC_22c(); 387 388 ScopedObjectAccess soa(Thread::Current()); 389 StackHandleScope<1> hs(soa.Self()); 390 Handle<mirror::ArtField> resolved_field(hs.NewHandle( 391 compiler_driver_->ComputeInstanceFieldInfo(field_index, dex_compilation_unit_, is_put, soa))); 392 393 if (resolved_field.Get() == nullptr) { 394 return false; 395 } 396 if (resolved_field->IsVolatile()) { 397 return false; 398 } 399 400 Primitive::Type field_type = resolved_field->GetTypeAsPrimitiveType(); 401 if (!IsTypeSupported(field_type)) { 402 return false; 403 } 404 405 HInstruction* object = LoadLocal(obj_reg, Primitive::kPrimNot); 406 current_block_->AddInstruction(new (arena_) HNullCheck(object, dex_offset)); 407 if (is_put) { 408 Temporaries temps(graph_, 1); 409 HInstruction* null_check = current_block_->GetLastInstruction(); 410 // We need one temporary for the null check. 411 temps.Add(null_check); 412 HInstruction* value = LoadLocal(source_or_dest_reg, field_type); 413 current_block_->AddInstruction(new (arena_) HInstanceFieldSet( 414 null_check, 415 value, 416 resolved_field->GetOffset())); 417 } else { 418 current_block_->AddInstruction(new (arena_) HInstanceFieldGet( 419 current_block_->GetLastInstruction(), 420 field_type, 421 resolved_field->GetOffset())); 422 423 UpdateLocal(source_or_dest_reg, current_block_->GetLastInstruction()); 424 } 425 return true; 426 } 427 428 void HGraphBuilder::BuildArrayAccess(const Instruction& instruction, 429 uint32_t dex_offset, 430 bool is_put, 431 Primitive::Type anticipated_type) { 432 uint8_t source_or_dest_reg = instruction.VRegA_23x(); 433 uint8_t array_reg = instruction.VRegB_23x(); 434 uint8_t index_reg = instruction.VRegC_23x(); 435 436 DCHECK(IsTypeSupported(anticipated_type)); 437 438 // We need one temporary for the null check, one for the index, and one for the length. 439 Temporaries temps(graph_, 3); 440 441 HInstruction* object = LoadLocal(array_reg, Primitive::kPrimNot); 442 object = new (arena_) HNullCheck(object, dex_offset); 443 current_block_->AddInstruction(object); 444 temps.Add(object); 445 446 HInstruction* length = new (arena_) HArrayLength(object); 447 current_block_->AddInstruction(length); 448 temps.Add(length); 449 HInstruction* index = LoadLocal(index_reg, Primitive::kPrimInt); 450 index = new (arena_) HBoundsCheck(index, length, dex_offset); 451 current_block_->AddInstruction(index); 452 temps.Add(index); 453 if (is_put) { 454 HInstruction* value = LoadLocal(source_or_dest_reg, anticipated_type); 455 // TODO: Insert a type check node if the type is Object. 456 current_block_->AddInstruction(new (arena_) HArraySet(object, index, value, dex_offset)); 457 } else { 458 current_block_->AddInstruction(new (arena_) HArrayGet(object, index, anticipated_type)); 459 UpdateLocal(source_or_dest_reg, current_block_->GetLastInstruction()); 460 } 461 } 462 463 bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, int32_t dex_offset) { 464 if (current_block_ == nullptr) { 465 return true; // Dead code 466 } 467 468 switch (instruction.Opcode()) { 469 case Instruction::CONST_4: { 470 int32_t register_index = instruction.VRegA(); 471 HIntConstant* constant = GetIntConstant(instruction.VRegB_11n()); 472 UpdateLocal(register_index, constant); 473 break; 474 } 475 476 case Instruction::CONST_16: { 477 int32_t register_index = instruction.VRegA(); 478 HIntConstant* constant = GetIntConstant(instruction.VRegB_21s()); 479 UpdateLocal(register_index, constant); 480 break; 481 } 482 483 case Instruction::CONST: { 484 int32_t register_index = instruction.VRegA(); 485 HIntConstant* constant = GetIntConstant(instruction.VRegB_31i()); 486 UpdateLocal(register_index, constant); 487 break; 488 } 489 490 case Instruction::CONST_HIGH16: { 491 int32_t register_index = instruction.VRegA(); 492 HIntConstant* constant = GetIntConstant(instruction.VRegB_21h() << 16); 493 UpdateLocal(register_index, constant); 494 break; 495 } 496 497 case Instruction::CONST_WIDE_16: { 498 int32_t register_index = instruction.VRegA(); 499 // Get 16 bits of constant value, sign extended to 64 bits. 500 int64_t value = instruction.VRegB_21s(); 501 value <<= 48; 502 value >>= 48; 503 HLongConstant* constant = GetLongConstant(value); 504 UpdateLocal(register_index, constant); 505 break; 506 } 507 508 case Instruction::CONST_WIDE_32: { 509 int32_t register_index = instruction.VRegA(); 510 // Get 32 bits of constant value, sign extended to 64 bits. 511 int64_t value = instruction.VRegB_31i(); 512 value <<= 32; 513 value >>= 32; 514 HLongConstant* constant = GetLongConstant(value); 515 UpdateLocal(register_index, constant); 516 break; 517 } 518 519 case Instruction::CONST_WIDE: { 520 int32_t register_index = instruction.VRegA(); 521 HLongConstant* constant = GetLongConstant(instruction.VRegB_51l()); 522 UpdateLocal(register_index, constant); 523 break; 524 } 525 526 case Instruction::CONST_WIDE_HIGH16: { 527 int32_t register_index = instruction.VRegA(); 528 int64_t value = static_cast<int64_t>(instruction.VRegB_21h()) << 48; 529 HLongConstant* constant = GetLongConstant(value); 530 UpdateLocal(register_index, constant); 531 break; 532 } 533 534 // TODO: these instructions are also used to move floating point values, so what is 535 // the type (int or float)? 536 case Instruction::MOVE: 537 case Instruction::MOVE_FROM16: 538 case Instruction::MOVE_16: { 539 HInstruction* value = LoadLocal(instruction.VRegB(), Primitive::kPrimInt); 540 UpdateLocal(instruction.VRegA(), value); 541 break; 542 } 543 544 // TODO: these instructions are also used to move floating point values, so what is 545 // the type (long or double)? 546 case Instruction::MOVE_WIDE: 547 case Instruction::MOVE_WIDE_FROM16: 548 case Instruction::MOVE_WIDE_16: { 549 HInstruction* value = LoadLocal(instruction.VRegB(), Primitive::kPrimLong); 550 UpdateLocal(instruction.VRegA(), value); 551 break; 552 } 553 554 case Instruction::MOVE_OBJECT: 555 case Instruction::MOVE_OBJECT_16: 556 case Instruction::MOVE_OBJECT_FROM16: { 557 HInstruction* value = LoadLocal(instruction.VRegB(), Primitive::kPrimNot); 558 UpdateLocal(instruction.VRegA(), value); 559 break; 560 } 561 562 case Instruction::RETURN_VOID: { 563 BuildReturn(instruction, Primitive::kPrimVoid); 564 break; 565 } 566 567 #define IF_XX(comparison, cond) \ 568 case Instruction::IF_##cond: If_22t<comparison>(instruction, dex_offset); break; \ 569 case Instruction::IF_##cond##Z: If_21t<comparison>(instruction, dex_offset); break 570 571 IF_XX(HEqual, EQ); 572 IF_XX(HNotEqual, NE); 573 IF_XX(HLessThan, LT); 574 IF_XX(HLessThanOrEqual, LE); 575 IF_XX(HGreaterThan, GT); 576 IF_XX(HGreaterThanOrEqual, GE); 577 578 case Instruction::GOTO: 579 case Instruction::GOTO_16: 580 case Instruction::GOTO_32: { 581 HBasicBlock* target = FindBlockStartingAt(instruction.GetTargetOffset() + dex_offset); 582 DCHECK(target != nullptr); 583 current_block_->AddInstruction(new (arena_) HGoto()); 584 current_block_->AddSuccessor(target); 585 current_block_ = nullptr; 586 break; 587 } 588 589 case Instruction::RETURN: { 590 BuildReturn(instruction, Primitive::kPrimInt); 591 break; 592 } 593 594 case Instruction::RETURN_OBJECT: { 595 BuildReturn(instruction, Primitive::kPrimNot); 596 break; 597 } 598 599 case Instruction::RETURN_WIDE: { 600 BuildReturn(instruction, Primitive::kPrimLong); 601 break; 602 } 603 604 case Instruction::INVOKE_STATIC: 605 case Instruction::INVOKE_DIRECT: { 606 uint32_t method_idx = instruction.VRegB_35c(); 607 uint32_t number_of_vreg_arguments = instruction.VRegA_35c(); 608 uint32_t args[5]; 609 instruction.GetVarArgs(args); 610 if (!BuildInvoke(instruction, dex_offset, method_idx, number_of_vreg_arguments, false, args, -1)) { 611 return false; 612 } 613 break; 614 } 615 616 case Instruction::INVOKE_STATIC_RANGE: 617 case Instruction::INVOKE_DIRECT_RANGE: { 618 uint32_t method_idx = instruction.VRegB_3rc(); 619 uint32_t number_of_vreg_arguments = instruction.VRegA_3rc(); 620 uint32_t register_index = instruction.VRegC(); 621 if (!BuildInvoke(instruction, dex_offset, method_idx, 622 number_of_vreg_arguments, true, nullptr, register_index)) { 623 return false; 624 } 625 break; 626 } 627 628 case Instruction::ADD_INT: { 629 Binop_23x<HAdd>(instruction, Primitive::kPrimInt); 630 break; 631 } 632 633 case Instruction::ADD_LONG: { 634 Binop_23x<HAdd>(instruction, Primitive::kPrimLong); 635 break; 636 } 637 638 case Instruction::SUB_INT: { 639 Binop_23x<HSub>(instruction, Primitive::kPrimInt); 640 break; 641 } 642 643 case Instruction::SUB_LONG: { 644 Binop_23x<HSub>(instruction, Primitive::kPrimLong); 645 break; 646 } 647 648 case Instruction::ADD_INT_2ADDR: { 649 Binop_12x<HAdd>(instruction, Primitive::kPrimInt); 650 break; 651 } 652 653 case Instruction::ADD_LONG_2ADDR: { 654 Binop_12x<HAdd>(instruction, Primitive::kPrimLong); 655 break; 656 } 657 658 case Instruction::SUB_INT_2ADDR: { 659 Binop_12x<HSub>(instruction, Primitive::kPrimInt); 660 break; 661 } 662 663 case Instruction::SUB_LONG_2ADDR: { 664 Binop_12x<HSub>(instruction, Primitive::kPrimLong); 665 break; 666 } 667 668 case Instruction::ADD_INT_LIT16: { 669 Binop_22s<HAdd>(instruction, false); 670 break; 671 } 672 673 case Instruction::RSUB_INT: { 674 Binop_22s<HSub>(instruction, true); 675 break; 676 } 677 678 case Instruction::ADD_INT_LIT8: { 679 Binop_22b<HAdd>(instruction, false); 680 break; 681 } 682 683 case Instruction::RSUB_INT_LIT8: { 684 Binop_22b<HSub>(instruction, true); 685 break; 686 } 687 688 case Instruction::NEW_INSTANCE: { 689 current_block_->AddInstruction( 690 new (arena_) HNewInstance(dex_offset, instruction.VRegB_21c())); 691 UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction()); 692 break; 693 } 694 695 case Instruction::MOVE_RESULT: 696 case Instruction::MOVE_RESULT_WIDE: 697 case Instruction::MOVE_RESULT_OBJECT: 698 UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction()); 699 break; 700 701 case Instruction::CMP_LONG: { 702 Binop_23x<HCompare>(instruction, Primitive::kPrimLong); 703 break; 704 } 705 706 case Instruction::NOP: 707 break; 708 709 case Instruction::IGET: 710 case Instruction::IGET_WIDE: 711 case Instruction::IGET_OBJECT: 712 case Instruction::IGET_BOOLEAN: 713 case Instruction::IGET_BYTE: 714 case Instruction::IGET_CHAR: 715 case Instruction::IGET_SHORT: { 716 if (!BuildFieldAccess(instruction, dex_offset, false)) { 717 return false; 718 } 719 break; 720 } 721 722 case Instruction::IPUT: 723 case Instruction::IPUT_WIDE: 724 case Instruction::IPUT_OBJECT: 725 case Instruction::IPUT_BOOLEAN: 726 case Instruction::IPUT_BYTE: 727 case Instruction::IPUT_CHAR: 728 case Instruction::IPUT_SHORT: { 729 if (!BuildFieldAccess(instruction, dex_offset, true)) { 730 return false; 731 } 732 break; 733 } 734 735 #define ARRAY_XX(kind, anticipated_type) \ 736 case Instruction::AGET##kind: { \ 737 BuildArrayAccess(instruction, dex_offset, false, anticipated_type); \ 738 break; \ 739 } \ 740 case Instruction::APUT##kind: { \ 741 BuildArrayAccess(instruction, dex_offset, true, anticipated_type); \ 742 break; \ 743 } 744 745 ARRAY_XX(, Primitive::kPrimInt); 746 ARRAY_XX(_WIDE, Primitive::kPrimLong); 747 ARRAY_XX(_OBJECT, Primitive::kPrimNot); 748 ARRAY_XX(_BOOLEAN, Primitive::kPrimBoolean); 749 ARRAY_XX(_BYTE, Primitive::kPrimByte); 750 ARRAY_XX(_CHAR, Primitive::kPrimChar); 751 ARRAY_XX(_SHORT, Primitive::kPrimShort); 752 753 default: 754 return false; 755 } 756 return true; 757 } 758 759 HIntConstant* HGraphBuilder::GetIntConstant0() { 760 if (constant0_ != nullptr) { 761 return constant0_; 762 } 763 constant0_ = new(arena_) HIntConstant(0); 764 entry_block_->AddInstruction(constant0_); 765 return constant0_; 766 } 767 768 HIntConstant* HGraphBuilder::GetIntConstant1() { 769 if (constant1_ != nullptr) { 770 return constant1_; 771 } 772 constant1_ = new(arena_) HIntConstant(1); 773 entry_block_->AddInstruction(constant1_); 774 return constant1_; 775 } 776 777 HIntConstant* HGraphBuilder::GetIntConstant(int32_t constant) { 778 switch (constant) { 779 case 0: return GetIntConstant0(); 780 case 1: return GetIntConstant1(); 781 default: { 782 HIntConstant* instruction = new (arena_) HIntConstant(constant); 783 entry_block_->AddInstruction(instruction); 784 return instruction; 785 } 786 } 787 } 788 789 HLongConstant* HGraphBuilder::GetLongConstant(int64_t constant) { 790 HLongConstant* instruction = new (arena_) HLongConstant(constant); 791 entry_block_->AddInstruction(instruction); 792 return instruction; 793 } 794 795 HLocal* HGraphBuilder::GetLocalAt(int register_index) const { 796 return locals_.Get(register_index); 797 } 798 799 void HGraphBuilder::UpdateLocal(int register_index, HInstruction* instruction) const { 800 HLocal* local = GetLocalAt(register_index); 801 current_block_->AddInstruction(new (arena_) HStoreLocal(local, instruction)); 802 } 803 804 HInstruction* HGraphBuilder::LoadLocal(int register_index, Primitive::Type type) const { 805 HLocal* local = GetLocalAt(register_index); 806 current_block_->AddInstruction(new (arena_) HLoadLocal(local, type)); 807 return current_block_->GetLastInstruction(); 808 } 809 810 } // namespace art 811
