builder.cc revision afd06414598e011693137ba044e38756609b2179 
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
35namespace 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 */
43class Temporaries : public ValueObject {
44 public:
45  explicit Temporaries(HGraph* graph) : graph_(graph), index_(0) {}
46
47  void Add(HInstruction* instruction) {
48    HInstruction* temp = new (graph_->GetArena()) HTemporary(index_);
49    instruction->GetBlock()->AddInstruction(temp);
50
51    DCHECK(temp->GetPrevious() == instruction);
52
53    size_t offset;
54    if (instruction->GetType() == Primitive::kPrimLong
55        || instruction->GetType() == Primitive::kPrimDouble) {
56      offset = 2;
57    } else {
58      offset = 1;
59    }
60    index_ += offset;
61
62    graph_->UpdateTemporariesVRegSlots(index_);
63  }
64
65 private:
66  HGraph* const graph_;
67
68  // Current index in the temporary stack, updated by `Add`.
69  size_t index_;
70};
71
72class SwitchTable : public ValueObject {
73 public:
74  SwitchTable(const Instruction& instruction, uint32_t dex_pc, bool sparse)
75      : instruction_(instruction), dex_pc_(dex_pc), sparse_(sparse) {
76    int32_t table_offset = instruction.VRegB_31t();
77    const uint16_t* table = reinterpret_cast<const uint16_t*>(&instruction) + table_offset;
78    if (sparse) {
79      CHECK_EQ(table[0], static_cast<uint16_t>(Instruction::kSparseSwitchSignature));
80    } else {
81      CHECK_EQ(table[0], static_cast<uint16_t>(Instruction::kPackedSwitchSignature));
82    }
83    num_entries_ = table[1];
84    values_ = reinterpret_cast<const int32_t*>(&table[2]);
85  }
86
87  uint16_t GetNumEntries() const {
88    return num_entries_;
89  }
90
91  void CheckIndex(size_t index) const {
92    if (sparse_) {
93      // In a sparse table, we have num_entries_ keys and num_entries_ values, in that order.
94      DCHECK_LT(index, 2 * static_cast<size_t>(num_entries_));
95    } else {
96      // In a packed table, we have the starting key and num_entries_ values.
97      DCHECK_LT(index, 1 + static_cast<size_t>(num_entries_));
98    }
99  }
100
101  int32_t GetEntryAt(size_t index) const {
102    CheckIndex(index);
103    return values_[index];
104  }
105
106  uint32_t GetDexPcForIndex(size_t index) const {
107    CheckIndex(index);
108    return dex_pc_ +
109        (reinterpret_cast<const int16_t*>(values_ + index) -
110         reinterpret_cast<const int16_t*>(&instruction_));
111  }
112
113  // Index of the first value in the table.
114  size_t GetFirstValueIndex() const {
115    if (sparse_) {
116      // In a sparse table, we have num_entries_ keys and num_entries_ values, in that order.
117      return num_entries_;
118    } else {
119      // In a packed table, we have the starting key and num_entries_ values.
120      return 1;
121    }
122  }
123
124 private:
125  const Instruction& instruction_;
126  const uint32_t dex_pc_;
127
128  // Whether this is a sparse-switch table (or a packed-switch one).
129  const bool sparse_;
130
131  // This can't be const as it needs to be computed off of the given instruction, and complicated
132  // expressions in the initializer list seemed very ugly.
133  uint16_t num_entries_;
134
135  const int32_t* values_;
136
137  DISALLOW_COPY_AND_ASSIGN(SwitchTable);
138};
139
140void HGraphBuilder::InitializeLocals(uint16_t count) {
141  graph_->SetNumberOfVRegs(count);
142  locals_.SetSize(count);
143  for (int i = 0; i < count; i++) {
144    HLocal* local = new (arena_) HLocal(i);
145    entry_block_->AddInstruction(local);
146    locals_.Put(i, local);
147  }
148}
149
150void HGraphBuilder::InitializeParameters(uint16_t number_of_parameters) {
151  // dex_compilation_unit_ is null only when unit testing.
152  if (dex_compilation_unit_ == nullptr) {
153    return;
154  }
155
156  graph_->SetNumberOfInVRegs(number_of_parameters);
157  const char* shorty = dex_compilation_unit_->GetShorty();
158  int locals_index = locals_.Size() - number_of_parameters;
159  int parameter_index = 0;
160
161  if (!dex_compilation_unit_->IsStatic()) {
162    // Add the implicit 'this' argument, not expressed in the signature.
163    HParameterValue* parameter =
164        new (arena_) HParameterValue(parameter_index++, Primitive::kPrimNot, true);
165    entry_block_->AddInstruction(parameter);
166    HLocal* local = GetLocalAt(locals_index++);
167    entry_block_->AddInstruction(new (arena_) HStoreLocal(local, parameter));
168    number_of_parameters--;
169  }
170
171  uint32_t pos = 1;
172  for (int i = 0; i < number_of_parameters; i++) {
173    HParameterValue* parameter =
174        new (arena_) HParameterValue(parameter_index++, Primitive::GetType(shorty[pos++]));
175    entry_block_->AddInstruction(parameter);
176    HLocal* local = GetLocalAt(locals_index++);
177    // Store the parameter value in the local that the dex code will use
178    // to reference that parameter.
179    entry_block_->AddInstruction(new (arena_) HStoreLocal(local, parameter));
180    bool is_wide = (parameter->GetType() == Primitive::kPrimLong)
181        || (parameter->GetType() == Primitive::kPrimDouble);
182    if (is_wide) {
183      i++;
184      locals_index++;
185      parameter_index++;
186    }
187  }
188}
189
190template<typename T>
191void HGraphBuilder::If_22t(const Instruction& instruction, uint32_t dex_pc) {
192  int32_t target_offset = instruction.GetTargetOffset();
193  HBasicBlock* branch_target = FindBlockStartingAt(dex_pc + target_offset);
194  HBasicBlock* fallthrough_target = FindBlockStartingAt(dex_pc + instruction.SizeInCodeUnits());
195  DCHECK(branch_target != nullptr);
196  DCHECK(fallthrough_target != nullptr);
197  PotentiallyAddSuspendCheck(branch_target, dex_pc);
198  HInstruction* first = LoadLocal(instruction.VRegA(), Primitive::kPrimInt);
199  HInstruction* second = LoadLocal(instruction.VRegB(), Primitive::kPrimInt);
200  T* comparison = new (arena_) T(first, second);
201  current_block_->AddInstruction(comparison);
202  HInstruction* ifinst = new (arena_) HIf(comparison);
203  current_block_->AddInstruction(ifinst);
204  current_block_->AddSuccessor(branch_target);
205  current_block_->AddSuccessor(fallthrough_target);
206  current_block_ = nullptr;
207}
208
209template<typename T>
210void HGraphBuilder::If_21t(const Instruction& instruction, uint32_t dex_pc) {
211  int32_t target_offset = instruction.GetTargetOffset();
212  HBasicBlock* branch_target = FindBlockStartingAt(dex_pc + target_offset);
213  HBasicBlock* fallthrough_target = FindBlockStartingAt(dex_pc + instruction.SizeInCodeUnits());
214  DCHECK(branch_target != nullptr);
215  DCHECK(fallthrough_target != nullptr);
216  PotentiallyAddSuspendCheck(branch_target, dex_pc);
217  HInstruction* value = LoadLocal(instruction.VRegA(), Primitive::kPrimInt);
218  T* comparison = new (arena_) T(value, graph_->GetIntConstant(0));
219  current_block_->AddInstruction(comparison);
220  HInstruction* ifinst = new (arena_) HIf(comparison);
221  current_block_->AddInstruction(ifinst);
222  current_block_->AddSuccessor(branch_target);
223  current_block_->AddSuccessor(fallthrough_target);
224  current_block_ = nullptr;
225}
226
227void HGraphBuilder::MaybeRecordStat(MethodCompilationStat compilation_stat) {
228  if (compilation_stats_ != nullptr) {
229    compilation_stats_->RecordStat(compilation_stat);
230  }
231}
232
233bool HGraphBuilder::SkipCompilation(const DexFile::CodeItem& code_item,
234                                    size_t number_of_branches) {
235  const CompilerOptions& compiler_options = compiler_driver_->GetCompilerOptions();
236  CompilerOptions::CompilerFilter compiler_filter = compiler_options.GetCompilerFilter();
237  if (compiler_filter == CompilerOptions::kEverything) {
238    return false;
239  }
240
241  if (compiler_options.IsHugeMethod(code_item.insns_size_in_code_units_)) {
242    VLOG(compiler) << "Skip compilation of huge method "
243                   << PrettyMethod(dex_compilation_unit_->GetDexMethodIndex(), *dex_file_)
244                   << ": " << code_item.insns_size_in_code_units_ << " code units";
245    MaybeRecordStat(MethodCompilationStat::kNotCompiledHugeMethod);
246    return true;
247  }
248
249  // If it's large and contains no branches, it's likely to be machine generated initialization.
250  if (compiler_options.IsLargeMethod(code_item.insns_size_in_code_units_)
251      && (number_of_branches == 0)) {
252    VLOG(compiler) << "Skip compilation of large method with no branch "
253                   << PrettyMethod(dex_compilation_unit_->GetDexMethodIndex(), *dex_file_)
254                   << ": " << code_item.insns_size_in_code_units_ << " code units";
255    MaybeRecordStat(MethodCompilationStat::kNotCompiledLargeMethodNoBranches);
256    return true;
257  }
258
259  return false;
260}
261
262bool HGraphBuilder::BuildGraph(const DexFile::CodeItem& code_item) {
263  DCHECK(graph_->GetBlocks().IsEmpty());
264
265  const uint16_t* code_ptr = code_item.insns_;
266  const uint16_t* code_end = code_item.insns_ + code_item.insns_size_in_code_units_;
267  code_start_ = code_ptr;
268
269  // Setup the graph with the entry block and exit block.
270  entry_block_ = new (arena_) HBasicBlock(graph_, 0);
271  graph_->AddBlock(entry_block_);
272  exit_block_ = new (arena_) HBasicBlock(graph_, kNoDexPc);
273  graph_->SetEntryBlock(entry_block_);
274  graph_->SetExitBlock(exit_block_);
275
276  InitializeLocals(code_item.registers_size_);
277  graph_->SetMaximumNumberOfOutVRegs(code_item.outs_size_);
278
279  // Compute the number of dex instructions, blocks, and branches. We will
280  // check these values against limits given to the compiler.
281  size_t number_of_branches = 0;
282
283  // To avoid splitting blocks, we compute ahead of time the instructions that
284  // start a new block, and create these blocks.
285  if (!ComputeBranchTargets(code_ptr, code_end, &number_of_branches)) {
286    MaybeRecordStat(MethodCompilationStat::kNotCompiledBranchOutsideMethodCode);
287    return false;
288  }
289
290  // Note that the compiler driver is null when unit testing.
291  if ((compiler_driver_ != nullptr) && SkipCompilation(code_item, number_of_branches)) {
292    return false;
293  }
294
295  // Also create blocks for catch handlers.
296  if (code_item.tries_size_ != 0) {
297    const uint8_t* handlers_ptr = DexFile::GetCatchHandlerData(code_item, 0);
298    uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
299    for (uint32_t idx = 0; idx < handlers_size; ++idx) {
300      CatchHandlerIterator iterator(handlers_ptr);
301      for (; iterator.HasNext(); iterator.Next()) {
302        uint32_t address = iterator.GetHandlerAddress();
303        HBasicBlock* block = FindBlockStartingAt(address);
304        if (block == nullptr) {
305          block = new (arena_) HBasicBlock(graph_, address);
306          branch_targets_.Put(address, block);
307        }
308        block->SetIsCatchBlock();
309      }
310      handlers_ptr = iterator.EndDataPointer();
311    }
312  }
313
314  InitializeParameters(code_item.ins_size_);
315
316  size_t dex_pc = 0;
317  while (code_ptr < code_end) {
318    // Update the current block if dex_pc starts a new block.
319    MaybeUpdateCurrentBlock(dex_pc);
320    const Instruction& instruction = *Instruction::At(code_ptr);
321    if (!AnalyzeDexInstruction(instruction, dex_pc)) {
322      return false;
323    }
324    dex_pc += instruction.SizeInCodeUnits();
325    code_ptr += instruction.SizeInCodeUnits();
326  }
327
328  // Add the exit block at the end to give it the highest id.
329  graph_->AddBlock(exit_block_);
330  exit_block_->AddInstruction(new (arena_) HExit());
331  // Add the suspend check to the entry block.
332  entry_block_->AddInstruction(new (arena_) HSuspendCheck(0));
333  entry_block_->AddInstruction(new (arena_) HGoto());
334
335  return true;
336}
337
338void HGraphBuilder::MaybeUpdateCurrentBlock(size_t index) {
339  HBasicBlock* block = FindBlockStartingAt(index);
340  if (block == nullptr) {
341    return;
342  }
343
344  if (current_block_ != nullptr) {
345    // Branching instructions clear current_block, so we know
346    // the last instruction of the current block is not a branching
347    // instruction. We add an unconditional goto to the found block.
348    current_block_->AddInstruction(new (arena_) HGoto());
349    current_block_->AddSuccessor(block);
350  }
351  graph_->AddBlock(block);
352  current_block_ = block;
353}
354
355bool HGraphBuilder::ComputeBranchTargets(const uint16_t* code_ptr,
356                                         const uint16_t* code_end,
357                                         size_t* number_of_branches) {
358  branch_targets_.SetSize(code_end - code_ptr);
359
360  // Create the first block for the dex instructions, single successor of the entry block.
361  HBasicBlock* block = new (arena_) HBasicBlock(graph_, 0);
362  branch_targets_.Put(0, block);
363  entry_block_->AddSuccessor(block);
364
365  // Iterate over all instructions and find branching instructions. Create blocks for
366  // the locations these instructions branch to.
367  uint32_t dex_pc = 0;
368  while (code_ptr < code_end) {
369    const Instruction& instruction = *Instruction::At(code_ptr);
370    if (instruction.IsBranch()) {
371      (*number_of_branches)++;
372      int32_t target = instruction.GetTargetOffset() + dex_pc;
373      // Create a block for the target instruction.
374      if (FindBlockStartingAt(target) == nullptr) {
375        block = new (arena_) HBasicBlock(graph_, target);
376        branch_targets_.Put(target, block);
377      }
378      dex_pc += instruction.SizeInCodeUnits();
379      code_ptr += instruction.SizeInCodeUnits();
380
381      if (code_ptr >= code_end) {
382        if (instruction.CanFlowThrough()) {
383          // In the normal case we should never hit this but someone can artificially forge a dex
384          // file to fall-through out the method code. In this case we bail out compilation.
385          return false;
386        }
387      } else if (FindBlockStartingAt(dex_pc) == nullptr) {
388        block = new (arena_) HBasicBlock(graph_, dex_pc);
389        branch_targets_.Put(dex_pc, block);
390      }
391    } else if (instruction.IsSwitch()) {
392      SwitchTable table(instruction, dex_pc, instruction.Opcode() == Instruction::SPARSE_SWITCH);
393
394      uint16_t num_entries = table.GetNumEntries();
395
396      // In a packed-switch, the entry at index 0 is the starting key. In a sparse-switch, the
397      // entry at index 0 is the first key, and values are after *all* keys.
398      size_t offset = table.GetFirstValueIndex();
399
400      // Use a larger loop counter type to avoid overflow issues.
401      for (size_t i = 0; i < num_entries; ++i) {
402        // The target of the case.
403        uint32_t target = dex_pc + table.GetEntryAt(i + offset);
404        if (FindBlockStartingAt(target) == nullptr) {
405          block = new (arena_) HBasicBlock(graph_, target);
406          branch_targets_.Put(target, block);
407        }
408
409        // The next case gets its own block.
410        if (i < num_entries) {
411          block = new (arena_) HBasicBlock(graph_, target);
412          branch_targets_.Put(table.GetDexPcForIndex(i), block);
413        }
414      }
415
416      // Fall-through. Add a block if there is more code afterwards.
417      dex_pc += instruction.SizeInCodeUnits();
418      code_ptr += instruction.SizeInCodeUnits();
419      if (code_ptr >= code_end) {
420        // In the normal case we should never hit this but someone can artificially forge a dex
421        // file to fall-through out the method code. In this case we bail out compilation.
422        // (A switch can fall-through so we don't need to check CanFlowThrough().)
423        return false;
424      } else if (FindBlockStartingAt(dex_pc) == nullptr) {
425        block = new (arena_) HBasicBlock(graph_, dex_pc);
426        branch_targets_.Put(dex_pc, block);
427      }
428    } else {
429      code_ptr += instruction.SizeInCodeUnits();
430      dex_pc += instruction.SizeInCodeUnits();
431    }
432  }
433  return true;
434}
435
436HBasicBlock* HGraphBuilder::FindBlockStartingAt(int32_t index) const {
437  DCHECK_GE(index, 0);
438  return branch_targets_.Get(index);
439}
440
441template<typename T>
442void HGraphBuilder::Unop_12x(const Instruction& instruction, Primitive::Type type) {
443  HInstruction* first = LoadLocal(instruction.VRegB(), type);
444  current_block_->AddInstruction(new (arena_) T(type, first));
445  UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction());
446}
447
448void HGraphBuilder::Conversion_12x(const Instruction& instruction,
449                                   Primitive::Type input_type,
450                                   Primitive::Type result_type,
451                                   uint32_t dex_pc) {
452  HInstruction* first = LoadLocal(instruction.VRegB(), input_type);
453  current_block_->AddInstruction(new (arena_) HTypeConversion(result_type, first, dex_pc));
454  UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction());
455}
456
457template<typename T>
458void HGraphBuilder::Binop_23x(const Instruction& instruction, Primitive::Type type) {
459  HInstruction* first = LoadLocal(instruction.VRegB(), type);
460  HInstruction* second = LoadLocal(instruction.VRegC(), type);
461  current_block_->AddInstruction(new (arena_) T(type, first, second));
462  UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction());
463}
464
465template<typename T>
466void HGraphBuilder::Binop_23x(const Instruction& instruction,
467                              Primitive::Type type,
468                              uint32_t dex_pc) {
469  HInstruction* first = LoadLocal(instruction.VRegB(), type);
470  HInstruction* second = LoadLocal(instruction.VRegC(), type);
471  current_block_->AddInstruction(new (arena_) T(type, first, second, dex_pc));
472  UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction());
473}
474
475template<typename T>
476void HGraphBuilder::Binop_23x_shift(const Instruction& instruction,
477                                    Primitive::Type type) {
478  HInstruction* first = LoadLocal(instruction.VRegB(), type);
479  HInstruction* second = LoadLocal(instruction.VRegC(), Primitive::kPrimInt);
480  current_block_->AddInstruction(new (arena_) T(type, first, second));
481  UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction());
482}
483
484void HGraphBuilder::Binop_23x_cmp(const Instruction& instruction,
485                                  Primitive::Type type,
486                                  HCompare::Bias bias) {
487  HInstruction* first = LoadLocal(instruction.VRegB(), type);
488  HInstruction* second = LoadLocal(instruction.VRegC(), type);
489  current_block_->AddInstruction(new (arena_) HCompare(type, first, second, bias));
490  UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction());
491}
492
493template<typename T>
494void HGraphBuilder::Binop_12x(const Instruction& instruction, Primitive::Type type) {
495  HInstruction* first = LoadLocal(instruction.VRegA(), type);
496  HInstruction* second = LoadLocal(instruction.VRegB(), type);
497  current_block_->AddInstruction(new (arena_) T(type, first, second));
498  UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction());
499}
500
501template<typename T>
502void HGraphBuilder::Binop_12x_shift(const Instruction& instruction, Primitive::Type type) {
503  HInstruction* first = LoadLocal(instruction.VRegA(), type);
504  HInstruction* second = LoadLocal(instruction.VRegB(), Primitive::kPrimInt);
505  current_block_->AddInstruction(new (arena_) T(type, first, second));
506  UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction());
507}
508
509template<typename T>
510void HGraphBuilder::Binop_12x(const Instruction& instruction,
511                              Primitive::Type type,
512                              uint32_t dex_pc) {
513  HInstruction* first = LoadLocal(instruction.VRegA(), type);
514  HInstruction* second = LoadLocal(instruction.VRegB(), type);
515  current_block_->AddInstruction(new (arena_) T(type, first, second, dex_pc));
516  UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction());
517}
518
519template<typename T>
520void HGraphBuilder::Binop_22s(const Instruction& instruction, bool reverse) {
521  HInstruction* first = LoadLocal(instruction.VRegB(), Primitive::kPrimInt);
522  HInstruction* second = graph_->GetIntConstant(instruction.VRegC_22s());
523  if (reverse) {
524    std::swap(first, second);
525  }
526  current_block_->AddInstruction(new (arena_) T(Primitive::kPrimInt, first, second));
527  UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction());
528}
529
530template<typename T>
531void HGraphBuilder::Binop_22b(const Instruction& instruction, bool reverse) {
532  HInstruction* first = LoadLocal(instruction.VRegB(), Primitive::kPrimInt);
533  HInstruction* second = graph_->GetIntConstant(instruction.VRegC_22b());
534  if (reverse) {
535    std::swap(first, second);
536  }
537  current_block_->AddInstruction(new (arena_) T(Primitive::kPrimInt, first, second));
538  UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction());
539}
540
541static bool RequiresConstructorBarrier(const DexCompilationUnit* cu, const CompilerDriver& driver) {
542  Thread* self = Thread::Current();
543  return cu->IsConstructor()
544      && driver.RequiresConstructorBarrier(self, cu->GetDexFile(), cu->GetClassDefIndex());
545}
546
547void HGraphBuilder::BuildReturn(const Instruction& instruction, Primitive::Type type) {
548  if (type == Primitive::kPrimVoid) {
549    if (graph_->ShouldGenerateConstructorBarrier()) {
550      // The compilation unit is null during testing.
551      if (dex_compilation_unit_ != nullptr) {
552        DCHECK(RequiresConstructorBarrier(dex_compilation_unit_, *compiler_driver_))
553          << "Inconsistent use of ShouldGenerateConstructorBarrier. Should not generate a barrier.";
554      }
555      current_block_->AddInstruction(new (arena_) HMemoryBarrier(kStoreStore));
556    }
557    current_block_->AddInstruction(new (arena_) HReturnVoid());
558  } else {
559    HInstruction* value = LoadLocal(instruction.VRegA(), type);
560    current_block_->AddInstruction(new (arena_) HReturn(value));
561  }
562  current_block_->AddSuccessor(exit_block_);
563  current_block_ = nullptr;
564}
565
566bool HGraphBuilder::BuildInvoke(const Instruction& instruction,
567                                uint32_t dex_pc,
568                                uint32_t method_idx,
569                                uint32_t number_of_vreg_arguments,
570                                bool is_range,
571                                uint32_t* args,
572                                uint32_t register_index) {
573  Instruction::Code opcode = instruction.Opcode();
574  InvokeType invoke_type;
575  switch (opcode) {
576    case Instruction::INVOKE_STATIC:
577    case Instruction::INVOKE_STATIC_RANGE:
578      invoke_type = kStatic;
579      break;
580    case Instruction::INVOKE_DIRECT:
581    case Instruction::INVOKE_DIRECT_RANGE:
582      invoke_type = kDirect;
583      break;
584    case Instruction::INVOKE_VIRTUAL:
585    case Instruction::INVOKE_VIRTUAL_RANGE:
586      invoke_type = kVirtual;
587      break;
588    case Instruction::INVOKE_INTERFACE:
589    case Instruction::INVOKE_INTERFACE_RANGE:
590      invoke_type = kInterface;
591      break;
592    case Instruction::INVOKE_SUPER_RANGE:
593    case Instruction::INVOKE_SUPER:
594      invoke_type = kSuper;
595      break;
596    default:
597      LOG(FATAL) << "Unexpected invoke op: " << opcode;
598      return false;
599  }
600
601  const DexFile::MethodId& method_id = dex_file_->GetMethodId(method_idx);
602  const DexFile::ProtoId& proto_id = dex_file_->GetProtoId(method_id.proto_idx_);
603  const char* descriptor = dex_file_->StringDataByIdx(proto_id.shorty_idx_);
604  Primitive::Type return_type = Primitive::GetType(descriptor[0]);
605  bool is_instance_call = invoke_type != kStatic;
606  // Remove the return type from the 'proto'.
607  size_t number_of_arguments = strlen(descriptor) - 1;
608  if (is_instance_call) {
609    // One extra argument for 'this'.
610    ++number_of_arguments;
611  }
612
613  MethodReference target_method(dex_file_, method_idx);
614  uintptr_t direct_code;
615  uintptr_t direct_method;
616  int table_index;
617  InvokeType optimized_invoke_type = invoke_type;
618
619  if (!compiler_driver_->ComputeInvokeInfo(dex_compilation_unit_, dex_pc, true, true,
620                                           &optimized_invoke_type, &target_method, &table_index,
621                                           &direct_code, &direct_method)) {
622    VLOG(compiler) << "Did not compile "
623                   << PrettyMethod(dex_compilation_unit_->GetDexMethodIndex(), *dex_file_)
624                   << " because a method call could not be resolved";
625    MaybeRecordStat(MethodCompilationStat::kNotCompiledUnresolvedMethod);
626    return false;
627  }
628  DCHECK(optimized_invoke_type != kSuper);
629
630  // By default, consider that the called method implicitly requires
631  // an initialization check of its declaring method.
632  HInvokeStaticOrDirect::ClinitCheckRequirement clinit_check_requirement =
633      HInvokeStaticOrDirect::ClinitCheckRequirement::kImplicit;
634  // Potential class initialization check, in the case of a static method call.
635  HClinitCheck* clinit_check = nullptr;
636  // Replace calls to String.<init> with StringFactory.
637  int32_t string_init_offset = 0;
638  bool is_string_init = compiler_driver_->IsStringInit(method_idx, dex_file_, &string_init_offset);
639  if (is_string_init) {
640    return_type = Primitive::kPrimNot;
641    is_instance_call = false;
642    number_of_arguments--;
643    invoke_type = kStatic;
644    optimized_invoke_type = kStatic;
645  }
646
647  HInvoke* invoke = nullptr;
648
649  if (optimized_invoke_type == kVirtual) {
650    invoke = new (arena_) HInvokeVirtual(
651        arena_, number_of_arguments, return_type, dex_pc, method_idx, table_index);
652  } else if (optimized_invoke_type == kInterface) {
653    invoke = new (arena_) HInvokeInterface(
654        arena_, number_of_arguments, return_type, dex_pc, method_idx, table_index);
655  } else {
656    DCHECK(optimized_invoke_type == kDirect || optimized_invoke_type == kStatic);
657    // Sharpening to kDirect only works if we compile PIC.
658    DCHECK((optimized_invoke_type == invoke_type) || (optimized_invoke_type != kDirect)
659           || compiler_driver_->GetCompilerOptions().GetCompilePic());
660    bool is_recursive =
661        (target_method.dex_method_index == outer_compilation_unit_->GetDexMethodIndex())
662        && (target_method.dex_file == outer_compilation_unit_->GetDexFile());
663
664    if (optimized_invoke_type == kStatic) {
665      ScopedObjectAccess soa(Thread::Current());
666      StackHandleScope<4> hs(soa.Self());
667      Handle<mirror::DexCache> dex_cache(hs.NewHandle(
668          dex_compilation_unit_->GetClassLinker()->FindDexCache(
669              *dex_compilation_unit_->GetDexFile())));
670      Handle<mirror::ClassLoader> class_loader(hs.NewHandle(
671          soa.Decode<mirror::ClassLoader*>(dex_compilation_unit_->GetClassLoader())));
672      ArtMethod* resolved_method = compiler_driver_->ResolveMethod(
673          soa, dex_cache, class_loader, dex_compilation_unit_, method_idx, optimized_invoke_type);
674
675      if (resolved_method == nullptr) {
676        MaybeRecordStat(MethodCompilationStat::kNotCompiledUnresolvedMethod);
677        return false;
678      }
679
680      const DexFile& outer_dex_file = *outer_compilation_unit_->GetDexFile();
681      Handle<mirror::DexCache> outer_dex_cache(hs.NewHandle(
682          outer_compilation_unit_->GetClassLinker()->FindDexCache(outer_dex_file)));
683      Handle<mirror::Class> outer_class(hs.NewHandle(GetOutermostCompilingClass()));
684
685      // The index at which the method's class is stored in the DexCache's type array.
686      uint32_t storage_index = DexFile::kDexNoIndex;
687      bool is_outer_class = (resolved_method->GetDeclaringClass() == outer_class.Get());
688      if (is_outer_class) {
689        storage_index = outer_class->GetDexTypeIndex();
690      } else if (outer_dex_cache.Get() == dex_cache.Get()) {
691        // Get `storage_index` from IsClassOfStaticMethodAvailableToReferrer.
692        compiler_driver_->IsClassOfStaticMethodAvailableToReferrer(outer_dex_cache.Get(),
693                                                                   GetCompilingClass(),
694                                                                   resolved_method,
695                                                                   method_idx,
696                                                                   &storage_index);
697      }
698
699      if (outer_class.Get()->IsSubClass(resolved_method->GetDeclaringClass())) {
700        // If the outer class is the declaring class or a subclass
701        // of the declaring class, no class initialization is needed
702        // before the static method call.
703        // Note that in case of inlining, we do not need to add clinit checks
704        // to calls that satisfy this subclass check with any inlined methods. This
705        // will be detected by the optimization passes.
706        clinit_check_requirement = HInvokeStaticOrDirect::ClinitCheckRequirement::kNone;
707      } else if (storage_index != DexFile::kDexNoIndex) {
708        // If the method's class type index is available, check
709        // whether we should add an explicit class initialization
710        // check for its declaring class before the static method call.
711
712        // TODO: find out why this check is needed.
713        bool is_in_dex_cache = compiler_driver_->CanAssumeTypeIsPresentInDexCache(
714            *outer_compilation_unit_->GetDexFile(), storage_index);
715        bool is_initialized =
716            resolved_method->GetDeclaringClass()->IsInitialized() && is_in_dex_cache;
717
718        if (is_initialized) {
719          clinit_check_requirement = HInvokeStaticOrDirect::ClinitCheckRequirement::kNone;
720        } else {
721          clinit_check_requirement = HInvokeStaticOrDirect::ClinitCheckRequirement::kExplicit;
722          HLoadClass* load_class = new (arena_) HLoadClass(
723              graph_->GetCurrentMethod(),
724              storage_index,
725              *dex_compilation_unit_->GetDexFile(),
726              is_outer_class,
727              dex_pc);
728          current_block_->AddInstruction(load_class);
729          clinit_check = new (arena_) HClinitCheck(load_class, dex_pc);
730          current_block_->AddInstruction(clinit_check);
731        }
732      }
733    }
734
735    invoke = new (arena_) HInvokeStaticOrDirect(arena_,
736                                                number_of_arguments,
737                                                return_type,
738                                                dex_pc,
739                                                target_method.dex_method_index,
740                                                is_recursive,
741                                                string_init_offset,
742                                                invoke_type,
743                                                optimized_invoke_type,
744                                                clinit_check_requirement);
745  }
746
747  size_t start_index = 0;
748  Temporaries temps(graph_);
749  if (is_instance_call) {
750    HInstruction* arg = LoadLocal(is_range ? register_index : args[0], Primitive::kPrimNot);
751    HNullCheck* null_check = new (arena_) HNullCheck(arg, dex_pc);
752    current_block_->AddInstruction(null_check);
753    temps.Add(null_check);
754    invoke->SetArgumentAt(0, null_check);
755    start_index = 1;
756  }
757
758  uint32_t descriptor_index = 1;  // Skip the return type.
759  uint32_t argument_index = start_index;
760  if (is_string_init) {
761    start_index = 1;
762  }
763  for (size_t i = start_index;
764       // Make sure we don't go over the expected arguments or over the number of
765       // dex registers given. If the instruction was seen as dead by the verifier,
766       // it hasn't been properly checked.
767       (i < number_of_vreg_arguments) && (argument_index < number_of_arguments);
768       i++, argument_index++) {
769    Primitive::Type type = Primitive::GetType(descriptor[descriptor_index++]);
770    bool is_wide = (type == Primitive::kPrimLong) || (type == Primitive::kPrimDouble);
771    if (!is_range
772        && is_wide
773        && ((i + 1 == number_of_vreg_arguments) || (args[i] + 1 != args[i + 1]))) {
774      // Longs and doubles should be in pairs, that is, sequential registers. The verifier should
775      // reject any class where this is violated. However, the verifier only does these checks
776      // on non trivially dead instructions, so we just bailout the compilation.
777      VLOG(compiler) << "Did not compile "
778                     << PrettyMethod(dex_compilation_unit_->GetDexMethodIndex(), *dex_file_)
779                     << " because of non-sequential dex register pair in wide argument";
780      MaybeRecordStat(MethodCompilationStat::kNotCompiledMalformedOpcode);
781      return false;
782    }
783    HInstruction* arg = LoadLocal(is_range ? register_index + i : args[i], type);
784    invoke->SetArgumentAt(argument_index, arg);
785    if (is_wide) {
786      i++;
787    }
788  }
789
790  if (argument_index != number_of_arguments) {
791    VLOG(compiler) << "Did not compile "
792                   << PrettyMethod(dex_compilation_unit_->GetDexMethodIndex(), *dex_file_)
793                   << " because of wrong number of arguments in invoke instruction";
794    MaybeRecordStat(MethodCompilationStat::kNotCompiledMalformedOpcode);
795    return false;
796  }
797
798  if (invoke->IsInvokeStaticOrDirect()) {
799    invoke->SetArgumentAt(argument_index, graph_->GetCurrentMethod());
800    argument_index++;
801  }
802
803  if (clinit_check_requirement == HInvokeStaticOrDirect::ClinitCheckRequirement::kExplicit) {
804    // Add the class initialization check as last input of `invoke`.
805    DCHECK(clinit_check != nullptr);
806    invoke->SetArgumentAt(argument_index, clinit_check);
807  }
808
809  current_block_->AddInstruction(invoke);
810  latest_result_ = invoke;
811
812  // Add move-result for StringFactory method.
813  if (is_string_init) {
814    uint32_t orig_this_reg = is_range ? register_index : args[0];
815    const VerifiedMethod* verified_method =
816        compiler_driver_->GetVerifiedMethod(dex_file_, dex_compilation_unit_->GetDexMethodIndex());
817    if (verified_method == nullptr) {
818      LOG(WARNING) << "No verified method for method calling String.<init>: "
819                   << PrettyMethod(dex_compilation_unit_->GetDexMethodIndex(), *dex_file_);
820      return false;
821    }
822    const SafeMap<uint32_t, std::set<uint32_t>>& string_init_map =
823        verified_method->GetStringInitPcRegMap();
824    auto map_it = string_init_map.find(dex_pc);
825    if (map_it != string_init_map.end()) {
826      std::set<uint32_t> reg_set = map_it->second;
827      for (auto set_it = reg_set.begin(); set_it != reg_set.end(); ++set_it) {
828        UpdateLocal(*set_it, invoke);
829      }
830    }
831    UpdateLocal(orig_this_reg, invoke);
832  }
833  return true;
834}
835
836bool HGraphBuilder::BuildInstanceFieldAccess(const Instruction& instruction,
837                                             uint32_t dex_pc,
838                                             bool is_put) {
839  uint32_t source_or_dest_reg = instruction.VRegA_22c();
840  uint32_t obj_reg = instruction.VRegB_22c();
841  uint16_t field_index = instruction.VRegC_22c();
842
843  ScopedObjectAccess soa(Thread::Current());
844  ArtField* resolved_field =
845      compiler_driver_->ComputeInstanceFieldInfo(field_index, dex_compilation_unit_, is_put, soa);
846
847  if (resolved_field == nullptr) {
848    MaybeRecordStat(MethodCompilationStat::kNotCompiledUnresolvedField);
849    return false;
850  }
851
852  Primitive::Type field_type = resolved_field->GetTypeAsPrimitiveType();
853
854  HInstruction* object = LoadLocal(obj_reg, Primitive::kPrimNot);
855  current_block_->AddInstruction(new (arena_) HNullCheck(object, dex_pc));
856  if (is_put) {
857    Temporaries temps(graph_);
858    HInstruction* null_check = current_block_->GetLastInstruction();
859    // We need one temporary for the null check.
860    temps.Add(null_check);
861    HInstruction* value = LoadLocal(source_or_dest_reg, field_type);
862    current_block_->AddInstruction(new (arena_) HInstanceFieldSet(
863        null_check,
864        value,
865        field_type,
866        resolved_field->GetOffset(),
867        resolved_field->IsVolatile(),
868        field_index,
869        *dex_file_));
870  } else {
871    current_block_->AddInstruction(new (arena_) HInstanceFieldGet(
872        current_block_->GetLastInstruction(),
873        field_type,
874        resolved_field->GetOffset(),
875        resolved_field->IsVolatile(),
876        field_index,
877        *dex_file_));
878
879    UpdateLocal(source_or_dest_reg, current_block_->GetLastInstruction());
880  }
881  return true;
882}
883
884static mirror::Class* GetClassFrom(CompilerDriver* driver,
885                                   const DexCompilationUnit& compilation_unit) {
886  ScopedObjectAccess soa(Thread::Current());
887  StackHandleScope<2> hs(soa.Self());
888  const DexFile& dex_file = *compilation_unit.GetDexFile();
889  Handle<mirror::ClassLoader> class_loader(hs.NewHandle(
890      soa.Decode<mirror::ClassLoader*>(compilation_unit.GetClassLoader())));
891  Handle<mirror::DexCache> dex_cache(hs.NewHandle(
892      compilation_unit.GetClassLinker()->FindDexCache(dex_file)));
893
894  return driver->ResolveCompilingMethodsClass(soa, dex_cache, class_loader, &compilation_unit);
895}
896
897mirror::Class* HGraphBuilder::GetOutermostCompilingClass() const {
898  return GetClassFrom(compiler_driver_, *outer_compilation_unit_);
899}
900
901mirror::Class* HGraphBuilder::GetCompilingClass() const {
902  return GetClassFrom(compiler_driver_, *dex_compilation_unit_);
903}
904
905bool HGraphBuilder::IsOutermostCompilingClass(uint16_t type_index) const {
906  ScopedObjectAccess soa(Thread::Current());
907  StackHandleScope<4> hs(soa.Self());
908  Handle<mirror::DexCache> dex_cache(hs.NewHandle(
909      dex_compilation_unit_->GetClassLinker()->FindDexCache(*dex_compilation_unit_->GetDexFile())));
910  Handle<mirror::ClassLoader> class_loader(hs.NewHandle(
911      soa.Decode<mirror::ClassLoader*>(dex_compilation_unit_->GetClassLoader())));
912  Handle<mirror::Class> cls(hs.NewHandle(compiler_driver_->ResolveClass(
913      soa, dex_cache, class_loader, type_index, dex_compilation_unit_)));
914  Handle<mirror::Class> outer_class(hs.NewHandle(GetOutermostCompilingClass()));
915
916  return outer_class.Get() == cls.Get();
917}
918
919bool HGraphBuilder::BuildStaticFieldAccess(const Instruction& instruction,
920                                           uint32_t dex_pc,
921                                           bool is_put) {
922  uint32_t source_or_dest_reg = instruction.VRegA_21c();
923  uint16_t field_index = instruction.VRegB_21c();
924
925  ScopedObjectAccess soa(Thread::Current());
926  StackHandleScope<4> hs(soa.Self());
927  Handle<mirror::DexCache> dex_cache(hs.NewHandle(
928      dex_compilation_unit_->GetClassLinker()->FindDexCache(*dex_compilation_unit_->GetDexFile())));
929  Handle<mirror::ClassLoader> class_loader(hs.NewHandle(
930      soa.Decode<mirror::ClassLoader*>(dex_compilation_unit_->GetClassLoader())));
931  ArtField* resolved_field = compiler_driver_->ResolveField(
932      soa, dex_cache, class_loader, dex_compilation_unit_, field_index, true);
933
934  if (resolved_field == nullptr) {
935    MaybeRecordStat(MethodCompilationStat::kNotCompiledUnresolvedField);
936    return false;
937  }
938
939  const DexFile& outer_dex_file = *outer_compilation_unit_->GetDexFile();
940  Handle<mirror::DexCache> outer_dex_cache(hs.NewHandle(
941      outer_compilation_unit_->GetClassLinker()->FindDexCache(outer_dex_file)));
942  Handle<mirror::Class> outer_class(hs.NewHandle(GetOutermostCompilingClass()));
943
944  // The index at which the field's class is stored in the DexCache's type array.
945  uint32_t storage_index;
946  bool is_outer_class = (outer_class.Get() == resolved_field->GetDeclaringClass());
947  if (is_outer_class) {
948    storage_index = outer_class->GetDexTypeIndex();
949  } else if (outer_dex_cache.Get() != dex_cache.Get()) {
950    // The compiler driver cannot currently understand multiple dex caches involved. Just bailout.
951    return false;
952  } else {
953    std::pair<bool, bool> pair = compiler_driver_->IsFastStaticField(
954        outer_dex_cache.Get(),
955        GetCompilingClass(),
956        resolved_field,
957        field_index,
958        &storage_index);
959    bool can_easily_access = is_put ? pair.second : pair.first;
960    if (!can_easily_access) {
961      return false;
962    }
963  }
964
965  // TODO: find out why this check is needed.
966  bool is_in_dex_cache = compiler_driver_->CanAssumeTypeIsPresentInDexCache(
967      *outer_compilation_unit_->GetDexFile(), storage_index);
968  bool is_initialized = resolved_field->GetDeclaringClass()->IsInitialized() && is_in_dex_cache;
969
970  HLoadClass* constant = new (arena_) HLoadClass(graph_->GetCurrentMethod(),
971                                                 storage_index,
972                                                 *dex_compilation_unit_->GetDexFile(),
973                                                 is_outer_class,
974                                                 dex_pc);
975  current_block_->AddInstruction(constant);
976
977  HInstruction* cls = constant;
978  if (!is_initialized && !is_outer_class) {
979    cls = new (arena_) HClinitCheck(constant, dex_pc);
980    current_block_->AddInstruction(cls);
981  }
982
983  Primitive::Type field_type = resolved_field->GetTypeAsPrimitiveType();
984  if (is_put) {
985    // We need to keep the class alive before loading the value.
986    Temporaries temps(graph_);
987    temps.Add(cls);
988    HInstruction* value = LoadLocal(source_or_dest_reg, field_type);
989    DCHECK_EQ(value->GetType(), field_type);
990    current_block_->AddInstruction(new (arena_) HStaticFieldSet(cls,
991                                                                value,
992                                                                field_type,
993                                                                resolved_field->GetOffset(),
994                                                                resolved_field->IsVolatile(),
995                                                                field_index,
996                                                                *dex_file_));
997  } else {
998    current_block_->AddInstruction(new (arena_) HStaticFieldGet(cls,
999                                                                field_type,
1000                                                                resolved_field->GetOffset(),
1001                                                                resolved_field->IsVolatile(),
1002                                                                field_index,
1003                                                                *dex_file_));
1004    UpdateLocal(source_or_dest_reg, current_block_->GetLastInstruction());
1005  }
1006  return true;
1007}
1008
1009void HGraphBuilder::BuildCheckedDivRem(uint16_t out_vreg,
1010                                       uint16_t first_vreg,
1011                                       int64_t second_vreg_or_constant,
1012                                       uint32_t dex_pc,
1013                                       Primitive::Type type,
1014                                       bool second_is_constant,
1015                                       bool isDiv) {
1016  DCHECK(type == Primitive::kPrimInt || type == Primitive::kPrimLong);
1017
1018  HInstruction* first = LoadLocal(first_vreg, type);
1019  HInstruction* second = nullptr;
1020  if (second_is_constant) {
1021    if (type == Primitive::kPrimInt) {
1022      second = graph_->GetIntConstant(second_vreg_or_constant);
1023    } else {
1024      second = graph_->GetLongConstant(second_vreg_or_constant);
1025    }
1026  } else {
1027    second = LoadLocal(second_vreg_or_constant, type);
1028  }
1029
1030  if (!second_is_constant
1031      || (type == Primitive::kPrimInt && second->AsIntConstant()->GetValue() == 0)
1032      || (type == Primitive::kPrimLong && second->AsLongConstant()->GetValue() == 0)) {
1033    second = new (arena_) HDivZeroCheck(second, dex_pc);
1034    Temporaries temps(graph_);
1035    current_block_->AddInstruction(second);
1036    temps.Add(current_block_->GetLastInstruction());
1037  }
1038
1039  if (isDiv) {
1040    current_block_->AddInstruction(new (arena_) HDiv(type, first, second, dex_pc));
1041  } else {
1042    current_block_->AddInstruction(new (arena_) HRem(type, first, second, dex_pc));
1043  }
1044  UpdateLocal(out_vreg, current_block_->GetLastInstruction());
1045}
1046
1047void HGraphBuilder::BuildArrayAccess(const Instruction& instruction,
1048                                     uint32_t dex_pc,
1049                                     bool is_put,
1050                                     Primitive::Type anticipated_type) {
1051  uint8_t source_or_dest_reg = instruction.VRegA_23x();
1052  uint8_t array_reg = instruction.VRegB_23x();
1053  uint8_t index_reg = instruction.VRegC_23x();
1054
1055  // We need one temporary for the null check, one for the index, and one for the length.
1056  Temporaries temps(graph_);
1057
1058  HInstruction* object = LoadLocal(array_reg, Primitive::kPrimNot);
1059  object = new (arena_) HNullCheck(object, dex_pc);
1060  current_block_->AddInstruction(object);
1061  temps.Add(object);
1062
1063  HInstruction* length = new (arena_) HArrayLength(object);
1064  current_block_->AddInstruction(length);
1065  temps.Add(length);
1066  HInstruction* index = LoadLocal(index_reg, Primitive::kPrimInt);
1067  index = new (arena_) HBoundsCheck(index, length, dex_pc);
1068  current_block_->AddInstruction(index);
1069  temps.Add(index);
1070  if (is_put) {
1071    HInstruction* value = LoadLocal(source_or_dest_reg, anticipated_type);
1072    // TODO: Insert a type check node if the type is Object.
1073    current_block_->AddInstruction(new (arena_) HArraySet(
1074        object, index, value, anticipated_type, dex_pc));
1075  } else {
1076    current_block_->AddInstruction(new (arena_) HArrayGet(object, index, anticipated_type));
1077    UpdateLocal(source_or_dest_reg, current_block_->GetLastInstruction());
1078  }
1079  graph_->SetHasBoundsChecks(true);
1080}
1081
1082void HGraphBuilder::BuildFilledNewArray(uint32_t dex_pc,
1083                                        uint32_t type_index,
1084                                        uint32_t number_of_vreg_arguments,
1085                                        bool is_range,
1086                                        uint32_t* args,
1087                                        uint32_t register_index) {
1088  HInstruction* length = graph_->GetIntConstant(number_of_vreg_arguments);
1089  QuickEntrypointEnum entrypoint = NeedsAccessCheck(type_index)
1090      ? kQuickAllocArrayWithAccessCheck
1091      : kQuickAllocArray;
1092  HInstruction* object = new (arena_) HNewArray(length,
1093                                                graph_->GetCurrentMethod(),
1094                                                dex_pc,
1095                                                type_index,
1096                                                *dex_compilation_unit_->GetDexFile(),
1097                                                entrypoint);
1098  current_block_->AddInstruction(object);
1099
1100  const char* descriptor = dex_file_->StringByTypeIdx(type_index);
1101  DCHECK_EQ(descriptor[0], '[') << descriptor;
1102  char primitive = descriptor[1];
1103  DCHECK(primitive == 'I'
1104      || primitive == 'L'
1105      || primitive == '[') << descriptor;
1106  bool is_reference_array = (primitive == 'L') || (primitive == '[');
1107  Primitive::Type type = is_reference_array ? Primitive::kPrimNot : Primitive::kPrimInt;
1108
1109  Temporaries temps(graph_);
1110  temps.Add(object);
1111  for (size_t i = 0; i < number_of_vreg_arguments; ++i) {
1112    HInstruction* value = LoadLocal(is_range ? register_index + i : args[i], type);
1113    HInstruction* index = graph_->GetIntConstant(i);
1114    current_block_->AddInstruction(
1115        new (arena_) HArraySet(object, index, value, type, dex_pc));
1116  }
1117  latest_result_ = object;
1118}
1119
1120template <typename T>
1121void HGraphBuilder::BuildFillArrayData(HInstruction* object,
1122                                       const T* data,
1123                                       uint32_t element_count,
1124                                       Primitive::Type anticipated_type,
1125                                       uint32_t dex_pc) {
1126  for (uint32_t i = 0; i < element_count; ++i) {
1127    HInstruction* index = graph_->GetIntConstant(i);
1128    HInstruction* value = graph_->GetIntConstant(data[i]);
1129    current_block_->AddInstruction(new (arena_) HArraySet(
1130      object, index, value, anticipated_type, dex_pc));
1131  }
1132}
1133
1134void HGraphBuilder::BuildFillArrayData(const Instruction& instruction, uint32_t dex_pc) {
1135  Temporaries temps(graph_);
1136  HInstruction* array = LoadLocal(instruction.VRegA_31t(), Primitive::kPrimNot);
1137  HNullCheck* null_check = new (arena_) HNullCheck(array, dex_pc);
1138  current_block_->AddInstruction(null_check);
1139  temps.Add(null_check);
1140
1141  HInstruction* length = new (arena_) HArrayLength(null_check);
1142  current_block_->AddInstruction(length);
1143
1144  int32_t payload_offset = instruction.VRegB_31t() + dex_pc;
1145  const Instruction::ArrayDataPayload* payload =
1146      reinterpret_cast<const Instruction::ArrayDataPayload*>(code_start_ + payload_offset);
1147  const uint8_t* data = payload->data;
1148  uint32_t element_count = payload->element_count;
1149
1150  // Implementation of this DEX instruction seems to be that the bounds check is
1151  // done before doing any stores.
1152  HInstruction* last_index = graph_->GetIntConstant(payload->element_count - 1);
1153  current_block_->AddInstruction(new (arena_) HBoundsCheck(last_index, length, dex_pc));
1154
1155  switch (payload->element_width) {
1156    case 1:
1157      BuildFillArrayData(null_check,
1158                         reinterpret_cast<const int8_t*>(data),
1159                         element_count,
1160                         Primitive::kPrimByte,
1161                         dex_pc);
1162      break;
1163    case 2:
1164      BuildFillArrayData(null_check,
1165                         reinterpret_cast<const int16_t*>(data),
1166                         element_count,
1167                         Primitive::kPrimShort,
1168                         dex_pc);
1169      break;
1170    case 4:
1171      BuildFillArrayData(null_check,
1172                         reinterpret_cast<const int32_t*>(data),
1173                         element_count,
1174                         Primitive::kPrimInt,
1175                         dex_pc);
1176      break;
1177    case 8:
1178      BuildFillWideArrayData(null_check,
1179                             reinterpret_cast<const int64_t*>(data),
1180                             element_count,
1181                             dex_pc);
1182      break;
1183    default:
1184      LOG(FATAL) << "Unknown element width for " << payload->element_width;
1185  }
1186  graph_->SetHasBoundsChecks(true);
1187}
1188
1189void HGraphBuilder::BuildFillWideArrayData(HInstruction* object,
1190                                           const int64_t* data,
1191                                           uint32_t element_count,
1192                                           uint32_t dex_pc) {
1193  for (uint32_t i = 0; i < element_count; ++i) {
1194    HInstruction* index = graph_->GetIntConstant(i);
1195    HInstruction* value = graph_->GetLongConstant(data[i]);
1196    current_block_->AddInstruction(new (arena_) HArraySet(
1197      object, index, value, Primitive::kPrimLong, dex_pc));
1198  }
1199}
1200
1201bool HGraphBuilder::BuildTypeCheck(const Instruction& instruction,
1202                                   uint8_t destination,
1203                                   uint8_t reference,
1204                                   uint16_t type_index,
1205                                   uint32_t dex_pc) {
1206  bool type_known_final;
1207  bool type_known_abstract;
1208  // `CanAccessTypeWithoutChecks` will tell whether the method being
1209  // built is trying to access its own class, so that the generated
1210  // code can optimize for this case. However, the optimization does not
1211  // work for inlining, so we use `IsOutermostCompilingClass` instead.
1212  bool dont_use_is_referrers_class;
1213  bool can_access = compiler_driver_->CanAccessTypeWithoutChecks(
1214      dex_compilation_unit_->GetDexMethodIndex(), *dex_file_, type_index,
1215      &type_known_final, &type_known_abstract, &dont_use_is_referrers_class);
1216  if (!can_access) {
1217    MaybeRecordStat(MethodCompilationStat::kNotCompiledCantAccesType);
1218    return false;
1219  }
1220  HInstruction* object = LoadLocal(reference, Primitive::kPrimNot);
1221  HLoadClass* cls = new (arena_) HLoadClass(
1222      graph_->GetCurrentMethod(),
1223      type_index,
1224      *dex_compilation_unit_->GetDexFile(),
1225      IsOutermostCompilingClass(type_index),
1226      dex_pc);
1227  current_block_->AddInstruction(cls);
1228  // The class needs a temporary before being used by the type check.
1229  Temporaries temps(graph_);
1230  temps.Add(cls);
1231  if (instruction.Opcode() == Instruction::INSTANCE_OF) {
1232    current_block_->AddInstruction(
1233        new (arena_) HInstanceOf(object, cls, type_known_final, dex_pc));
1234    UpdateLocal(destination, current_block_->GetLastInstruction());
1235  } else {
1236    DCHECK_EQ(instruction.Opcode(), Instruction::CHECK_CAST);
1237    current_block_->AddInstruction(
1238        new (arena_) HCheckCast(object, cls, type_known_final, dex_pc));
1239  }
1240  return true;
1241}
1242
1243bool HGraphBuilder::NeedsAccessCheck(uint32_t type_index) const {
1244  return !compiler_driver_->CanAccessInstantiableTypeWithoutChecks(
1245      dex_compilation_unit_->GetDexMethodIndex(), *dex_file_, type_index);
1246}
1247
1248void HGraphBuilder::BuildPackedSwitch(const Instruction& instruction, uint32_t dex_pc) {
1249  // Verifier guarantees that the payload for PackedSwitch contains:
1250  //   (a) number of entries (may be zero)
1251  //   (b) first and lowest switch case value (entry 0, always present)
1252  //   (c) list of target pcs (entries 1 <= i <= N)
1253  SwitchTable table(instruction, dex_pc, false);
1254
1255  // Value to test against.
1256  HInstruction* value = LoadLocal(instruction.VRegA(), Primitive::kPrimInt);
1257
1258  // Retrieve number of entries.
1259  uint16_t num_entries = table.GetNumEntries();
1260  if (num_entries == 0) {
1261    return;
1262  }
1263
1264  // Chained cmp-and-branch, starting from starting_key.
1265  int32_t starting_key = table.GetEntryAt(0);
1266
1267  for (size_t i = 1; i <= num_entries; i++) {
1268    BuildSwitchCaseHelper(instruction, i, i == num_entries, table, value, starting_key + i - 1,
1269                          table.GetEntryAt(i), dex_pc);
1270  }
1271}
1272
1273void HGraphBuilder::BuildSparseSwitch(const Instruction& instruction, uint32_t dex_pc) {
1274  // Verifier guarantees that the payload for SparseSwitch contains:
1275  //   (a) number of entries (may be zero)
1276  //   (b) sorted key values (entries 0 <= i < N)
1277  //   (c) target pcs corresponding to the switch values (entries N <= i < 2*N)
1278  SwitchTable table(instruction, dex_pc, true);
1279
1280  // Value to test against.
1281  HInstruction* value = LoadLocal(instruction.VRegA(), Primitive::kPrimInt);
1282
1283  uint16_t num_entries = table.GetNumEntries();
1284
1285  for (size_t i = 0; i < num_entries; i++) {
1286    BuildSwitchCaseHelper(instruction, i, i == static_cast<size_t>(num_entries) - 1, table, value,
1287                          table.GetEntryAt(i), table.GetEntryAt(i + num_entries), dex_pc);
1288  }
1289}
1290
1291void HGraphBuilder::BuildSwitchCaseHelper(const Instruction& instruction, size_t index,
1292                                          bool is_last_case, const SwitchTable& table,
1293                                          HInstruction* value, int32_t case_value_int,
1294                                          int32_t target_offset, uint32_t dex_pc) {
1295  HBasicBlock* case_target = FindBlockStartingAt(dex_pc + target_offset);
1296  DCHECK(case_target != nullptr);
1297  PotentiallyAddSuspendCheck(case_target, dex_pc);
1298
1299  // The current case's value.
1300  HInstruction* this_case_value = graph_->GetIntConstant(case_value_int);
1301
1302  // Compare value and this_case_value.
1303  HEqual* comparison = new (arena_) HEqual(value, this_case_value);
1304  current_block_->AddInstruction(comparison);
1305  HInstruction* ifinst = new (arena_) HIf(comparison);
1306  current_block_->AddInstruction(ifinst);
1307
1308  // Case hit: use the target offset to determine where to go.
1309  current_block_->AddSuccessor(case_target);
1310
1311  // Case miss: go to the next case (or default fall-through).
1312  // When there is a next case, we use the block stored with the table offset representing this
1313  // case (that is where we registered them in ComputeBranchTargets).
1314  // When there is no next case, we use the following instruction.
1315  // TODO: Find a good way to peel the last iteration to avoid conditional, but still have re-use.
1316  if (!is_last_case) {
1317    HBasicBlock* next_case_target = FindBlockStartingAt(table.GetDexPcForIndex(index));
1318    DCHECK(next_case_target != nullptr);
1319    current_block_->AddSuccessor(next_case_target);
1320
1321    // Need to manually add the block, as there is no dex-pc transition for the cases.
1322    graph_->AddBlock(next_case_target);
1323
1324    current_block_ = next_case_target;
1325  } else {
1326    HBasicBlock* default_target = FindBlockStartingAt(dex_pc + instruction.SizeInCodeUnits());
1327    DCHECK(default_target != nullptr);
1328    current_block_->AddSuccessor(default_target);
1329    current_block_ = nullptr;
1330  }
1331}
1332
1333void HGraphBuilder::PotentiallyAddSuspendCheck(HBasicBlock* target, uint32_t dex_pc) {
1334  int32_t target_offset = target->GetDexPc() - dex_pc;
1335  if (target_offset <= 0) {
1336    // DX generates back edges to the first encountered return. We can save
1337    // time of later passes by not adding redundant suspend checks.
1338    HInstruction* last_in_target = target->GetLastInstruction();
1339    if (last_in_target != nullptr &&
1340        (last_in_target->IsReturn() || last_in_target->IsReturnVoid())) {
1341      return;
1342    }
1343
1344    // Add a suspend check to backward branches which may potentially loop. We
1345    // can remove them after we recognize loops in the graph.
1346    current_block_->AddInstruction(new (arena_) HSuspendCheck(dex_pc));
1347  }
1348}
1349
1350bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32_t dex_pc) {
1351  if (current_block_ == nullptr) {
1352    return true;  // Dead code
1353  }
1354
1355  switch (instruction.Opcode()) {
1356    case Instruction::CONST_4: {
1357      int32_t register_index = instruction.VRegA();
1358      HIntConstant* constant = graph_->GetIntConstant(instruction.VRegB_11n());
1359      UpdateLocal(register_index, constant);
1360      break;
1361    }
1362
1363    case Instruction::CONST_16: {
1364      int32_t register_index = instruction.VRegA();
1365      HIntConstant* constant = graph_->GetIntConstant(instruction.VRegB_21s());
1366      UpdateLocal(register_index, constant);
1367      break;
1368    }
1369
1370    case Instruction::CONST: {
1371      int32_t register_index = instruction.VRegA();
1372      HIntConstant* constant = graph_->GetIntConstant(instruction.VRegB_31i());
1373      UpdateLocal(register_index, constant);
1374      break;
1375    }
1376
1377    case Instruction::CONST_HIGH16: {
1378      int32_t register_index = instruction.VRegA();
1379      HIntConstant* constant = graph_->GetIntConstant(instruction.VRegB_21h() << 16);
1380      UpdateLocal(register_index, constant);
1381      break;
1382    }
1383
1384    case Instruction::CONST_WIDE_16: {
1385      int32_t register_index = instruction.VRegA();
1386      // Get 16 bits of constant value, sign extended to 64 bits.
1387      int64_t value = instruction.VRegB_21s();
1388      value <<= 48;
1389      value >>= 48;
1390      HLongConstant* constant = graph_->GetLongConstant(value);
1391      UpdateLocal(register_index, constant);
1392      break;
1393    }
1394
1395    case Instruction::CONST_WIDE_32: {
1396      int32_t register_index = instruction.VRegA();
1397      // Get 32 bits of constant value, sign extended to 64 bits.
1398      int64_t value = instruction.VRegB_31i();
1399      value <<= 32;
1400      value >>= 32;
1401      HLongConstant* constant = graph_->GetLongConstant(value);
1402      UpdateLocal(register_index, constant);
1403      break;
1404    }
1405
1406    case Instruction::CONST_WIDE: {
1407      int32_t register_index = instruction.VRegA();
1408      HLongConstant* constant = graph_->GetLongConstant(instruction.VRegB_51l());
1409      UpdateLocal(register_index, constant);
1410      break;
1411    }
1412
1413    case Instruction::CONST_WIDE_HIGH16: {
1414      int32_t register_index = instruction.VRegA();
1415      int64_t value = static_cast<int64_t>(instruction.VRegB_21h()) << 48;
1416      HLongConstant* constant = graph_->GetLongConstant(value);
1417      UpdateLocal(register_index, constant);
1418      break;
1419    }
1420
1421    // Note that the SSA building will refine the types.
1422    case Instruction::MOVE:
1423    case Instruction::MOVE_FROM16:
1424    case Instruction::MOVE_16: {
1425      HInstruction* value = LoadLocal(instruction.VRegB(), Primitive::kPrimInt);
1426      UpdateLocal(instruction.VRegA(), value);
1427      break;
1428    }
1429
1430    // Note that the SSA building will refine the types.
1431    case Instruction::MOVE_WIDE:
1432    case Instruction::MOVE_WIDE_FROM16:
1433    case Instruction::MOVE_WIDE_16: {
1434      HInstruction* value = LoadLocal(instruction.VRegB(), Primitive::kPrimLong);
1435      UpdateLocal(instruction.VRegA(), value);
1436      break;
1437    }
1438
1439    case Instruction::MOVE_OBJECT:
1440    case Instruction::MOVE_OBJECT_16:
1441    case Instruction::MOVE_OBJECT_FROM16: {
1442      HInstruction* value = LoadLocal(instruction.VRegB(), Primitive::kPrimNot);
1443      UpdateLocal(instruction.VRegA(), value);
1444      break;
1445    }
1446
1447    case Instruction::RETURN_VOID: {
1448      BuildReturn(instruction, Primitive::kPrimVoid);
1449      break;
1450    }
1451
1452#define IF_XX(comparison, cond) \
1453    case Instruction::IF_##cond: If_22t<comparison>(instruction, dex_pc); break; \
1454    case Instruction::IF_##cond##Z: If_21t<comparison>(instruction, dex_pc); break
1455
1456    IF_XX(HEqual, EQ);
1457    IF_XX(HNotEqual, NE);
1458    IF_XX(HLessThan, LT);
1459    IF_XX(HLessThanOrEqual, LE);
1460    IF_XX(HGreaterThan, GT);
1461    IF_XX(HGreaterThanOrEqual, GE);
1462
1463    case Instruction::GOTO:
1464    case Instruction::GOTO_16:
1465    case Instruction::GOTO_32: {
1466      int32_t offset = instruction.GetTargetOffset();
1467      HBasicBlock* target = FindBlockStartingAt(offset + dex_pc);
1468      DCHECK(target != nullptr);
1469      PotentiallyAddSuspendCheck(target, dex_pc);
1470      current_block_->AddInstruction(new (arena_) HGoto());
1471      current_block_->AddSuccessor(target);
1472      current_block_ = nullptr;
1473      break;
1474    }
1475
1476    case Instruction::RETURN: {
1477      BuildReturn(instruction, return_type_);
1478      break;
1479    }
1480
1481    case Instruction::RETURN_OBJECT: {
1482      BuildReturn(instruction, return_type_);
1483      break;
1484    }
1485
1486    case Instruction::RETURN_WIDE: {
1487      BuildReturn(instruction, return_type_);
1488      break;
1489    }
1490
1491    case Instruction::INVOKE_DIRECT:
1492    case Instruction::INVOKE_INTERFACE:
1493    case Instruction::INVOKE_STATIC:
1494    case Instruction::INVOKE_SUPER:
1495    case Instruction::INVOKE_VIRTUAL: {
1496      uint32_t method_idx = instruction.VRegB_35c();
1497      uint32_t number_of_vreg_arguments = instruction.VRegA_35c();
1498      uint32_t args[5];
1499      instruction.GetVarArgs(args);
1500      if (!BuildInvoke(instruction, dex_pc, method_idx,
1501                       number_of_vreg_arguments, false, args, -1)) {
1502        return false;
1503      }
1504      break;
1505    }
1506
1507    case Instruction::INVOKE_DIRECT_RANGE:
1508    case Instruction::INVOKE_INTERFACE_RANGE:
1509    case Instruction::INVOKE_STATIC_RANGE:
1510    case Instruction::INVOKE_SUPER_RANGE:
1511    case Instruction::INVOKE_VIRTUAL_RANGE: {
1512      uint32_t method_idx = instruction.VRegB_3rc();
1513      uint32_t number_of_vreg_arguments = instruction.VRegA_3rc();
1514      uint32_t register_index = instruction.VRegC();
1515      if (!BuildInvoke(instruction, dex_pc, method_idx,
1516                       number_of_vreg_arguments, true, nullptr, register_index)) {
1517        return false;
1518      }
1519      break;
1520    }
1521
1522    case Instruction::NEG_INT: {
1523      Unop_12x<HNeg>(instruction, Primitive::kPrimInt);
1524      break;
1525    }
1526
1527    case Instruction::NEG_LONG: {
1528      Unop_12x<HNeg>(instruction, Primitive::kPrimLong);
1529      break;
1530    }
1531
1532    case Instruction::NEG_FLOAT: {
1533      Unop_12x<HNeg>(instruction, Primitive::kPrimFloat);
1534      break;
1535    }
1536
1537    case Instruction::NEG_DOUBLE: {
1538      Unop_12x<HNeg>(instruction, Primitive::kPrimDouble);
1539      break;
1540    }
1541
1542    case Instruction::NOT_INT: {
1543      Unop_12x<HNot>(instruction, Primitive::kPrimInt);
1544      break;
1545    }
1546
1547    case Instruction::NOT_LONG: {
1548      Unop_12x<HNot>(instruction, Primitive::kPrimLong);
1549      break;
1550    }
1551
1552    case Instruction::INT_TO_LONG: {
1553      Conversion_12x(instruction, Primitive::kPrimInt, Primitive::kPrimLong, dex_pc);
1554      break;
1555    }
1556
1557    case Instruction::INT_TO_FLOAT: {
1558      Conversion_12x(instruction, Primitive::kPrimInt, Primitive::kPrimFloat, dex_pc);
1559      break;
1560    }
1561
1562    case Instruction::INT_TO_DOUBLE: {
1563      Conversion_12x(instruction, Primitive::kPrimInt, Primitive::kPrimDouble, dex_pc);
1564      break;
1565    }
1566
1567    case Instruction::LONG_TO_INT: {
1568      Conversion_12x(instruction, Primitive::kPrimLong, Primitive::kPrimInt, dex_pc);
1569      break;
1570    }
1571
1572    case Instruction::LONG_TO_FLOAT: {
1573      Conversion_12x(instruction, Primitive::kPrimLong, Primitive::kPrimFloat, dex_pc);
1574      break;
1575    }
1576
1577    case Instruction::LONG_TO_DOUBLE: {
1578      Conversion_12x(instruction, Primitive::kPrimLong, Primitive::kPrimDouble, dex_pc);
1579      break;
1580    }
1581
1582    case Instruction::FLOAT_TO_INT: {
1583      Conversion_12x(instruction, Primitive::kPrimFloat, Primitive::kPrimInt, dex_pc);
1584      break;
1585    }
1586
1587    case Instruction::FLOAT_TO_LONG: {
1588      Conversion_12x(instruction, Primitive::kPrimFloat, Primitive::kPrimLong, dex_pc);
1589      break;
1590    }
1591
1592    case Instruction::FLOAT_TO_DOUBLE: {
1593      Conversion_12x(instruction, Primitive::kPrimFloat, Primitive::kPrimDouble, dex_pc);
1594      break;
1595    }
1596
1597    case Instruction::DOUBLE_TO_INT: {
1598      Conversion_12x(instruction, Primitive::kPrimDouble, Primitive::kPrimInt, dex_pc);
1599      break;
1600    }
1601
1602    case Instruction::DOUBLE_TO_LONG: {
1603      Conversion_12x(instruction, Primitive::kPrimDouble, Primitive::kPrimLong, dex_pc);
1604      break;
1605    }
1606
1607    case Instruction::DOUBLE_TO_FLOAT: {
1608      Conversion_12x(instruction, Primitive::kPrimDouble, Primitive::kPrimFloat, dex_pc);
1609      break;
1610    }
1611
1612    case Instruction::INT_TO_BYTE: {
1613      Conversion_12x(instruction, Primitive::kPrimInt, Primitive::kPrimByte, dex_pc);
1614      break;
1615    }
1616
1617    case Instruction::INT_TO_SHORT: {
1618      Conversion_12x(instruction, Primitive::kPrimInt, Primitive::kPrimShort, dex_pc);
1619      break;
1620    }
1621
1622    case Instruction::INT_TO_CHAR: {
1623      Conversion_12x(instruction, Primitive::kPrimInt, Primitive::kPrimChar, dex_pc);
1624      break;
1625    }
1626
1627    case Instruction::ADD_INT: {
1628      Binop_23x<HAdd>(instruction, Primitive::kPrimInt);
1629      break;
1630    }
1631
1632    case Instruction::ADD_LONG: {
1633      Binop_23x<HAdd>(instruction, Primitive::kPrimLong);
1634      break;
1635    }
1636
1637    case Instruction::ADD_DOUBLE: {
1638      Binop_23x<HAdd>(instruction, Primitive::kPrimDouble);
1639      break;
1640    }
1641
1642    case Instruction::ADD_FLOAT: {
1643      Binop_23x<HAdd>(instruction, Primitive::kPrimFloat);
1644      break;
1645    }
1646
1647    case Instruction::SUB_INT: {
1648      Binop_23x<HSub>(instruction, Primitive::kPrimInt);
1649      break;
1650    }
1651
1652    case Instruction::SUB_LONG: {
1653      Binop_23x<HSub>(instruction, Primitive::kPrimLong);
1654      break;
1655    }
1656
1657    case Instruction::SUB_FLOAT: {
1658      Binop_23x<HSub>(instruction, Primitive::kPrimFloat);
1659      break;
1660    }
1661
1662    case Instruction::SUB_DOUBLE: {
1663      Binop_23x<HSub>(instruction, Primitive::kPrimDouble);
1664      break;
1665    }
1666
1667    case Instruction::ADD_INT_2ADDR: {
1668      Binop_12x<HAdd>(instruction, Primitive::kPrimInt);
1669      break;
1670    }
1671
1672    case Instruction::MUL_INT: {
1673      Binop_23x<HMul>(instruction, Primitive::kPrimInt);
1674      break;
1675    }
1676
1677    case Instruction::MUL_LONG: {
1678      Binop_23x<HMul>(instruction, Primitive::kPrimLong);
1679      break;
1680    }
1681
1682    case Instruction::MUL_FLOAT: {
1683      Binop_23x<HMul>(instruction, Primitive::kPrimFloat);
1684      break;
1685    }
1686
1687    case Instruction::MUL_DOUBLE: {
1688      Binop_23x<HMul>(instruction, Primitive::kPrimDouble);
1689      break;
1690    }
1691
1692    case Instruction::DIV_INT: {
1693      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(),
1694                         dex_pc, Primitive::kPrimInt, false, true);
1695      break;
1696    }
1697
1698    case Instruction::DIV_LONG: {
1699      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(),
1700                         dex_pc, Primitive::kPrimLong, false, true);
1701      break;
1702    }
1703
1704    case Instruction::DIV_FLOAT: {
1705      Binop_23x<HDiv>(instruction, Primitive::kPrimFloat, dex_pc);
1706      break;
1707    }
1708
1709    case Instruction::DIV_DOUBLE: {
1710      Binop_23x<HDiv>(instruction, Primitive::kPrimDouble, dex_pc);
1711      break;
1712    }
1713
1714    case Instruction::REM_INT: {
1715      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(),
1716                         dex_pc, Primitive::kPrimInt, false, false);
1717      break;
1718    }
1719
1720    case Instruction::REM_LONG: {
1721      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(),
1722                         dex_pc, Primitive::kPrimLong, false, false);
1723      break;
1724    }
1725
1726    case Instruction::REM_FLOAT: {
1727      Binop_23x<HRem>(instruction, Primitive::kPrimFloat, dex_pc);
1728      break;
1729    }
1730
1731    case Instruction::REM_DOUBLE: {
1732      Binop_23x<HRem>(instruction, Primitive::kPrimDouble, dex_pc);
1733      break;
1734    }
1735
1736    case Instruction::AND_INT: {
1737      Binop_23x<HAnd>(instruction, Primitive::kPrimInt);
1738      break;
1739    }
1740
1741    case Instruction::AND_LONG: {
1742      Binop_23x<HAnd>(instruction, Primitive::kPrimLong);
1743      break;
1744    }
1745
1746    case Instruction::SHL_INT: {
1747      Binop_23x_shift<HShl>(instruction, Primitive::kPrimInt);
1748      break;
1749    }
1750
1751    case Instruction::SHL_LONG: {
1752      Binop_23x_shift<HShl>(instruction, Primitive::kPrimLong);
1753      break;
1754    }
1755
1756    case Instruction::SHR_INT: {
1757      Binop_23x_shift<HShr>(instruction, Primitive::kPrimInt);
1758      break;
1759    }
1760
1761    case Instruction::SHR_LONG: {
1762      Binop_23x_shift<HShr>(instruction, Primitive::kPrimLong);
1763      break;
1764    }
1765
1766    case Instruction::USHR_INT: {
1767      Binop_23x_shift<HUShr>(instruction, Primitive::kPrimInt);
1768      break;
1769    }
1770
1771    case Instruction::USHR_LONG: {
1772      Binop_23x_shift<HUShr>(instruction, Primitive::kPrimLong);
1773      break;
1774    }
1775
1776    case Instruction::OR_INT: {
1777      Binop_23x<HOr>(instruction, Primitive::kPrimInt);
1778      break;
1779    }
1780
1781    case Instruction::OR_LONG: {
1782      Binop_23x<HOr>(instruction, Primitive::kPrimLong);
1783      break;
1784    }
1785
1786    case Instruction::XOR_INT: {
1787      Binop_23x<HXor>(instruction, Primitive::kPrimInt);
1788      break;
1789    }
1790
1791    case Instruction::XOR_LONG: {
1792      Binop_23x<HXor>(instruction, Primitive::kPrimLong);
1793      break;
1794    }
1795
1796    case Instruction::ADD_LONG_2ADDR: {
1797      Binop_12x<HAdd>(instruction, Primitive::kPrimLong);
1798      break;
1799    }
1800
1801    case Instruction::ADD_DOUBLE_2ADDR: {
1802      Binop_12x<HAdd>(instruction, Primitive::kPrimDouble);
1803      break;
1804    }
1805
1806    case Instruction::ADD_FLOAT_2ADDR: {
1807      Binop_12x<HAdd>(instruction, Primitive::kPrimFloat);
1808      break;
1809    }
1810
1811    case Instruction::SUB_INT_2ADDR: {
1812      Binop_12x<HSub>(instruction, Primitive::kPrimInt);
1813      break;
1814    }
1815
1816    case Instruction::SUB_LONG_2ADDR: {
1817      Binop_12x<HSub>(instruction, Primitive::kPrimLong);
1818      break;
1819    }
1820
1821    case Instruction::SUB_FLOAT_2ADDR: {
1822      Binop_12x<HSub>(instruction, Primitive::kPrimFloat);
1823      break;
1824    }
1825
1826    case Instruction::SUB_DOUBLE_2ADDR: {
1827      Binop_12x<HSub>(instruction, Primitive::kPrimDouble);
1828      break;
1829    }
1830
1831    case Instruction::MUL_INT_2ADDR: {
1832      Binop_12x<HMul>(instruction, Primitive::kPrimInt);
1833      break;
1834    }
1835
1836    case Instruction::MUL_LONG_2ADDR: {
1837      Binop_12x<HMul>(instruction, Primitive::kPrimLong);
1838      break;
1839    }
1840
1841    case Instruction::MUL_FLOAT_2ADDR: {
1842      Binop_12x<HMul>(instruction, Primitive::kPrimFloat);
1843      break;
1844    }
1845
1846    case Instruction::MUL_DOUBLE_2ADDR: {
1847      Binop_12x<HMul>(instruction, Primitive::kPrimDouble);
1848      break;
1849    }
1850
1851    case Instruction::DIV_INT_2ADDR: {
1852      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegA(), instruction.VRegB(),
1853                         dex_pc, Primitive::kPrimInt, false, true);
1854      break;
1855    }
1856
1857    case Instruction::DIV_LONG_2ADDR: {
1858      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegA(), instruction.VRegB(),
1859                         dex_pc, Primitive::kPrimLong, false, true);
1860      break;
1861    }
1862
1863    case Instruction::REM_INT_2ADDR: {
1864      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegA(), instruction.VRegB(),
1865                         dex_pc, Primitive::kPrimInt, false, false);
1866      break;
1867    }
1868
1869    case Instruction::REM_LONG_2ADDR: {
1870      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegA(), instruction.VRegB(),
1871                         dex_pc, Primitive::kPrimLong, false, false);
1872      break;
1873    }
1874
1875    case Instruction::REM_FLOAT_2ADDR: {
1876      Binop_12x<HRem>(instruction, Primitive::kPrimFloat, dex_pc);
1877      break;
1878    }
1879
1880    case Instruction::REM_DOUBLE_2ADDR: {
1881      Binop_12x<HRem>(instruction, Primitive::kPrimDouble, dex_pc);
1882      break;
1883    }
1884
1885    case Instruction::SHL_INT_2ADDR: {
1886      Binop_12x_shift<HShl>(instruction, Primitive::kPrimInt);
1887      break;
1888    }
1889
1890    case Instruction::SHL_LONG_2ADDR: {
1891      Binop_12x_shift<HShl>(instruction, Primitive::kPrimLong);
1892      break;
1893    }
1894
1895    case Instruction::SHR_INT_2ADDR: {
1896      Binop_12x_shift<HShr>(instruction, Primitive::kPrimInt);
1897      break;
1898    }
1899
1900    case Instruction::SHR_LONG_2ADDR: {
1901      Binop_12x_shift<HShr>(instruction, Primitive::kPrimLong);
1902      break;
1903    }
1904
1905    case Instruction::USHR_INT_2ADDR: {
1906      Binop_12x_shift<HUShr>(instruction, Primitive::kPrimInt);
1907      break;
1908    }
1909
1910    case Instruction::USHR_LONG_2ADDR: {
1911      Binop_12x_shift<HUShr>(instruction, Primitive::kPrimLong);
1912      break;
1913    }
1914
1915    case Instruction::DIV_FLOAT_2ADDR: {
1916      Binop_12x<HDiv>(instruction, Primitive::kPrimFloat, dex_pc);
1917      break;
1918    }
1919
1920    case Instruction::DIV_DOUBLE_2ADDR: {
1921      Binop_12x<HDiv>(instruction, Primitive::kPrimDouble, dex_pc);
1922      break;
1923    }
1924
1925    case Instruction::AND_INT_2ADDR: {
1926      Binop_12x<HAnd>(instruction, Primitive::kPrimInt);
1927      break;
1928    }
1929
1930    case Instruction::AND_LONG_2ADDR: {
1931      Binop_12x<HAnd>(instruction, Primitive::kPrimLong);
1932      break;
1933    }
1934
1935    case Instruction::OR_INT_2ADDR: {
1936      Binop_12x<HOr>(instruction, Primitive::kPrimInt);
1937      break;
1938    }
1939
1940    case Instruction::OR_LONG_2ADDR: {
1941      Binop_12x<HOr>(instruction, Primitive::kPrimLong);
1942      break;
1943    }
1944
1945    case Instruction::XOR_INT_2ADDR: {
1946      Binop_12x<HXor>(instruction, Primitive::kPrimInt);
1947      break;
1948    }
1949
1950    case Instruction::XOR_LONG_2ADDR: {
1951      Binop_12x<HXor>(instruction, Primitive::kPrimLong);
1952      break;
1953    }
1954
1955    case Instruction::ADD_INT_LIT16: {
1956      Binop_22s<HAdd>(instruction, false);
1957      break;
1958    }
1959
1960    case Instruction::AND_INT_LIT16: {
1961      Binop_22s<HAnd>(instruction, false);
1962      break;
1963    }
1964
1965    case Instruction::OR_INT_LIT16: {
1966      Binop_22s<HOr>(instruction, false);
1967      break;
1968    }
1969
1970    case Instruction::XOR_INT_LIT16: {
1971      Binop_22s<HXor>(instruction, false);
1972      break;
1973    }
1974
1975    case Instruction::RSUB_INT: {
1976      Binop_22s<HSub>(instruction, true);
1977      break;
1978    }
1979
1980    case Instruction::MUL_INT_LIT16: {
1981      Binop_22s<HMul>(instruction, false);
1982      break;
1983    }
1984
1985    case Instruction::ADD_INT_LIT8: {
1986      Binop_22b<HAdd>(instruction, false);
1987      break;
1988    }
1989
1990    case Instruction::AND_INT_LIT8: {
1991      Binop_22b<HAnd>(instruction, false);
1992      break;
1993    }
1994
1995    case Instruction::OR_INT_LIT8: {
1996      Binop_22b<HOr>(instruction, false);
1997      break;
1998    }
1999
2000    case Instruction::XOR_INT_LIT8: {
2001      Binop_22b<HXor>(instruction, false);
2002      break;
2003    }
2004
2005    case Instruction::RSUB_INT_LIT8: {
2006      Binop_22b<HSub>(instruction, true);
2007      break;
2008    }
2009
2010    case Instruction::MUL_INT_LIT8: {
2011      Binop_22b<HMul>(instruction, false);
2012      break;
2013    }
2014
2015    case Instruction::DIV_INT_LIT16:
2016    case Instruction::DIV_INT_LIT8: {
2017      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(),
2018                         dex_pc, Primitive::kPrimInt, true, true);
2019      break;
2020    }
2021
2022    case Instruction::REM_INT_LIT16:
2023    case Instruction::REM_INT_LIT8: {
2024      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(),
2025                         dex_pc, Primitive::kPrimInt, true, false);
2026      break;
2027    }
2028
2029    case Instruction::SHL_INT_LIT8: {
2030      Binop_22b<HShl>(instruction, false);
2031      break;
2032    }
2033
2034    case Instruction::SHR_INT_LIT8: {
2035      Binop_22b<HShr>(instruction, false);
2036      break;
2037    }
2038
2039    case Instruction::USHR_INT_LIT8: {
2040      Binop_22b<HUShr>(instruction, false);
2041      break;
2042    }
2043
2044    case Instruction::NEW_INSTANCE: {
2045      uint16_t type_index = instruction.VRegB_21c();
2046      if (compiler_driver_->IsStringTypeIndex(type_index, dex_file_)) {
2047        // Turn new-instance of string into a const 0.
2048        int32_t register_index = instruction.VRegA();
2049        HNullConstant* constant = graph_->GetNullConstant();
2050        UpdateLocal(register_index, constant);
2051      } else {
2052        QuickEntrypointEnum entrypoint = NeedsAccessCheck(type_index)
2053            ? kQuickAllocObjectWithAccessCheck
2054            : kQuickAllocObject;
2055
2056        current_block_->AddInstruction(new (arena_) HNewInstance(
2057            graph_->GetCurrentMethod(),
2058            dex_pc,
2059            type_index,
2060            *dex_compilation_unit_->GetDexFile(),
2061            entrypoint));
2062        UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction());
2063      }
2064      break;
2065    }
2066
2067    case Instruction::NEW_ARRAY: {
2068      uint16_t type_index = instruction.VRegC_22c();
2069      HInstruction* length = LoadLocal(instruction.VRegB_22c(), Primitive::kPrimInt);
2070      QuickEntrypointEnum entrypoint = NeedsAccessCheck(type_index)
2071          ? kQuickAllocArrayWithAccessCheck
2072          : kQuickAllocArray;
2073      current_block_->AddInstruction(new (arena_) HNewArray(length,
2074                                                            graph_->GetCurrentMethod(),
2075                                                            dex_pc,
2076                                                            type_index,
2077                                                            *dex_compilation_unit_->GetDexFile(),
2078                                                            entrypoint));
2079      UpdateLocal(instruction.VRegA_22c(), current_block_->GetLastInstruction());
2080      break;
2081    }
2082
2083    case Instruction::FILLED_NEW_ARRAY: {
2084      uint32_t number_of_vreg_arguments = instruction.VRegA_35c();
2085      uint32_t type_index = instruction.VRegB_35c();
2086      uint32_t args[5];
2087      instruction.GetVarArgs(args);
2088      BuildFilledNewArray(dex_pc, type_index, number_of_vreg_arguments, false, args, 0);
2089      break;
2090    }
2091
2092    case Instruction::FILLED_NEW_ARRAY_RANGE: {
2093      uint32_t number_of_vreg_arguments = instruction.VRegA_3rc();
2094      uint32_t type_index = instruction.VRegB_3rc();
2095      uint32_t register_index = instruction.VRegC_3rc();
2096      BuildFilledNewArray(
2097          dex_pc, type_index, number_of_vreg_arguments, true, nullptr, register_index);
2098      break;
2099    }
2100
2101    case Instruction::FILL_ARRAY_DATA: {
2102      BuildFillArrayData(instruction, dex_pc);
2103      break;
2104    }
2105
2106    case Instruction::MOVE_RESULT:
2107    case Instruction::MOVE_RESULT_WIDE:
2108    case Instruction::MOVE_RESULT_OBJECT:
2109      UpdateLocal(instruction.VRegA(), latest_result_);
2110      latest_result_ = nullptr;
2111      break;
2112
2113    case Instruction::CMP_LONG: {
2114      Binop_23x_cmp(instruction, Primitive::kPrimLong, HCompare::kNoBias);
2115      break;
2116    }
2117
2118    case Instruction::CMPG_FLOAT: {
2119      Binop_23x_cmp(instruction, Primitive::kPrimFloat, HCompare::kGtBias);
2120      break;
2121    }
2122
2123    case Instruction::CMPG_DOUBLE: {
2124      Binop_23x_cmp(instruction, Primitive::kPrimDouble, HCompare::kGtBias);
2125      break;
2126    }
2127
2128    case Instruction::CMPL_FLOAT: {
2129      Binop_23x_cmp(instruction, Primitive::kPrimFloat, HCompare::kLtBias);
2130      break;
2131    }
2132
2133    case Instruction::CMPL_DOUBLE: {
2134      Binop_23x_cmp(instruction, Primitive::kPrimDouble, HCompare::kLtBias);
2135      break;
2136    }
2137
2138    case Instruction::NOP:
2139      break;
2140
2141    case Instruction::IGET:
2142    case Instruction::IGET_WIDE:
2143    case Instruction::IGET_OBJECT:
2144    case Instruction::IGET_BOOLEAN:
2145    case Instruction::IGET_BYTE:
2146    case Instruction::IGET_CHAR:
2147    case Instruction::IGET_SHORT: {
2148      if (!BuildInstanceFieldAccess(instruction, dex_pc, false)) {
2149        return false;
2150      }
2151      break;
2152    }
2153
2154    case Instruction::IPUT:
2155    case Instruction::IPUT_WIDE:
2156    case Instruction::IPUT_OBJECT:
2157    case Instruction::IPUT_BOOLEAN:
2158    case Instruction::IPUT_BYTE:
2159    case Instruction::IPUT_CHAR:
2160    case Instruction::IPUT_SHORT: {
2161      if (!BuildInstanceFieldAccess(instruction, dex_pc, true)) {
2162        return false;
2163      }
2164      break;
2165    }
2166
2167    case Instruction::SGET:
2168    case Instruction::SGET_WIDE:
2169    case Instruction::SGET_OBJECT:
2170    case Instruction::SGET_BOOLEAN:
2171    case Instruction::SGET_BYTE:
2172    case Instruction::SGET_CHAR:
2173    case Instruction::SGET_SHORT: {
2174      if (!BuildStaticFieldAccess(instruction, dex_pc, false)) {
2175        return false;
2176      }
2177      break;
2178    }
2179
2180    case Instruction::SPUT:
2181    case Instruction::SPUT_WIDE:
2182    case Instruction::SPUT_OBJECT:
2183    case Instruction::SPUT_BOOLEAN:
2184    case Instruction::SPUT_BYTE:
2185    case Instruction::SPUT_CHAR:
2186    case Instruction::SPUT_SHORT: {
2187      if (!BuildStaticFieldAccess(instruction, dex_pc, true)) {
2188        return false;
2189      }
2190      break;
2191    }
2192
2193#define ARRAY_XX(kind, anticipated_type)                                          \
2194    case Instruction::AGET##kind: {                                               \
2195      BuildArrayAccess(instruction, dex_pc, false, anticipated_type);         \
2196      break;                                                                      \
2197    }                                                                             \
2198    case Instruction::APUT##kind: {                                               \
2199      BuildArrayAccess(instruction, dex_pc, true, anticipated_type);          \
2200      break;                                                                      \
2201    }
2202
2203    ARRAY_XX(, Primitive::kPrimInt);
2204    ARRAY_XX(_WIDE, Primitive::kPrimLong);
2205    ARRAY_XX(_OBJECT, Primitive::kPrimNot);
2206    ARRAY_XX(_BOOLEAN, Primitive::kPrimBoolean);
2207    ARRAY_XX(_BYTE, Primitive::kPrimByte);
2208    ARRAY_XX(_CHAR, Primitive::kPrimChar);
2209    ARRAY_XX(_SHORT, Primitive::kPrimShort);
2210
2211    case Instruction::ARRAY_LENGTH: {
2212      HInstruction* object = LoadLocal(instruction.VRegB_12x(), Primitive::kPrimNot);
2213      // No need for a temporary for the null check, it is the only input of the following
2214      // instruction.
2215      object = new (arena_) HNullCheck(object, dex_pc);
2216      current_block_->AddInstruction(object);
2217      current_block_->AddInstruction(new (arena_) HArrayLength(object));
2218      UpdateLocal(instruction.VRegA_12x(), current_block_->GetLastInstruction());
2219      break;
2220    }
2221
2222    case Instruction::CONST_STRING: {
2223      current_block_->AddInstruction(
2224          new (arena_) HLoadString(graph_->GetCurrentMethod(), instruction.VRegB_21c(), dex_pc));
2225      UpdateLocal(instruction.VRegA_21c(), current_block_->GetLastInstruction());
2226      break;
2227    }
2228
2229    case Instruction::CONST_STRING_JUMBO: {
2230      current_block_->AddInstruction(
2231          new (arena_) HLoadString(graph_->GetCurrentMethod(), instruction.VRegB_31c(), dex_pc));
2232      UpdateLocal(instruction.VRegA_31c(), current_block_->GetLastInstruction());
2233      break;
2234    }
2235
2236    case Instruction::CONST_CLASS: {
2237      uint16_t type_index = instruction.VRegB_21c();
2238      bool type_known_final;
2239      bool type_known_abstract;
2240      bool dont_use_is_referrers_class;
2241      // `CanAccessTypeWithoutChecks` will tell whether the method being
2242      // built is trying to access its own class, so that the generated
2243      // code can optimize for this case. However, the optimization does not
2244      // work for inlining, so we use `IsOutermostCompilingClass` instead.
2245      bool can_access = compiler_driver_->CanAccessTypeWithoutChecks(
2246          dex_compilation_unit_->GetDexMethodIndex(), *dex_file_, type_index,
2247          &type_known_final, &type_known_abstract, &dont_use_is_referrers_class);
2248      if (!can_access) {
2249        MaybeRecordStat(MethodCompilationStat::kNotCompiledCantAccesType);
2250        return false;
2251      }
2252      current_block_->AddInstruction(new (arena_) HLoadClass(
2253          graph_->GetCurrentMethod(),
2254          type_index,
2255          *dex_compilation_unit_->GetDexFile(),
2256          IsOutermostCompilingClass(type_index),
2257          dex_pc));
2258      UpdateLocal(instruction.VRegA_21c(), current_block_->GetLastInstruction());
2259      break;
2260    }
2261
2262    case Instruction::MOVE_EXCEPTION: {
2263      current_block_->AddInstruction(new (arena_) HLoadException());
2264      UpdateLocal(instruction.VRegA_11x(), current_block_->GetLastInstruction());
2265      break;
2266    }
2267
2268    case Instruction::THROW: {
2269      HInstruction* exception = LoadLocal(instruction.VRegA_11x(), Primitive::kPrimNot);
2270      current_block_->AddInstruction(new (arena_) HThrow(exception, dex_pc));
2271      // A throw instruction must branch to the exit block.
2272      current_block_->AddSuccessor(exit_block_);
2273      // We finished building this block. Set the current block to null to avoid
2274      // adding dead instructions to it.
2275      current_block_ = nullptr;
2276      break;
2277    }
2278
2279    case Instruction::INSTANCE_OF: {
2280      uint8_t destination = instruction.VRegA_22c();
2281      uint8_t reference = instruction.VRegB_22c();
2282      uint16_t type_index = instruction.VRegC_22c();
2283      if (!BuildTypeCheck(instruction, destination, reference, type_index, dex_pc)) {
2284        return false;
2285      }
2286      break;
2287    }
2288
2289    case Instruction::CHECK_CAST: {
2290      uint8_t reference = instruction.VRegA_21c();
2291      uint16_t type_index = instruction.VRegB_21c();
2292      if (!BuildTypeCheck(instruction, -1, reference, type_index, dex_pc)) {
2293        return false;
2294      }
2295      break;
2296    }
2297
2298    case Instruction::MONITOR_ENTER: {
2299      current_block_->AddInstruction(new (arena_) HMonitorOperation(
2300          LoadLocal(instruction.VRegA_11x(), Primitive::kPrimNot),
2301          HMonitorOperation::kEnter,
2302          dex_pc));
2303      break;
2304    }
2305
2306    case Instruction::MONITOR_EXIT: {
2307      current_block_->AddInstruction(new (arena_) HMonitorOperation(
2308          LoadLocal(instruction.VRegA_11x(), Primitive::kPrimNot),
2309          HMonitorOperation::kExit,
2310          dex_pc));
2311      break;
2312    }
2313
2314    case Instruction::PACKED_SWITCH: {
2315      BuildPackedSwitch(instruction, dex_pc);
2316      break;
2317    }
2318
2319    case Instruction::SPARSE_SWITCH: {
2320      BuildSparseSwitch(instruction, dex_pc);
2321      break;
2322    }
2323
2324    default:
2325      VLOG(compiler) << "Did not compile "
2326                     << PrettyMethod(dex_compilation_unit_->GetDexMethodIndex(), *dex_file_)
2327                     << " because of unhandled instruction "
2328                     << instruction.Name();
2329      MaybeRecordStat(MethodCompilationStat::kNotCompiledUnhandledInstruction);
2330      return false;
2331  }
2332  return true;
2333}  // NOLINT(readability/fn_size)
2334
2335HLocal* HGraphBuilder::GetLocalAt(int register_index) const {
2336  return locals_.Get(register_index);
2337}
2338
2339void HGraphBuilder::UpdateLocal(int register_index, HInstruction* instruction) const {
2340  HLocal* local = GetLocalAt(register_index);
2341  current_block_->AddInstruction(new (arena_) HStoreLocal(local, instruction));
2342}
2343
2344HInstruction* HGraphBuilder::LoadLocal(int register_index, Primitive::Type type) const {
2345  HLocal* local = GetLocalAt(register_index);
2346  current_block_->AddInstruction(new (arena_) HLoadLocal(local, type));
2347  return current_block_->GetLastInstruction();
2348}
2349
2350}  // namespace art
2351