builder.cc revision 7b0e353b49ac3f464c662f20e20e240f0231afff 
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  size_t number_of_arguments = strlen(descriptor) - (is_instance_call ? 0 : 1);
607
608  MethodReference target_method(dex_file_, method_idx);
609  uintptr_t direct_code;
610  uintptr_t direct_method;
611  int table_index;
612  InvokeType optimized_invoke_type = invoke_type;
613
614  if (!compiler_driver_->ComputeInvokeInfo(dex_compilation_unit_, dex_pc, true, true,
615                                           &optimized_invoke_type, &target_method, &table_index,
616                                           &direct_code, &direct_method)) {
617    VLOG(compiler) << "Did not compile " << PrettyMethod(method_idx, *dex_file_)
618                   << " because a method call could not be resolved";
619    MaybeRecordStat(MethodCompilationStat::kNotCompiledUnresolvedMethod);
620    return false;
621  }
622  DCHECK(optimized_invoke_type != kSuper);
623
624  // By default, consider that the called method implicitly requires
625  // an initialization check of its declaring method.
626  HInvokeStaticOrDirect::ClinitCheckRequirement clinit_check_requirement =
627      HInvokeStaticOrDirect::ClinitCheckRequirement::kImplicit;
628  // Potential class initialization check, in the case of a static method call.
629  HClinitCheck* clinit_check = nullptr;
630  // Replace calls to String.<init> with StringFactory.
631  int32_t string_init_offset = 0;
632  bool is_string_init = compiler_driver_->IsStringInit(method_idx, dex_file_, &string_init_offset);
633  if (is_string_init) {
634    return_type = Primitive::kPrimNot;
635    is_instance_call = false;
636    number_of_arguments--;
637    invoke_type = kStatic;
638    optimized_invoke_type = kStatic;
639  }
640
641  HInvoke* invoke = nullptr;
642
643  if (optimized_invoke_type == kVirtual) {
644    invoke = new (arena_) HInvokeVirtual(
645        arena_, number_of_arguments, return_type, dex_pc, method_idx, table_index);
646  } else if (optimized_invoke_type == kInterface) {
647    invoke = new (arena_) HInvokeInterface(
648        arena_, number_of_arguments, return_type, dex_pc, method_idx, table_index);
649  } else {
650    DCHECK(optimized_invoke_type == kDirect || optimized_invoke_type == kStatic);
651    // Sharpening to kDirect only works if we compile PIC.
652    DCHECK((optimized_invoke_type == invoke_type) || (optimized_invoke_type != kDirect)
653           || compiler_driver_->GetCompilerOptions().GetCompilePic());
654    bool is_recursive =
655        (target_method.dex_method_index == outer_compilation_unit_->GetDexMethodIndex())
656        && (target_method.dex_file == outer_compilation_unit_->GetDexFile());
657
658    if (optimized_invoke_type == kStatic) {
659      ScopedObjectAccess soa(Thread::Current());
660      StackHandleScope<4> hs(soa.Self());
661      Handle<mirror::DexCache> dex_cache(hs.NewHandle(
662          dex_compilation_unit_->GetClassLinker()->FindDexCache(
663              *dex_compilation_unit_->GetDexFile())));
664      Handle<mirror::ClassLoader> class_loader(hs.NewHandle(
665          soa.Decode<mirror::ClassLoader*>(dex_compilation_unit_->GetClassLoader())));
666      ArtMethod* resolved_method = compiler_driver_->ResolveMethod(
667          soa, dex_cache, class_loader, dex_compilation_unit_, method_idx, optimized_invoke_type);
668
669      if (resolved_method == nullptr) {
670        MaybeRecordStat(MethodCompilationStat::kNotCompiledUnresolvedMethod);
671        return false;
672      }
673
674      const DexFile& outer_dex_file = *outer_compilation_unit_->GetDexFile();
675      Handle<mirror::DexCache> outer_dex_cache(hs.NewHandle(
676          outer_compilation_unit_->GetClassLinker()->FindDexCache(outer_dex_file)));
677      Handle<mirror::Class> referrer_class(hs.NewHandle(GetOutermostCompilingClass()));
678
679      // The index at which the method's class is stored in the DexCache's type array.
680      uint32_t storage_index = DexFile::kDexNoIndex;
681      bool is_referrer_class = (resolved_method->GetDeclaringClass() == referrer_class.Get());
682      if (is_referrer_class) {
683        storage_index = referrer_class->GetDexTypeIndex();
684      } else if (outer_dex_cache.Get() == dex_cache.Get()) {
685        // Get `storage_index` from IsClassOfStaticMethodAvailableToReferrer.
686        compiler_driver_->IsClassOfStaticMethodAvailableToReferrer(outer_dex_cache.Get(),
687                                                                   referrer_class.Get(),
688                                                                   resolved_method,
689                                                                   method_idx,
690                                                                   &storage_index);
691      }
692
693      if (referrer_class.Get()->IsSubClass(resolved_method->GetDeclaringClass())) {
694        // If the referrer class is the declaring class or a subclass
695        // of the declaring class, no class initialization is needed
696        // before the static method call.
697        clinit_check_requirement = HInvokeStaticOrDirect::ClinitCheckRequirement::kNone;
698      } else if (storage_index != DexFile::kDexNoIndex) {
699        // If the method's class type index is available, check
700        // whether we should add an explicit class initialization
701        // check for its declaring class before the static method call.
702
703        // TODO: find out why this check is needed.
704        bool is_in_dex_cache = compiler_driver_->CanAssumeTypeIsPresentInDexCache(
705            *outer_compilation_unit_->GetDexFile(), storage_index);
706        bool is_initialized =
707            resolved_method->GetDeclaringClass()->IsInitialized() && is_in_dex_cache;
708
709        if (is_initialized) {
710          clinit_check_requirement = HInvokeStaticOrDirect::ClinitCheckRequirement::kNone;
711        } else {
712          clinit_check_requirement = HInvokeStaticOrDirect::ClinitCheckRequirement::kExplicit;
713          HLoadClass* load_class = new (arena_) HLoadClass(
714              graph_->GetCurrentMethod(),
715              storage_index,
716              *dex_compilation_unit_->GetDexFile(),
717              is_referrer_class,
718              dex_pc);
719          current_block_->AddInstruction(load_class);
720          clinit_check = new (arena_) HClinitCheck(load_class, dex_pc);
721          current_block_->AddInstruction(clinit_check);
722        }
723      }
724    }
725
726    invoke = new (arena_) HInvokeStaticOrDirect(
727        arena_, number_of_arguments, return_type, dex_pc, target_method.dex_method_index,
728        is_recursive, string_init_offset, invoke_type, optimized_invoke_type,
729        clinit_check_requirement);
730  }
731
732  size_t start_index = 0;
733  Temporaries temps(graph_);
734  if (is_instance_call) {
735    HInstruction* arg = LoadLocal(is_range ? register_index : args[0], Primitive::kPrimNot);
736    HNullCheck* null_check = new (arena_) HNullCheck(arg, dex_pc);
737    current_block_->AddInstruction(null_check);
738    temps.Add(null_check);
739    invoke->SetArgumentAt(0, null_check);
740    start_index = 1;
741  }
742
743  uint32_t descriptor_index = 1;
744  uint32_t argument_index = start_index;
745  if (is_string_init) {
746    start_index = 1;
747  }
748  for (size_t i = start_index; i < number_of_vreg_arguments; i++, argument_index++) {
749    Primitive::Type type = Primitive::GetType(descriptor[descriptor_index++]);
750    bool is_wide = (type == Primitive::kPrimLong) || (type == Primitive::kPrimDouble);
751    if (!is_range && is_wide && args[i] + 1 != args[i + 1]) {
752      LOG(WARNING) << "Non sequential register pair in " << dex_compilation_unit_->GetSymbol()
753                   << " at " << dex_pc;
754      // We do not implement non sequential register pair.
755      MaybeRecordStat(MethodCompilationStat::kNotCompiledNonSequentialRegPair);
756      return false;
757    }
758    HInstruction* arg = LoadLocal(is_range ? register_index + i : args[i], type);
759    invoke->SetArgumentAt(argument_index, arg);
760    if (is_wide) {
761      i++;
762    }
763  }
764  DCHECK_EQ(argument_index, number_of_arguments);
765
766  if (invoke->IsInvokeStaticOrDirect()) {
767    invoke->SetArgumentAt(argument_index, graph_->GetCurrentMethod());
768    argument_index++;
769  }
770
771  if (clinit_check_requirement == HInvokeStaticOrDirect::ClinitCheckRequirement::kExplicit) {
772    // Add the class initialization check as last input of `invoke`.
773    DCHECK(clinit_check != nullptr);
774    invoke->SetArgumentAt(argument_index, clinit_check);
775  }
776
777  current_block_->AddInstruction(invoke);
778  latest_result_ = invoke;
779
780  // Add move-result for StringFactory method.
781  if (is_string_init) {
782    uint32_t orig_this_reg = is_range ? register_index : args[0];
783    const VerifiedMethod* verified_method =
784        compiler_driver_->GetVerifiedMethod(dex_file_, dex_compilation_unit_->GetDexMethodIndex());
785    if (verified_method == nullptr) {
786      LOG(WARNING) << "No verified method for method calling String.<init>: "
787                   << PrettyMethod(dex_compilation_unit_->GetDexMethodIndex(), *dex_file_);
788      return false;
789    }
790    const SafeMap<uint32_t, std::set<uint32_t>>& string_init_map =
791        verified_method->GetStringInitPcRegMap();
792    auto map_it = string_init_map.find(dex_pc);
793    if (map_it != string_init_map.end()) {
794      std::set<uint32_t> reg_set = map_it->second;
795      for (auto set_it = reg_set.begin(); set_it != reg_set.end(); ++set_it) {
796        UpdateLocal(*set_it, invoke);
797      }
798    }
799    UpdateLocal(orig_this_reg, invoke);
800  }
801  return true;
802}
803
804bool HGraphBuilder::BuildInstanceFieldAccess(const Instruction& instruction,
805                                             uint32_t dex_pc,
806                                             bool is_put) {
807  uint32_t source_or_dest_reg = instruction.VRegA_22c();
808  uint32_t obj_reg = instruction.VRegB_22c();
809  uint16_t field_index = instruction.VRegC_22c();
810
811  ScopedObjectAccess soa(Thread::Current());
812  ArtField* resolved_field =
813      compiler_driver_->ComputeInstanceFieldInfo(field_index, dex_compilation_unit_, is_put, soa);
814
815  if (resolved_field == nullptr) {
816    MaybeRecordStat(MethodCompilationStat::kNotCompiledUnresolvedField);
817    return false;
818  }
819
820  Primitive::Type field_type = resolved_field->GetTypeAsPrimitiveType();
821
822  HInstruction* object = LoadLocal(obj_reg, Primitive::kPrimNot);
823  current_block_->AddInstruction(new (arena_) HNullCheck(object, dex_pc));
824  if (is_put) {
825    Temporaries temps(graph_);
826    HInstruction* null_check = current_block_->GetLastInstruction();
827    // We need one temporary for the null check.
828    temps.Add(null_check);
829    HInstruction* value = LoadLocal(source_or_dest_reg, field_type);
830    current_block_->AddInstruction(new (arena_) HInstanceFieldSet(
831        null_check,
832        value,
833        field_type,
834        resolved_field->GetOffset(),
835        resolved_field->IsVolatile(),
836        field_index,
837        *dex_file_));
838  } else {
839    current_block_->AddInstruction(new (arena_) HInstanceFieldGet(
840        current_block_->GetLastInstruction(),
841        field_type,
842        resolved_field->GetOffset(),
843        resolved_field->IsVolatile(),
844        field_index,
845        *dex_file_));
846
847    UpdateLocal(source_or_dest_reg, current_block_->GetLastInstruction());
848  }
849  return true;
850}
851
852mirror::Class* HGraphBuilder::GetOutermostCompilingClass() const {
853  ScopedObjectAccess soa(Thread::Current());
854  StackHandleScope<2> hs(soa.Self());
855  const DexFile& outer_dex_file = *outer_compilation_unit_->GetDexFile();
856  Handle<mirror::ClassLoader> class_loader(hs.NewHandle(
857      soa.Decode<mirror::ClassLoader*>(dex_compilation_unit_->GetClassLoader())));
858  Handle<mirror::DexCache> outer_dex_cache(hs.NewHandle(
859      outer_compilation_unit_->GetClassLinker()->FindDexCache(outer_dex_file)));
860
861  return compiler_driver_->ResolveCompilingMethodsClass(
862      soa, outer_dex_cache, class_loader, outer_compilation_unit_);
863}
864
865bool HGraphBuilder::IsOutermostCompilingClass(uint16_t type_index) const {
866  ScopedObjectAccess soa(Thread::Current());
867  StackHandleScope<4> hs(soa.Self());
868  Handle<mirror::DexCache> dex_cache(hs.NewHandle(
869      dex_compilation_unit_->GetClassLinker()->FindDexCache(*dex_compilation_unit_->GetDexFile())));
870  Handle<mirror::ClassLoader> class_loader(hs.NewHandle(
871      soa.Decode<mirror::ClassLoader*>(dex_compilation_unit_->GetClassLoader())));
872  Handle<mirror::Class> cls(hs.NewHandle(compiler_driver_->ResolveClass(
873      soa, dex_cache, class_loader, type_index, dex_compilation_unit_)));
874  Handle<mirror::Class> compiling_class(hs.NewHandle(GetOutermostCompilingClass()));
875
876  return compiling_class.Get() == cls.Get();
877}
878
879bool HGraphBuilder::BuildStaticFieldAccess(const Instruction& instruction,
880                                           uint32_t dex_pc,
881                                           bool is_put) {
882  uint32_t source_or_dest_reg = instruction.VRegA_21c();
883  uint16_t field_index = instruction.VRegB_21c();
884
885  ScopedObjectAccess soa(Thread::Current());
886  StackHandleScope<4> hs(soa.Self());
887  Handle<mirror::DexCache> dex_cache(hs.NewHandle(
888      dex_compilation_unit_->GetClassLinker()->FindDexCache(*dex_compilation_unit_->GetDexFile())));
889  Handle<mirror::ClassLoader> class_loader(hs.NewHandle(
890      soa.Decode<mirror::ClassLoader*>(dex_compilation_unit_->GetClassLoader())));
891  ArtField* resolved_field = compiler_driver_->ResolveField(
892      soa, dex_cache, class_loader, dex_compilation_unit_, field_index, true);
893
894  if (resolved_field == nullptr) {
895    MaybeRecordStat(MethodCompilationStat::kNotCompiledUnresolvedField);
896    return false;
897  }
898
899  const DexFile& outer_dex_file = *outer_compilation_unit_->GetDexFile();
900  Handle<mirror::DexCache> outer_dex_cache(hs.NewHandle(
901      outer_compilation_unit_->GetClassLinker()->FindDexCache(outer_dex_file)));
902  Handle<mirror::Class> referrer_class(hs.NewHandle(GetOutermostCompilingClass()));
903
904  // The index at which the field's class is stored in the DexCache's type array.
905  uint32_t storage_index;
906  bool is_referrer_class = (referrer_class.Get() == resolved_field->GetDeclaringClass());
907  if (is_referrer_class) {
908    storage_index = referrer_class->GetDexTypeIndex();
909  } else if (outer_dex_cache.Get() != dex_cache.Get()) {
910    // The compiler driver cannot currently understand multiple dex caches involved. Just bailout.
911    return false;
912  } else {
913    std::pair<bool, bool> pair = compiler_driver_->IsFastStaticField(
914        outer_dex_cache.Get(),
915        referrer_class.Get(),
916        resolved_field,
917        field_index,
918        &storage_index);
919    bool can_easily_access = is_put ? pair.second : pair.first;
920    if (!can_easily_access) {
921      return false;
922    }
923  }
924
925  // TODO: find out why this check is needed.
926  bool is_in_dex_cache = compiler_driver_->CanAssumeTypeIsPresentInDexCache(
927      *outer_compilation_unit_->GetDexFile(), storage_index);
928  bool is_initialized = resolved_field->GetDeclaringClass()->IsInitialized() && is_in_dex_cache;
929
930  HLoadClass* constant = new (arena_) HLoadClass(graph_->GetCurrentMethod(),
931                                                 storage_index,
932                                                 *dex_compilation_unit_->GetDexFile(),
933                                                 is_referrer_class,
934                                                 dex_pc);
935  current_block_->AddInstruction(constant);
936
937  HInstruction* cls = constant;
938  if (!is_initialized && !is_referrer_class) {
939    cls = new (arena_) HClinitCheck(constant, dex_pc);
940    current_block_->AddInstruction(cls);
941  }
942
943  Primitive::Type field_type = resolved_field->GetTypeAsPrimitiveType();
944  if (is_put) {
945    // We need to keep the class alive before loading the value.
946    Temporaries temps(graph_);
947    temps.Add(cls);
948    HInstruction* value = LoadLocal(source_or_dest_reg, field_type);
949    DCHECK_EQ(value->GetType(), field_type);
950    current_block_->AddInstruction(new (arena_) HStaticFieldSet(cls,
951                                                                value,
952                                                                field_type,
953                                                                resolved_field->GetOffset(),
954                                                                resolved_field->IsVolatile(),
955                                                                field_index,
956                                                                *dex_file_));
957  } else {
958    current_block_->AddInstruction(new (arena_) HStaticFieldGet(cls,
959                                                                field_type,
960                                                                resolved_field->GetOffset(),
961                                                                resolved_field->IsVolatile(),
962                                                                field_index,
963                                                                *dex_file_));
964    UpdateLocal(source_or_dest_reg, current_block_->GetLastInstruction());
965  }
966  return true;
967}
968
969void HGraphBuilder::BuildCheckedDivRem(uint16_t out_vreg,
970                                       uint16_t first_vreg,
971                                       int64_t second_vreg_or_constant,
972                                       uint32_t dex_pc,
973                                       Primitive::Type type,
974                                       bool second_is_constant,
975                                       bool isDiv) {
976  DCHECK(type == Primitive::kPrimInt || type == Primitive::kPrimLong);
977
978  HInstruction* first = LoadLocal(first_vreg, type);
979  HInstruction* second = nullptr;
980  if (second_is_constant) {
981    if (type == Primitive::kPrimInt) {
982      second = graph_->GetIntConstant(second_vreg_or_constant);
983    } else {
984      second = graph_->GetLongConstant(second_vreg_or_constant);
985    }
986  } else {
987    second = LoadLocal(second_vreg_or_constant, type);
988  }
989
990  if (!second_is_constant
991      || (type == Primitive::kPrimInt && second->AsIntConstant()->GetValue() == 0)
992      || (type == Primitive::kPrimLong && second->AsLongConstant()->GetValue() == 0)) {
993    second = new (arena_) HDivZeroCheck(second, dex_pc);
994    Temporaries temps(graph_);
995    current_block_->AddInstruction(second);
996    temps.Add(current_block_->GetLastInstruction());
997  }
998
999  if (isDiv) {
1000    current_block_->AddInstruction(new (arena_) HDiv(type, first, second, dex_pc));
1001  } else {
1002    current_block_->AddInstruction(new (arena_) HRem(type, first, second, dex_pc));
1003  }
1004  UpdateLocal(out_vreg, current_block_->GetLastInstruction());
1005}
1006
1007void HGraphBuilder::BuildArrayAccess(const Instruction& instruction,
1008                                     uint32_t dex_pc,
1009                                     bool is_put,
1010                                     Primitive::Type anticipated_type) {
1011  uint8_t source_or_dest_reg = instruction.VRegA_23x();
1012  uint8_t array_reg = instruction.VRegB_23x();
1013  uint8_t index_reg = instruction.VRegC_23x();
1014
1015  // We need one temporary for the null check, one for the index, and one for the length.
1016  Temporaries temps(graph_);
1017
1018  HInstruction* object = LoadLocal(array_reg, Primitive::kPrimNot);
1019  object = new (arena_) HNullCheck(object, dex_pc);
1020  current_block_->AddInstruction(object);
1021  temps.Add(object);
1022
1023  HInstruction* length = new (arena_) HArrayLength(object);
1024  current_block_->AddInstruction(length);
1025  temps.Add(length);
1026  HInstruction* index = LoadLocal(index_reg, Primitive::kPrimInt);
1027  index = new (arena_) HBoundsCheck(index, length, dex_pc);
1028  current_block_->AddInstruction(index);
1029  temps.Add(index);
1030  if (is_put) {
1031    HInstruction* value = LoadLocal(source_or_dest_reg, anticipated_type);
1032    // TODO: Insert a type check node if the type is Object.
1033    current_block_->AddInstruction(new (arena_) HArraySet(
1034        object, index, value, anticipated_type, dex_pc));
1035  } else {
1036    current_block_->AddInstruction(new (arena_) HArrayGet(object, index, anticipated_type));
1037    UpdateLocal(source_or_dest_reg, current_block_->GetLastInstruction());
1038  }
1039  graph_->SetHasBoundsChecks(true);
1040}
1041
1042void HGraphBuilder::BuildFilledNewArray(uint32_t dex_pc,
1043                                        uint32_t type_index,
1044                                        uint32_t number_of_vreg_arguments,
1045                                        bool is_range,
1046                                        uint32_t* args,
1047                                        uint32_t register_index) {
1048  HInstruction* length = graph_->GetIntConstant(number_of_vreg_arguments);
1049  QuickEntrypointEnum entrypoint = NeedsAccessCheck(type_index)
1050      ? kQuickAllocArrayWithAccessCheck
1051      : kQuickAllocArray;
1052  HInstruction* object = new (arena_) HNewArray(length,
1053                                                dex_pc,
1054                                                type_index,
1055                                                *dex_compilation_unit_->GetDexFile(),
1056                                                entrypoint);
1057  current_block_->AddInstruction(object);
1058
1059  const char* descriptor = dex_file_->StringByTypeIdx(type_index);
1060  DCHECK_EQ(descriptor[0], '[') << descriptor;
1061  char primitive = descriptor[1];
1062  DCHECK(primitive == 'I'
1063      || primitive == 'L'
1064      || primitive == '[') << descriptor;
1065  bool is_reference_array = (primitive == 'L') || (primitive == '[');
1066  Primitive::Type type = is_reference_array ? Primitive::kPrimNot : Primitive::kPrimInt;
1067
1068  Temporaries temps(graph_);
1069  temps.Add(object);
1070  for (size_t i = 0; i < number_of_vreg_arguments; ++i) {
1071    HInstruction* value = LoadLocal(is_range ? register_index + i : args[i], type);
1072    HInstruction* index = graph_->GetIntConstant(i);
1073    current_block_->AddInstruction(
1074        new (arena_) HArraySet(object, index, value, type, dex_pc));
1075  }
1076  latest_result_ = object;
1077}
1078
1079template <typename T>
1080void HGraphBuilder::BuildFillArrayData(HInstruction* object,
1081                                       const T* data,
1082                                       uint32_t element_count,
1083                                       Primitive::Type anticipated_type,
1084                                       uint32_t dex_pc) {
1085  for (uint32_t i = 0; i < element_count; ++i) {
1086    HInstruction* index = graph_->GetIntConstant(i);
1087    HInstruction* value = graph_->GetIntConstant(data[i]);
1088    current_block_->AddInstruction(new (arena_) HArraySet(
1089      object, index, value, anticipated_type, dex_pc));
1090  }
1091}
1092
1093void HGraphBuilder::BuildFillArrayData(const Instruction& instruction, uint32_t dex_pc) {
1094  Temporaries temps(graph_);
1095  HInstruction* array = LoadLocal(instruction.VRegA_31t(), Primitive::kPrimNot);
1096  HNullCheck* null_check = new (arena_) HNullCheck(array, dex_pc);
1097  current_block_->AddInstruction(null_check);
1098  temps.Add(null_check);
1099
1100  HInstruction* length = new (arena_) HArrayLength(null_check);
1101  current_block_->AddInstruction(length);
1102
1103  int32_t payload_offset = instruction.VRegB_31t() + dex_pc;
1104  const Instruction::ArrayDataPayload* payload =
1105      reinterpret_cast<const Instruction::ArrayDataPayload*>(code_start_ + payload_offset);
1106  const uint8_t* data = payload->data;
1107  uint32_t element_count = payload->element_count;
1108
1109  // Implementation of this DEX instruction seems to be that the bounds check is
1110  // done before doing any stores.
1111  HInstruction* last_index = graph_->GetIntConstant(payload->element_count - 1);
1112  current_block_->AddInstruction(new (arena_) HBoundsCheck(last_index, length, dex_pc));
1113
1114  switch (payload->element_width) {
1115    case 1:
1116      BuildFillArrayData(null_check,
1117                         reinterpret_cast<const int8_t*>(data),
1118                         element_count,
1119                         Primitive::kPrimByte,
1120                         dex_pc);
1121      break;
1122    case 2:
1123      BuildFillArrayData(null_check,
1124                         reinterpret_cast<const int16_t*>(data),
1125                         element_count,
1126                         Primitive::kPrimShort,
1127                         dex_pc);
1128      break;
1129    case 4:
1130      BuildFillArrayData(null_check,
1131                         reinterpret_cast<const int32_t*>(data),
1132                         element_count,
1133                         Primitive::kPrimInt,
1134                         dex_pc);
1135      break;
1136    case 8:
1137      BuildFillWideArrayData(null_check,
1138                             reinterpret_cast<const int64_t*>(data),
1139                             element_count,
1140                             dex_pc);
1141      break;
1142    default:
1143      LOG(FATAL) << "Unknown element width for " << payload->element_width;
1144  }
1145  graph_->SetHasBoundsChecks(true);
1146}
1147
1148void HGraphBuilder::BuildFillWideArrayData(HInstruction* object,
1149                                           const int64_t* data,
1150                                           uint32_t element_count,
1151                                           uint32_t dex_pc) {
1152  for (uint32_t i = 0; i < element_count; ++i) {
1153    HInstruction* index = graph_->GetIntConstant(i);
1154    HInstruction* value = graph_->GetLongConstant(data[i]);
1155    current_block_->AddInstruction(new (arena_) HArraySet(
1156      object, index, value, Primitive::kPrimLong, dex_pc));
1157  }
1158}
1159
1160bool HGraphBuilder::BuildTypeCheck(const Instruction& instruction,
1161                                   uint8_t destination,
1162                                   uint8_t reference,
1163                                   uint16_t type_index,
1164                                   uint32_t dex_pc) {
1165  bool type_known_final;
1166  bool type_known_abstract;
1167  // `CanAccessTypeWithoutChecks` will tell whether the method being
1168  // built is trying to access its own class, so that the generated
1169  // code can optimize for this case. However, the optimization does not
1170  // work for inlining, so we use `IsOutermostCompilingClass` instead.
1171  bool dont_use_is_referrers_class;
1172  bool can_access = compiler_driver_->CanAccessTypeWithoutChecks(
1173      dex_compilation_unit_->GetDexMethodIndex(), *dex_file_, type_index,
1174      &type_known_final, &type_known_abstract, &dont_use_is_referrers_class);
1175  if (!can_access) {
1176    MaybeRecordStat(MethodCompilationStat::kNotCompiledCantAccesType);
1177    return false;
1178  }
1179  HInstruction* object = LoadLocal(reference, Primitive::kPrimNot);
1180  HLoadClass* cls = new (arena_) HLoadClass(
1181      graph_->GetCurrentMethod(),
1182      type_index,
1183      *dex_compilation_unit_->GetDexFile(),
1184      IsOutermostCompilingClass(type_index),
1185      dex_pc);
1186  current_block_->AddInstruction(cls);
1187  // The class needs a temporary before being used by the type check.
1188  Temporaries temps(graph_);
1189  temps.Add(cls);
1190  if (instruction.Opcode() == Instruction::INSTANCE_OF) {
1191    current_block_->AddInstruction(
1192        new (arena_) HInstanceOf(object, cls, type_known_final, dex_pc));
1193    UpdateLocal(destination, current_block_->GetLastInstruction());
1194  } else {
1195    DCHECK_EQ(instruction.Opcode(), Instruction::CHECK_CAST);
1196    current_block_->AddInstruction(
1197        new (arena_) HCheckCast(object, cls, type_known_final, dex_pc));
1198  }
1199  return true;
1200}
1201
1202bool HGraphBuilder::NeedsAccessCheck(uint32_t type_index) const {
1203  return !compiler_driver_->CanAccessInstantiableTypeWithoutChecks(
1204      dex_compilation_unit_->GetDexMethodIndex(), *dex_file_, type_index);
1205}
1206
1207void HGraphBuilder::BuildPackedSwitch(const Instruction& instruction, uint32_t dex_pc) {
1208  SwitchTable table(instruction, dex_pc, false);
1209
1210  // Value to test against.
1211  HInstruction* value = LoadLocal(instruction.VRegA(), Primitive::kPrimInt);
1212
1213  uint16_t num_entries = table.GetNumEntries();
1214  // There should be at least one entry here.
1215  DCHECK_GT(num_entries, 0U);
1216
1217  // Chained cmp-and-branch, starting from starting_key.
1218  int32_t starting_key = table.GetEntryAt(0);
1219
1220  for (size_t i = 1; i <= num_entries; i++) {
1221    BuildSwitchCaseHelper(instruction, i, i == num_entries, table, value, starting_key + i - 1,
1222                          table.GetEntryAt(i), dex_pc);
1223  }
1224}
1225
1226void HGraphBuilder::BuildSparseSwitch(const Instruction& instruction, uint32_t dex_pc) {
1227  SwitchTable table(instruction, dex_pc, true);
1228
1229  // Value to test against.
1230  HInstruction* value = LoadLocal(instruction.VRegA(), Primitive::kPrimInt);
1231
1232  uint16_t num_entries = table.GetNumEntries();
1233
1234  for (size_t i = 0; i < num_entries; i++) {
1235    BuildSwitchCaseHelper(instruction, i, i == static_cast<size_t>(num_entries) - 1, table, value,
1236                          table.GetEntryAt(i), table.GetEntryAt(i + num_entries), dex_pc);
1237  }
1238}
1239
1240void HGraphBuilder::BuildSwitchCaseHelper(const Instruction& instruction, size_t index,
1241                                          bool is_last_case, const SwitchTable& table,
1242                                          HInstruction* value, int32_t case_value_int,
1243                                          int32_t target_offset, uint32_t dex_pc) {
1244  HBasicBlock* case_target = FindBlockStartingAt(dex_pc + target_offset);
1245  DCHECK(case_target != nullptr);
1246  PotentiallyAddSuspendCheck(case_target, dex_pc);
1247
1248  // The current case's value.
1249  HInstruction* this_case_value = graph_->GetIntConstant(case_value_int);
1250
1251  // Compare value and this_case_value.
1252  HEqual* comparison = new (arena_) HEqual(value, this_case_value);
1253  current_block_->AddInstruction(comparison);
1254  HInstruction* ifinst = new (arena_) HIf(comparison);
1255  current_block_->AddInstruction(ifinst);
1256
1257  // Case hit: use the target offset to determine where to go.
1258  current_block_->AddSuccessor(case_target);
1259
1260  // Case miss: go to the next case (or default fall-through).
1261  // When there is a next case, we use the block stored with the table offset representing this
1262  // case (that is where we registered them in ComputeBranchTargets).
1263  // When there is no next case, we use the following instruction.
1264  // TODO: Find a good way to peel the last iteration to avoid conditional, but still have re-use.
1265  if (!is_last_case) {
1266    HBasicBlock* next_case_target = FindBlockStartingAt(table.GetDexPcForIndex(index));
1267    DCHECK(next_case_target != nullptr);
1268    current_block_->AddSuccessor(next_case_target);
1269
1270    // Need to manually add the block, as there is no dex-pc transition for the cases.
1271    graph_->AddBlock(next_case_target);
1272
1273    current_block_ = next_case_target;
1274  } else {
1275    HBasicBlock* default_target = FindBlockStartingAt(dex_pc + instruction.SizeInCodeUnits());
1276    DCHECK(default_target != nullptr);
1277    current_block_->AddSuccessor(default_target);
1278    current_block_ = nullptr;
1279  }
1280}
1281
1282void HGraphBuilder::PotentiallyAddSuspendCheck(HBasicBlock* target, uint32_t dex_pc) {
1283  int32_t target_offset = target->GetDexPc() - dex_pc;
1284  if (target_offset <= 0) {
1285    // DX generates back edges to the first encountered return. We can save
1286    // time of later passes by not adding redundant suspend checks.
1287    HInstruction* last_in_target = target->GetLastInstruction();
1288    if (last_in_target != nullptr &&
1289        (last_in_target->IsReturn() || last_in_target->IsReturnVoid())) {
1290      return;
1291    }
1292
1293    // Add a suspend check to backward branches which may potentially loop. We
1294    // can remove them after we recognize loops in the graph.
1295    current_block_->AddInstruction(new (arena_) HSuspendCheck(dex_pc));
1296  }
1297}
1298
1299bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32_t dex_pc) {
1300  if (current_block_ == nullptr) {
1301    return true;  // Dead code
1302  }
1303
1304  switch (instruction.Opcode()) {
1305    case Instruction::CONST_4: {
1306      int32_t register_index = instruction.VRegA();
1307      HIntConstant* constant = graph_->GetIntConstant(instruction.VRegB_11n());
1308      UpdateLocal(register_index, constant);
1309      break;
1310    }
1311
1312    case Instruction::CONST_16: {
1313      int32_t register_index = instruction.VRegA();
1314      HIntConstant* constant = graph_->GetIntConstant(instruction.VRegB_21s());
1315      UpdateLocal(register_index, constant);
1316      break;
1317    }
1318
1319    case Instruction::CONST: {
1320      int32_t register_index = instruction.VRegA();
1321      HIntConstant* constant = graph_->GetIntConstant(instruction.VRegB_31i());
1322      UpdateLocal(register_index, constant);
1323      break;
1324    }
1325
1326    case Instruction::CONST_HIGH16: {
1327      int32_t register_index = instruction.VRegA();
1328      HIntConstant* constant = graph_->GetIntConstant(instruction.VRegB_21h() << 16);
1329      UpdateLocal(register_index, constant);
1330      break;
1331    }
1332
1333    case Instruction::CONST_WIDE_16: {
1334      int32_t register_index = instruction.VRegA();
1335      // Get 16 bits of constant value, sign extended to 64 bits.
1336      int64_t value = instruction.VRegB_21s();
1337      value <<= 48;
1338      value >>= 48;
1339      HLongConstant* constant = graph_->GetLongConstant(value);
1340      UpdateLocal(register_index, constant);
1341      break;
1342    }
1343
1344    case Instruction::CONST_WIDE_32: {
1345      int32_t register_index = instruction.VRegA();
1346      // Get 32 bits of constant value, sign extended to 64 bits.
1347      int64_t value = instruction.VRegB_31i();
1348      value <<= 32;
1349      value >>= 32;
1350      HLongConstant* constant = graph_->GetLongConstant(value);
1351      UpdateLocal(register_index, constant);
1352      break;
1353    }
1354
1355    case Instruction::CONST_WIDE: {
1356      int32_t register_index = instruction.VRegA();
1357      HLongConstant* constant = graph_->GetLongConstant(instruction.VRegB_51l());
1358      UpdateLocal(register_index, constant);
1359      break;
1360    }
1361
1362    case Instruction::CONST_WIDE_HIGH16: {
1363      int32_t register_index = instruction.VRegA();
1364      int64_t value = static_cast<int64_t>(instruction.VRegB_21h()) << 48;
1365      HLongConstant* constant = graph_->GetLongConstant(value);
1366      UpdateLocal(register_index, constant);
1367      break;
1368    }
1369
1370    // Note that the SSA building will refine the types.
1371    case Instruction::MOVE:
1372    case Instruction::MOVE_FROM16:
1373    case Instruction::MOVE_16: {
1374      HInstruction* value = LoadLocal(instruction.VRegB(), Primitive::kPrimInt);
1375      UpdateLocal(instruction.VRegA(), value);
1376      break;
1377    }
1378
1379    // Note that the SSA building will refine the types.
1380    case Instruction::MOVE_WIDE:
1381    case Instruction::MOVE_WIDE_FROM16:
1382    case Instruction::MOVE_WIDE_16: {
1383      HInstruction* value = LoadLocal(instruction.VRegB(), Primitive::kPrimLong);
1384      UpdateLocal(instruction.VRegA(), value);
1385      break;
1386    }
1387
1388    case Instruction::MOVE_OBJECT:
1389    case Instruction::MOVE_OBJECT_16:
1390    case Instruction::MOVE_OBJECT_FROM16: {
1391      HInstruction* value = LoadLocal(instruction.VRegB(), Primitive::kPrimNot);
1392      UpdateLocal(instruction.VRegA(), value);
1393      break;
1394    }
1395
1396    case Instruction::RETURN_VOID: {
1397      BuildReturn(instruction, Primitive::kPrimVoid);
1398      break;
1399    }
1400
1401#define IF_XX(comparison, cond) \
1402    case Instruction::IF_##cond: If_22t<comparison>(instruction, dex_pc); break; \
1403    case Instruction::IF_##cond##Z: If_21t<comparison>(instruction, dex_pc); break
1404
1405    IF_XX(HEqual, EQ);
1406    IF_XX(HNotEqual, NE);
1407    IF_XX(HLessThan, LT);
1408    IF_XX(HLessThanOrEqual, LE);
1409    IF_XX(HGreaterThan, GT);
1410    IF_XX(HGreaterThanOrEqual, GE);
1411
1412    case Instruction::GOTO:
1413    case Instruction::GOTO_16:
1414    case Instruction::GOTO_32: {
1415      int32_t offset = instruction.GetTargetOffset();
1416      HBasicBlock* target = FindBlockStartingAt(offset + dex_pc);
1417      DCHECK(target != nullptr);
1418      PotentiallyAddSuspendCheck(target, dex_pc);
1419      current_block_->AddInstruction(new (arena_) HGoto());
1420      current_block_->AddSuccessor(target);
1421      current_block_ = nullptr;
1422      break;
1423    }
1424
1425    case Instruction::RETURN: {
1426      DCHECK_NE(return_type_, Primitive::kPrimNot);
1427      DCHECK_NE(return_type_, Primitive::kPrimLong);
1428      DCHECK_NE(return_type_, Primitive::kPrimDouble);
1429      BuildReturn(instruction, return_type_);
1430      break;
1431    }
1432
1433    case Instruction::RETURN_OBJECT: {
1434      DCHECK(return_type_ == Primitive::kPrimNot);
1435      BuildReturn(instruction, return_type_);
1436      break;
1437    }
1438
1439    case Instruction::RETURN_WIDE: {
1440      DCHECK(return_type_ == Primitive::kPrimDouble || return_type_ == Primitive::kPrimLong);
1441      BuildReturn(instruction, return_type_);
1442      break;
1443    }
1444
1445    case Instruction::INVOKE_DIRECT:
1446    case Instruction::INVOKE_INTERFACE:
1447    case Instruction::INVOKE_STATIC:
1448    case Instruction::INVOKE_SUPER:
1449    case Instruction::INVOKE_VIRTUAL: {
1450      uint32_t method_idx = instruction.VRegB_35c();
1451      uint32_t number_of_vreg_arguments = instruction.VRegA_35c();
1452      uint32_t args[5];
1453      instruction.GetVarArgs(args);
1454      if (!BuildInvoke(instruction, dex_pc, method_idx,
1455                       number_of_vreg_arguments, false, args, -1)) {
1456        return false;
1457      }
1458      break;
1459    }
1460
1461    case Instruction::INVOKE_DIRECT_RANGE:
1462    case Instruction::INVOKE_INTERFACE_RANGE:
1463    case Instruction::INVOKE_STATIC_RANGE:
1464    case Instruction::INVOKE_SUPER_RANGE:
1465    case Instruction::INVOKE_VIRTUAL_RANGE: {
1466      uint32_t method_idx = instruction.VRegB_3rc();
1467      uint32_t number_of_vreg_arguments = instruction.VRegA_3rc();
1468      uint32_t register_index = instruction.VRegC();
1469      if (!BuildInvoke(instruction, dex_pc, method_idx,
1470                       number_of_vreg_arguments, true, nullptr, register_index)) {
1471        return false;
1472      }
1473      break;
1474    }
1475
1476    case Instruction::NEG_INT: {
1477      Unop_12x<HNeg>(instruction, Primitive::kPrimInt);
1478      break;
1479    }
1480
1481    case Instruction::NEG_LONG: {
1482      Unop_12x<HNeg>(instruction, Primitive::kPrimLong);
1483      break;
1484    }
1485
1486    case Instruction::NEG_FLOAT: {
1487      Unop_12x<HNeg>(instruction, Primitive::kPrimFloat);
1488      break;
1489    }
1490
1491    case Instruction::NEG_DOUBLE: {
1492      Unop_12x<HNeg>(instruction, Primitive::kPrimDouble);
1493      break;
1494    }
1495
1496    case Instruction::NOT_INT: {
1497      Unop_12x<HNot>(instruction, Primitive::kPrimInt);
1498      break;
1499    }
1500
1501    case Instruction::NOT_LONG: {
1502      Unop_12x<HNot>(instruction, Primitive::kPrimLong);
1503      break;
1504    }
1505
1506    case Instruction::INT_TO_LONG: {
1507      Conversion_12x(instruction, Primitive::kPrimInt, Primitive::kPrimLong, dex_pc);
1508      break;
1509    }
1510
1511    case Instruction::INT_TO_FLOAT: {
1512      Conversion_12x(instruction, Primitive::kPrimInt, Primitive::kPrimFloat, dex_pc);
1513      break;
1514    }
1515
1516    case Instruction::INT_TO_DOUBLE: {
1517      Conversion_12x(instruction, Primitive::kPrimInt, Primitive::kPrimDouble, dex_pc);
1518      break;
1519    }
1520
1521    case Instruction::LONG_TO_INT: {
1522      Conversion_12x(instruction, Primitive::kPrimLong, Primitive::kPrimInt, dex_pc);
1523      break;
1524    }
1525
1526    case Instruction::LONG_TO_FLOAT: {
1527      Conversion_12x(instruction, Primitive::kPrimLong, Primitive::kPrimFloat, dex_pc);
1528      break;
1529    }
1530
1531    case Instruction::LONG_TO_DOUBLE: {
1532      Conversion_12x(instruction, Primitive::kPrimLong, Primitive::kPrimDouble, dex_pc);
1533      break;
1534    }
1535
1536    case Instruction::FLOAT_TO_INT: {
1537      Conversion_12x(instruction, Primitive::kPrimFloat, Primitive::kPrimInt, dex_pc);
1538      break;
1539    }
1540
1541    case Instruction::FLOAT_TO_LONG: {
1542      Conversion_12x(instruction, Primitive::kPrimFloat, Primitive::kPrimLong, dex_pc);
1543      break;
1544    }
1545
1546    case Instruction::FLOAT_TO_DOUBLE: {
1547      Conversion_12x(instruction, Primitive::kPrimFloat, Primitive::kPrimDouble, dex_pc);
1548      break;
1549    }
1550
1551    case Instruction::DOUBLE_TO_INT: {
1552      Conversion_12x(instruction, Primitive::kPrimDouble, Primitive::kPrimInt, dex_pc);
1553      break;
1554    }
1555
1556    case Instruction::DOUBLE_TO_LONG: {
1557      Conversion_12x(instruction, Primitive::kPrimDouble, Primitive::kPrimLong, dex_pc);
1558      break;
1559    }
1560
1561    case Instruction::DOUBLE_TO_FLOAT: {
1562      Conversion_12x(instruction, Primitive::kPrimDouble, Primitive::kPrimFloat, dex_pc);
1563      break;
1564    }
1565
1566    case Instruction::INT_TO_BYTE: {
1567      Conversion_12x(instruction, Primitive::kPrimInt, Primitive::kPrimByte, dex_pc);
1568      break;
1569    }
1570
1571    case Instruction::INT_TO_SHORT: {
1572      Conversion_12x(instruction, Primitive::kPrimInt, Primitive::kPrimShort, dex_pc);
1573      break;
1574    }
1575
1576    case Instruction::INT_TO_CHAR: {
1577      Conversion_12x(instruction, Primitive::kPrimInt, Primitive::kPrimChar, dex_pc);
1578      break;
1579    }
1580
1581    case Instruction::ADD_INT: {
1582      Binop_23x<HAdd>(instruction, Primitive::kPrimInt);
1583      break;
1584    }
1585
1586    case Instruction::ADD_LONG: {
1587      Binop_23x<HAdd>(instruction, Primitive::kPrimLong);
1588      break;
1589    }
1590
1591    case Instruction::ADD_DOUBLE: {
1592      Binop_23x<HAdd>(instruction, Primitive::kPrimDouble);
1593      break;
1594    }
1595
1596    case Instruction::ADD_FLOAT: {
1597      Binop_23x<HAdd>(instruction, Primitive::kPrimFloat);
1598      break;
1599    }
1600
1601    case Instruction::SUB_INT: {
1602      Binop_23x<HSub>(instruction, Primitive::kPrimInt);
1603      break;
1604    }
1605
1606    case Instruction::SUB_LONG: {
1607      Binop_23x<HSub>(instruction, Primitive::kPrimLong);
1608      break;
1609    }
1610
1611    case Instruction::SUB_FLOAT: {
1612      Binop_23x<HSub>(instruction, Primitive::kPrimFloat);
1613      break;
1614    }
1615
1616    case Instruction::SUB_DOUBLE: {
1617      Binop_23x<HSub>(instruction, Primitive::kPrimDouble);
1618      break;
1619    }
1620
1621    case Instruction::ADD_INT_2ADDR: {
1622      Binop_12x<HAdd>(instruction, Primitive::kPrimInt);
1623      break;
1624    }
1625
1626    case Instruction::MUL_INT: {
1627      Binop_23x<HMul>(instruction, Primitive::kPrimInt);
1628      break;
1629    }
1630
1631    case Instruction::MUL_LONG: {
1632      Binop_23x<HMul>(instruction, Primitive::kPrimLong);
1633      break;
1634    }
1635
1636    case Instruction::MUL_FLOAT: {
1637      Binop_23x<HMul>(instruction, Primitive::kPrimFloat);
1638      break;
1639    }
1640
1641    case Instruction::MUL_DOUBLE: {
1642      Binop_23x<HMul>(instruction, Primitive::kPrimDouble);
1643      break;
1644    }
1645
1646    case Instruction::DIV_INT: {
1647      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(),
1648                         dex_pc, Primitive::kPrimInt, false, true);
1649      break;
1650    }
1651
1652    case Instruction::DIV_LONG: {
1653      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(),
1654                         dex_pc, Primitive::kPrimLong, false, true);
1655      break;
1656    }
1657
1658    case Instruction::DIV_FLOAT: {
1659      Binop_23x<HDiv>(instruction, Primitive::kPrimFloat, dex_pc);
1660      break;
1661    }
1662
1663    case Instruction::DIV_DOUBLE: {
1664      Binop_23x<HDiv>(instruction, Primitive::kPrimDouble, dex_pc);
1665      break;
1666    }
1667
1668    case Instruction::REM_INT: {
1669      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(),
1670                         dex_pc, Primitive::kPrimInt, false, false);
1671      break;
1672    }
1673
1674    case Instruction::REM_LONG: {
1675      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(),
1676                         dex_pc, Primitive::kPrimLong, false, false);
1677      break;
1678    }
1679
1680    case Instruction::REM_FLOAT: {
1681      Binop_23x<HRem>(instruction, Primitive::kPrimFloat, dex_pc);
1682      break;
1683    }
1684
1685    case Instruction::REM_DOUBLE: {
1686      Binop_23x<HRem>(instruction, Primitive::kPrimDouble, dex_pc);
1687      break;
1688    }
1689
1690    case Instruction::AND_INT: {
1691      Binop_23x<HAnd>(instruction, Primitive::kPrimInt);
1692      break;
1693    }
1694
1695    case Instruction::AND_LONG: {
1696      Binop_23x<HAnd>(instruction, Primitive::kPrimLong);
1697      break;
1698    }
1699
1700    case Instruction::SHL_INT: {
1701      Binop_23x_shift<HShl>(instruction, Primitive::kPrimInt);
1702      break;
1703    }
1704
1705    case Instruction::SHL_LONG: {
1706      Binop_23x_shift<HShl>(instruction, Primitive::kPrimLong);
1707      break;
1708    }
1709
1710    case Instruction::SHR_INT: {
1711      Binop_23x_shift<HShr>(instruction, Primitive::kPrimInt);
1712      break;
1713    }
1714
1715    case Instruction::SHR_LONG: {
1716      Binop_23x_shift<HShr>(instruction, Primitive::kPrimLong);
1717      break;
1718    }
1719
1720    case Instruction::USHR_INT: {
1721      Binop_23x_shift<HUShr>(instruction, Primitive::kPrimInt);
1722      break;
1723    }
1724
1725    case Instruction::USHR_LONG: {
1726      Binop_23x_shift<HUShr>(instruction, Primitive::kPrimLong);
1727      break;
1728    }
1729
1730    case Instruction::OR_INT: {
1731      Binop_23x<HOr>(instruction, Primitive::kPrimInt);
1732      break;
1733    }
1734
1735    case Instruction::OR_LONG: {
1736      Binop_23x<HOr>(instruction, Primitive::kPrimLong);
1737      break;
1738    }
1739
1740    case Instruction::XOR_INT: {
1741      Binop_23x<HXor>(instruction, Primitive::kPrimInt);
1742      break;
1743    }
1744
1745    case Instruction::XOR_LONG: {
1746      Binop_23x<HXor>(instruction, Primitive::kPrimLong);
1747      break;
1748    }
1749
1750    case Instruction::ADD_LONG_2ADDR: {
1751      Binop_12x<HAdd>(instruction, Primitive::kPrimLong);
1752      break;
1753    }
1754
1755    case Instruction::ADD_DOUBLE_2ADDR: {
1756      Binop_12x<HAdd>(instruction, Primitive::kPrimDouble);
1757      break;
1758    }
1759
1760    case Instruction::ADD_FLOAT_2ADDR: {
1761      Binop_12x<HAdd>(instruction, Primitive::kPrimFloat);
1762      break;
1763    }
1764
1765    case Instruction::SUB_INT_2ADDR: {
1766      Binop_12x<HSub>(instruction, Primitive::kPrimInt);
1767      break;
1768    }
1769
1770    case Instruction::SUB_LONG_2ADDR: {
1771      Binop_12x<HSub>(instruction, Primitive::kPrimLong);
1772      break;
1773    }
1774
1775    case Instruction::SUB_FLOAT_2ADDR: {
1776      Binop_12x<HSub>(instruction, Primitive::kPrimFloat);
1777      break;
1778    }
1779
1780    case Instruction::SUB_DOUBLE_2ADDR: {
1781      Binop_12x<HSub>(instruction, Primitive::kPrimDouble);
1782      break;
1783    }
1784
1785    case Instruction::MUL_INT_2ADDR: {
1786      Binop_12x<HMul>(instruction, Primitive::kPrimInt);
1787      break;
1788    }
1789
1790    case Instruction::MUL_LONG_2ADDR: {
1791      Binop_12x<HMul>(instruction, Primitive::kPrimLong);
1792      break;
1793    }
1794
1795    case Instruction::MUL_FLOAT_2ADDR: {
1796      Binop_12x<HMul>(instruction, Primitive::kPrimFloat);
1797      break;
1798    }
1799
1800    case Instruction::MUL_DOUBLE_2ADDR: {
1801      Binop_12x<HMul>(instruction, Primitive::kPrimDouble);
1802      break;
1803    }
1804
1805    case Instruction::DIV_INT_2ADDR: {
1806      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegA(), instruction.VRegB(),
1807                         dex_pc, Primitive::kPrimInt, false, true);
1808      break;
1809    }
1810
1811    case Instruction::DIV_LONG_2ADDR: {
1812      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegA(), instruction.VRegB(),
1813                         dex_pc, Primitive::kPrimLong, false, true);
1814      break;
1815    }
1816
1817    case Instruction::REM_INT_2ADDR: {
1818      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegA(), instruction.VRegB(),
1819                         dex_pc, Primitive::kPrimInt, false, false);
1820      break;
1821    }
1822
1823    case Instruction::REM_LONG_2ADDR: {
1824      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegA(), instruction.VRegB(),
1825                         dex_pc, Primitive::kPrimLong, false, false);
1826      break;
1827    }
1828
1829    case Instruction::REM_FLOAT_2ADDR: {
1830      Binop_12x<HRem>(instruction, Primitive::kPrimFloat, dex_pc);
1831      break;
1832    }
1833
1834    case Instruction::REM_DOUBLE_2ADDR: {
1835      Binop_12x<HRem>(instruction, Primitive::kPrimDouble, dex_pc);
1836      break;
1837    }
1838
1839    case Instruction::SHL_INT_2ADDR: {
1840      Binop_12x_shift<HShl>(instruction, Primitive::kPrimInt);
1841      break;
1842    }
1843
1844    case Instruction::SHL_LONG_2ADDR: {
1845      Binop_12x_shift<HShl>(instruction, Primitive::kPrimLong);
1846      break;
1847    }
1848
1849    case Instruction::SHR_INT_2ADDR: {
1850      Binop_12x_shift<HShr>(instruction, Primitive::kPrimInt);
1851      break;
1852    }
1853
1854    case Instruction::SHR_LONG_2ADDR: {
1855      Binop_12x_shift<HShr>(instruction, Primitive::kPrimLong);
1856      break;
1857    }
1858
1859    case Instruction::USHR_INT_2ADDR: {
1860      Binop_12x_shift<HUShr>(instruction, Primitive::kPrimInt);
1861      break;
1862    }
1863
1864    case Instruction::USHR_LONG_2ADDR: {
1865      Binop_12x_shift<HUShr>(instruction, Primitive::kPrimLong);
1866      break;
1867    }
1868
1869    case Instruction::DIV_FLOAT_2ADDR: {
1870      Binop_12x<HDiv>(instruction, Primitive::kPrimFloat, dex_pc);
1871      break;
1872    }
1873
1874    case Instruction::DIV_DOUBLE_2ADDR: {
1875      Binop_12x<HDiv>(instruction, Primitive::kPrimDouble, dex_pc);
1876      break;
1877    }
1878
1879    case Instruction::AND_INT_2ADDR: {
1880      Binop_12x<HAnd>(instruction, Primitive::kPrimInt);
1881      break;
1882    }
1883
1884    case Instruction::AND_LONG_2ADDR: {
1885      Binop_12x<HAnd>(instruction, Primitive::kPrimLong);
1886      break;
1887    }
1888
1889    case Instruction::OR_INT_2ADDR: {
1890      Binop_12x<HOr>(instruction, Primitive::kPrimInt);
1891      break;
1892    }
1893
1894    case Instruction::OR_LONG_2ADDR: {
1895      Binop_12x<HOr>(instruction, Primitive::kPrimLong);
1896      break;
1897    }
1898
1899    case Instruction::XOR_INT_2ADDR: {
1900      Binop_12x<HXor>(instruction, Primitive::kPrimInt);
1901      break;
1902    }
1903
1904    case Instruction::XOR_LONG_2ADDR: {
1905      Binop_12x<HXor>(instruction, Primitive::kPrimLong);
1906      break;
1907    }
1908
1909    case Instruction::ADD_INT_LIT16: {
1910      Binop_22s<HAdd>(instruction, false);
1911      break;
1912    }
1913
1914    case Instruction::AND_INT_LIT16: {
1915      Binop_22s<HAnd>(instruction, false);
1916      break;
1917    }
1918
1919    case Instruction::OR_INT_LIT16: {
1920      Binop_22s<HOr>(instruction, false);
1921      break;
1922    }
1923
1924    case Instruction::XOR_INT_LIT16: {
1925      Binop_22s<HXor>(instruction, false);
1926      break;
1927    }
1928
1929    case Instruction::RSUB_INT: {
1930      Binop_22s<HSub>(instruction, true);
1931      break;
1932    }
1933
1934    case Instruction::MUL_INT_LIT16: {
1935      Binop_22s<HMul>(instruction, false);
1936      break;
1937    }
1938
1939    case Instruction::ADD_INT_LIT8: {
1940      Binop_22b<HAdd>(instruction, false);
1941      break;
1942    }
1943
1944    case Instruction::AND_INT_LIT8: {
1945      Binop_22b<HAnd>(instruction, false);
1946      break;
1947    }
1948
1949    case Instruction::OR_INT_LIT8: {
1950      Binop_22b<HOr>(instruction, false);
1951      break;
1952    }
1953
1954    case Instruction::XOR_INT_LIT8: {
1955      Binop_22b<HXor>(instruction, false);
1956      break;
1957    }
1958
1959    case Instruction::RSUB_INT_LIT8: {
1960      Binop_22b<HSub>(instruction, true);
1961      break;
1962    }
1963
1964    case Instruction::MUL_INT_LIT8: {
1965      Binop_22b<HMul>(instruction, false);
1966      break;
1967    }
1968
1969    case Instruction::DIV_INT_LIT16:
1970    case Instruction::DIV_INT_LIT8: {
1971      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(),
1972                         dex_pc, Primitive::kPrimInt, true, true);
1973      break;
1974    }
1975
1976    case Instruction::REM_INT_LIT16:
1977    case Instruction::REM_INT_LIT8: {
1978      BuildCheckedDivRem(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(),
1979                         dex_pc, Primitive::kPrimInt, true, false);
1980      break;
1981    }
1982
1983    case Instruction::SHL_INT_LIT8: {
1984      Binop_22b<HShl>(instruction, false);
1985      break;
1986    }
1987
1988    case Instruction::SHR_INT_LIT8: {
1989      Binop_22b<HShr>(instruction, false);
1990      break;
1991    }
1992
1993    case Instruction::USHR_INT_LIT8: {
1994      Binop_22b<HUShr>(instruction, false);
1995      break;
1996    }
1997
1998    case Instruction::NEW_INSTANCE: {
1999      uint16_t type_index = instruction.VRegB_21c();
2000      if (compiler_driver_->IsStringTypeIndex(type_index, dex_file_)) {
2001        // Turn new-instance of string into a const 0.
2002        int32_t register_index = instruction.VRegA();
2003        HNullConstant* constant = graph_->GetNullConstant();
2004        UpdateLocal(register_index, constant);
2005      } else {
2006        QuickEntrypointEnum entrypoint = NeedsAccessCheck(type_index)
2007            ? kQuickAllocObjectWithAccessCheck
2008            : kQuickAllocObject;
2009
2010        current_block_->AddInstruction(new (arena_) HNewInstance(
2011            dex_pc, type_index, *dex_compilation_unit_->GetDexFile(), entrypoint));
2012        UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction());
2013      }
2014      break;
2015    }
2016
2017    case Instruction::NEW_ARRAY: {
2018      uint16_t type_index = instruction.VRegC_22c();
2019      HInstruction* length = LoadLocal(instruction.VRegB_22c(), Primitive::kPrimInt);
2020      QuickEntrypointEnum entrypoint = NeedsAccessCheck(type_index)
2021          ? kQuickAllocArrayWithAccessCheck
2022          : kQuickAllocArray;
2023      current_block_->AddInstruction(new (arena_) HNewArray(
2024          length, dex_pc, type_index, *dex_compilation_unit_->GetDexFile(), entrypoint));
2025      UpdateLocal(instruction.VRegA_22c(), current_block_->GetLastInstruction());
2026      break;
2027    }
2028
2029    case Instruction::FILLED_NEW_ARRAY: {
2030      uint32_t number_of_vreg_arguments = instruction.VRegA_35c();
2031      uint32_t type_index = instruction.VRegB_35c();
2032      uint32_t args[5];
2033      instruction.GetVarArgs(args);
2034      BuildFilledNewArray(dex_pc, type_index, number_of_vreg_arguments, false, args, 0);
2035      break;
2036    }
2037
2038    case Instruction::FILLED_NEW_ARRAY_RANGE: {
2039      uint32_t number_of_vreg_arguments = instruction.VRegA_3rc();
2040      uint32_t type_index = instruction.VRegB_3rc();
2041      uint32_t register_index = instruction.VRegC_3rc();
2042      BuildFilledNewArray(
2043          dex_pc, type_index, number_of_vreg_arguments, true, nullptr, register_index);
2044      break;
2045    }
2046
2047    case Instruction::FILL_ARRAY_DATA: {
2048      BuildFillArrayData(instruction, dex_pc);
2049      break;
2050    }
2051
2052    case Instruction::MOVE_RESULT:
2053    case Instruction::MOVE_RESULT_WIDE:
2054    case Instruction::MOVE_RESULT_OBJECT:
2055      UpdateLocal(instruction.VRegA(), latest_result_);
2056      latest_result_ = nullptr;
2057      break;
2058
2059    case Instruction::CMP_LONG: {
2060      Binop_23x_cmp(instruction, Primitive::kPrimLong, HCompare::kNoBias);
2061      break;
2062    }
2063
2064    case Instruction::CMPG_FLOAT: {
2065      Binop_23x_cmp(instruction, Primitive::kPrimFloat, HCompare::kGtBias);
2066      break;
2067    }
2068
2069    case Instruction::CMPG_DOUBLE: {
2070      Binop_23x_cmp(instruction, Primitive::kPrimDouble, HCompare::kGtBias);
2071      break;
2072    }
2073
2074    case Instruction::CMPL_FLOAT: {
2075      Binop_23x_cmp(instruction, Primitive::kPrimFloat, HCompare::kLtBias);
2076      break;
2077    }
2078
2079    case Instruction::CMPL_DOUBLE: {
2080      Binop_23x_cmp(instruction, Primitive::kPrimDouble, HCompare::kLtBias);
2081      break;
2082    }
2083
2084    case Instruction::NOP:
2085      break;
2086
2087    case Instruction::IGET:
2088    case Instruction::IGET_WIDE:
2089    case Instruction::IGET_OBJECT:
2090    case Instruction::IGET_BOOLEAN:
2091    case Instruction::IGET_BYTE:
2092    case Instruction::IGET_CHAR:
2093    case Instruction::IGET_SHORT: {
2094      if (!BuildInstanceFieldAccess(instruction, dex_pc, false)) {
2095        return false;
2096      }
2097      break;
2098    }
2099
2100    case Instruction::IPUT:
2101    case Instruction::IPUT_WIDE:
2102    case Instruction::IPUT_OBJECT:
2103    case Instruction::IPUT_BOOLEAN:
2104    case Instruction::IPUT_BYTE:
2105    case Instruction::IPUT_CHAR:
2106    case Instruction::IPUT_SHORT: {
2107      if (!BuildInstanceFieldAccess(instruction, dex_pc, true)) {
2108        return false;
2109      }
2110      break;
2111    }
2112
2113    case Instruction::SGET:
2114    case Instruction::SGET_WIDE:
2115    case Instruction::SGET_OBJECT:
2116    case Instruction::SGET_BOOLEAN:
2117    case Instruction::SGET_BYTE:
2118    case Instruction::SGET_CHAR:
2119    case Instruction::SGET_SHORT: {
2120      if (!BuildStaticFieldAccess(instruction, dex_pc, false)) {
2121        return false;
2122      }
2123      break;
2124    }
2125
2126    case Instruction::SPUT:
2127    case Instruction::SPUT_WIDE:
2128    case Instruction::SPUT_OBJECT:
2129    case Instruction::SPUT_BOOLEAN:
2130    case Instruction::SPUT_BYTE:
2131    case Instruction::SPUT_CHAR:
2132    case Instruction::SPUT_SHORT: {
2133      if (!BuildStaticFieldAccess(instruction, dex_pc, true)) {
2134        return false;
2135      }
2136      break;
2137    }
2138
2139#define ARRAY_XX(kind, anticipated_type)                                          \
2140    case Instruction::AGET##kind: {                                               \
2141      BuildArrayAccess(instruction, dex_pc, false, anticipated_type);         \
2142      break;                                                                      \
2143    }                                                                             \
2144    case Instruction::APUT##kind: {                                               \
2145      BuildArrayAccess(instruction, dex_pc, true, anticipated_type);          \
2146      break;                                                                      \
2147    }
2148
2149    ARRAY_XX(, Primitive::kPrimInt);
2150    ARRAY_XX(_WIDE, Primitive::kPrimLong);
2151    ARRAY_XX(_OBJECT, Primitive::kPrimNot);
2152    ARRAY_XX(_BOOLEAN, Primitive::kPrimBoolean);
2153    ARRAY_XX(_BYTE, Primitive::kPrimByte);
2154    ARRAY_XX(_CHAR, Primitive::kPrimChar);
2155    ARRAY_XX(_SHORT, Primitive::kPrimShort);
2156
2157    case Instruction::ARRAY_LENGTH: {
2158      HInstruction* object = LoadLocal(instruction.VRegB_12x(), Primitive::kPrimNot);
2159      // No need for a temporary for the null check, it is the only input of the following
2160      // instruction.
2161      object = new (arena_) HNullCheck(object, dex_pc);
2162      current_block_->AddInstruction(object);
2163      current_block_->AddInstruction(new (arena_) HArrayLength(object));
2164      UpdateLocal(instruction.VRegA_12x(), current_block_->GetLastInstruction());
2165      break;
2166    }
2167
2168    case Instruction::CONST_STRING: {
2169      current_block_->AddInstruction(
2170          new (arena_) HLoadString(graph_->GetCurrentMethod(), instruction.VRegB_21c(), dex_pc));
2171      UpdateLocal(instruction.VRegA_21c(), current_block_->GetLastInstruction());
2172      break;
2173    }
2174
2175    case Instruction::CONST_STRING_JUMBO: {
2176      current_block_->AddInstruction(
2177          new (arena_) HLoadString(graph_->GetCurrentMethod(), instruction.VRegB_31c(), dex_pc));
2178      UpdateLocal(instruction.VRegA_31c(), current_block_->GetLastInstruction());
2179      break;
2180    }
2181
2182    case Instruction::CONST_CLASS: {
2183      uint16_t type_index = instruction.VRegB_21c();
2184      bool type_known_final;
2185      bool type_known_abstract;
2186      bool dont_use_is_referrers_class;
2187      // `CanAccessTypeWithoutChecks` will tell whether the method being
2188      // built is trying to access its own class, so that the generated
2189      // code can optimize for this case. However, the optimization does not
2190      // work for inlining, so we use `IsOutermostCompilingClass` instead.
2191      bool can_access = compiler_driver_->CanAccessTypeWithoutChecks(
2192          dex_compilation_unit_->GetDexMethodIndex(), *dex_file_, type_index,
2193          &type_known_final, &type_known_abstract, &dont_use_is_referrers_class);
2194      if (!can_access) {
2195        MaybeRecordStat(MethodCompilationStat::kNotCompiledCantAccesType);
2196        return false;
2197      }
2198      current_block_->AddInstruction(new (arena_) HLoadClass(
2199          graph_->GetCurrentMethod(),
2200          type_index,
2201          *dex_compilation_unit_->GetDexFile(),
2202          IsOutermostCompilingClass(type_index),
2203          dex_pc));
2204      UpdateLocal(instruction.VRegA_21c(), current_block_->GetLastInstruction());
2205      break;
2206    }
2207
2208    case Instruction::MOVE_EXCEPTION: {
2209      current_block_->AddInstruction(new (arena_) HLoadException());
2210      UpdateLocal(instruction.VRegA_11x(), current_block_->GetLastInstruction());
2211      break;
2212    }
2213
2214    case Instruction::THROW: {
2215      HInstruction* exception = LoadLocal(instruction.VRegA_11x(), Primitive::kPrimNot);
2216      current_block_->AddInstruction(new (arena_) HThrow(exception, dex_pc));
2217      // A throw instruction must branch to the exit block.
2218      current_block_->AddSuccessor(exit_block_);
2219      // We finished building this block. Set the current block to null to avoid
2220      // adding dead instructions to it.
2221      current_block_ = nullptr;
2222      break;
2223    }
2224
2225    case Instruction::INSTANCE_OF: {
2226      uint8_t destination = instruction.VRegA_22c();
2227      uint8_t reference = instruction.VRegB_22c();
2228      uint16_t type_index = instruction.VRegC_22c();
2229      if (!BuildTypeCheck(instruction, destination, reference, type_index, dex_pc)) {
2230        return false;
2231      }
2232      break;
2233    }
2234
2235    case Instruction::CHECK_CAST: {
2236      uint8_t reference = instruction.VRegA_21c();
2237      uint16_t type_index = instruction.VRegB_21c();
2238      if (!BuildTypeCheck(instruction, -1, reference, type_index, dex_pc)) {
2239        return false;
2240      }
2241      break;
2242    }
2243
2244    case Instruction::MONITOR_ENTER: {
2245      current_block_->AddInstruction(new (arena_) HMonitorOperation(
2246          LoadLocal(instruction.VRegA_11x(), Primitive::kPrimNot),
2247          HMonitorOperation::kEnter,
2248          dex_pc));
2249      break;
2250    }
2251
2252    case Instruction::MONITOR_EXIT: {
2253      current_block_->AddInstruction(new (arena_) HMonitorOperation(
2254          LoadLocal(instruction.VRegA_11x(), Primitive::kPrimNot),
2255          HMonitorOperation::kExit,
2256          dex_pc));
2257      break;
2258    }
2259
2260    case Instruction::PACKED_SWITCH: {
2261      BuildPackedSwitch(instruction, dex_pc);
2262      break;
2263    }
2264
2265    case Instruction::SPARSE_SWITCH: {
2266      BuildSparseSwitch(instruction, dex_pc);
2267      break;
2268    }
2269
2270    default:
2271      VLOG(compiler) << "Did not compile "
2272                     << PrettyMethod(dex_compilation_unit_->GetDexMethodIndex(), *dex_file_)
2273                     << " because of unhandled instruction "
2274                     << instruction.Name();
2275      MaybeRecordStat(MethodCompilationStat::kNotCompiledUnhandledInstruction);
2276      return false;
2277  }
2278  return true;
2279}  // NOLINT(readability/fn_size)
2280
2281HLocal* HGraphBuilder::GetLocalAt(int register_index) const {
2282  return locals_.Get(register_index);
2283}
2284
2285void HGraphBuilder::UpdateLocal(int register_index, HInstruction* instruction) const {
2286  HLocal* local = GetLocalAt(register_index);
2287  current_block_->AddInstruction(new (arena_) HStoreLocal(local, instruction));
2288}
2289
2290HInstruction* HGraphBuilder::LoadLocal(int register_index, Primitive::Type type) const {
2291  HLocal* local = GetLocalAt(register_index);
2292  current_block_->AddInstruction(new (arena_) HLoadLocal(local, type));
2293  return current_block_->GetLastInstruction();
2294}
2295
2296}  // namespace art
2297