code_generator.cc revision 87f3fcbd0db352157fc59148e94647ef21b73bce 
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 "code_generator.h"
18
19#ifdef ART_ENABLE_CODEGEN_arm
20#include "code_generator_arm.h"
21#endif
22
23#ifdef ART_ENABLE_CODEGEN_arm64
24#include "code_generator_arm64.h"
25#endif
26
27#ifdef ART_ENABLE_CODEGEN_x86
28#include "code_generator_x86.h"
29#endif
30
31#ifdef ART_ENABLE_CODEGEN_x86_64
32#include "code_generator_x86_64.h"
33#endif
34
35#ifdef ART_ENABLE_CODEGEN_mips
36#include "code_generator_mips.h"
37#endif
38
39#ifdef ART_ENABLE_CODEGEN_mips64
40#include "code_generator_mips64.h"
41#endif
42
43#include "bytecode_utils.h"
44#include "compiled_method.h"
45#include "dex/verified_method.h"
46#include "driver/compiler_driver.h"
47#include "graph_visualizer.h"
48#include "intrinsics.h"
49#include "leb128.h"
50#include "mirror/array-inl.h"
51#include "mirror/object_array-inl.h"
52#include "mirror/object_reference.h"
53#include "mirror/string.h"
54#include "parallel_move_resolver.h"
55#include "ssa_liveness_analysis.h"
56#include "utils/assembler.h"
57
58namespace art {
59
60// Return whether a location is consistent with a type.
61static bool CheckType(Primitive::Type type, Location location) {
62  if (location.IsFpuRegister()
63      || (location.IsUnallocated() && (location.GetPolicy() == Location::kRequiresFpuRegister))) {
64    return (type == Primitive::kPrimFloat) || (type == Primitive::kPrimDouble);
65  } else if (location.IsRegister() ||
66             (location.IsUnallocated() && (location.GetPolicy() == Location::kRequiresRegister))) {
67    return Primitive::IsIntegralType(type) || (type == Primitive::kPrimNot);
68  } else if (location.IsRegisterPair()) {
69    return type == Primitive::kPrimLong;
70  } else if (location.IsFpuRegisterPair()) {
71    return type == Primitive::kPrimDouble;
72  } else if (location.IsStackSlot()) {
73    return (Primitive::IsIntegralType(type) && type != Primitive::kPrimLong)
74           || (type == Primitive::kPrimFloat)
75           || (type == Primitive::kPrimNot);
76  } else if (location.IsDoubleStackSlot()) {
77    return (type == Primitive::kPrimLong) || (type == Primitive::kPrimDouble);
78  } else if (location.IsConstant()) {
79    if (location.GetConstant()->IsIntConstant()) {
80      return Primitive::IsIntegralType(type) && (type != Primitive::kPrimLong);
81    } else if (location.GetConstant()->IsNullConstant()) {
82      return type == Primitive::kPrimNot;
83    } else if (location.GetConstant()->IsLongConstant()) {
84      return type == Primitive::kPrimLong;
85    } else if (location.GetConstant()->IsFloatConstant()) {
86      return type == Primitive::kPrimFloat;
87    } else {
88      return location.GetConstant()->IsDoubleConstant()
89          && (type == Primitive::kPrimDouble);
90    }
91  } else {
92    return location.IsInvalid() || (location.GetPolicy() == Location::kAny);
93  }
94}
95
96// Check that a location summary is consistent with an instruction.
97static bool CheckTypeConsistency(HInstruction* instruction) {
98  LocationSummary* locations = instruction->GetLocations();
99  if (locations == nullptr) {
100    return true;
101  }
102
103  if (locations->Out().IsUnallocated()
104      && (locations->Out().GetPolicy() == Location::kSameAsFirstInput)) {
105    DCHECK(CheckType(instruction->GetType(), locations->InAt(0)))
106        << instruction->GetType()
107        << " " << locations->InAt(0);
108  } else {
109    DCHECK(CheckType(instruction->GetType(), locations->Out()))
110        << instruction->GetType()
111        << " " << locations->Out();
112  }
113
114  auto&& inputs = instruction->GetInputs();
115  for (size_t i = 0; i < inputs.size(); ++i) {
116    DCHECK(CheckType(inputs[i]->GetType(), locations->InAt(i)))
117      << inputs[i]->GetType() << " " << locations->InAt(i);
118  }
119
120  HEnvironment* environment = instruction->GetEnvironment();
121  for (size_t i = 0; i < instruction->EnvironmentSize(); ++i) {
122    if (environment->GetInstructionAt(i) != nullptr) {
123      Primitive::Type type = environment->GetInstructionAt(i)->GetType();
124      DCHECK(CheckType(type, environment->GetLocationAt(i)))
125        << type << " " << environment->GetLocationAt(i);
126    } else {
127      DCHECK(environment->GetLocationAt(i).IsInvalid())
128        << environment->GetLocationAt(i);
129    }
130  }
131  return true;
132}
133
134size_t CodeGenerator::GetCacheOffset(uint32_t index) {
135  return sizeof(GcRoot<mirror::Object>) * index;
136}
137
138size_t CodeGenerator::GetCachePointerOffset(uint32_t index) {
139  auto pointer_size = InstructionSetPointerSize(GetInstructionSet());
140  return pointer_size * index;
141}
142
143uint32_t CodeGenerator::GetArrayLengthOffset(HArrayLength* array_length) {
144  return array_length->IsStringLength()
145      ? mirror::String::CountOffset().Uint32Value()
146      : mirror::Array::LengthOffset().Uint32Value();
147}
148
149uint32_t CodeGenerator::GetArrayDataOffset(HArrayGet* array_get) {
150  DCHECK(array_get->GetType() == Primitive::kPrimChar || !array_get->IsStringCharAt());
151  return array_get->IsStringCharAt()
152      ? mirror::String::ValueOffset().Uint32Value()
153      : mirror::Array::DataOffset(Primitive::ComponentSize(array_get->GetType())).Uint32Value();
154}
155
156bool CodeGenerator::GoesToNextBlock(HBasicBlock* current, HBasicBlock* next) const {
157  DCHECK_EQ((*block_order_)[current_block_index_], current);
158  return GetNextBlockToEmit() == FirstNonEmptyBlock(next);
159}
160
161HBasicBlock* CodeGenerator::GetNextBlockToEmit() const {
162  for (size_t i = current_block_index_ + 1; i < block_order_->size(); ++i) {
163    HBasicBlock* block = (*block_order_)[i];
164    if (!block->IsSingleJump()) {
165      return block;
166    }
167  }
168  return nullptr;
169}
170
171HBasicBlock* CodeGenerator::FirstNonEmptyBlock(HBasicBlock* block) const {
172  while (block->IsSingleJump()) {
173    block = block->GetSuccessors()[0];
174  }
175  return block;
176}
177
178class DisassemblyScope {
179 public:
180  DisassemblyScope(HInstruction* instruction, const CodeGenerator& codegen)
181      : codegen_(codegen), instruction_(instruction), start_offset_(static_cast<size_t>(-1)) {
182    if (codegen_.GetDisassemblyInformation() != nullptr) {
183      start_offset_ = codegen_.GetAssembler().CodeSize();
184    }
185  }
186
187  ~DisassemblyScope() {
188    // We avoid building this data when we know it will not be used.
189    if (codegen_.GetDisassemblyInformation() != nullptr) {
190      codegen_.GetDisassemblyInformation()->AddInstructionInterval(
191          instruction_, start_offset_, codegen_.GetAssembler().CodeSize());
192    }
193  }
194
195 private:
196  const CodeGenerator& codegen_;
197  HInstruction* instruction_;
198  size_t start_offset_;
199};
200
201
202void CodeGenerator::GenerateSlowPaths() {
203  size_t code_start = 0;
204  for (const std::unique_ptr<SlowPathCode>& slow_path_unique_ptr : slow_paths_) {
205    SlowPathCode* slow_path = slow_path_unique_ptr.get();
206    current_slow_path_ = slow_path;
207    if (disasm_info_ != nullptr) {
208      code_start = GetAssembler()->CodeSize();
209    }
210    // Record the dex pc at start of slow path (required for java line number mapping).
211    MaybeRecordNativeDebugInfo(slow_path->GetInstruction(), slow_path->GetDexPc(), slow_path);
212    slow_path->EmitNativeCode(this);
213    if (disasm_info_ != nullptr) {
214      disasm_info_->AddSlowPathInterval(slow_path, code_start, GetAssembler()->CodeSize());
215    }
216  }
217  current_slow_path_ = nullptr;
218}
219
220void CodeGenerator::Compile(CodeAllocator* allocator) {
221  // The register allocator already called `InitializeCodeGeneration`,
222  // where the frame size has been computed.
223  DCHECK(block_order_ != nullptr);
224  Initialize();
225
226  HGraphVisitor* instruction_visitor = GetInstructionVisitor();
227  DCHECK_EQ(current_block_index_, 0u);
228
229  size_t frame_start = GetAssembler()->CodeSize();
230  GenerateFrameEntry();
231  DCHECK_EQ(GetAssembler()->cfi().GetCurrentCFAOffset(), static_cast<int>(frame_size_));
232  if (disasm_info_ != nullptr) {
233    disasm_info_->SetFrameEntryInterval(frame_start, GetAssembler()->CodeSize());
234  }
235
236  for (size_t e = block_order_->size(); current_block_index_ < e; ++current_block_index_) {
237    HBasicBlock* block = (*block_order_)[current_block_index_];
238    // Don't generate code for an empty block. Its predecessors will branch to its successor
239    // directly. Also, the label of that block will not be emitted, so this helps catch
240    // errors where we reference that label.
241    if (block->IsSingleJump()) continue;
242    Bind(block);
243    // This ensures that we have correct native line mapping for all native instructions.
244    // It is necessary to make stepping over a statement work. Otherwise, any initial
245    // instructions (e.g. moves) would be assumed to be the start of next statement.
246    MaybeRecordNativeDebugInfo(nullptr /* instruction */, block->GetDexPc());
247    for (HInstructionIterator it(block->GetInstructions()); !it.Done(); it.Advance()) {
248      HInstruction* current = it.Current();
249      if (current->HasEnvironment()) {
250        // Create stackmap for HNativeDebugInfo or any instruction which calls native code.
251        // Note that we need correct mapping for the native PC of the call instruction,
252        // so the runtime's stackmap is not sufficient since it is at PC after the call.
253        MaybeRecordNativeDebugInfo(current, block->GetDexPc());
254      }
255      DisassemblyScope disassembly_scope(current, *this);
256      DCHECK(CheckTypeConsistency(current));
257      current->Accept(instruction_visitor);
258    }
259  }
260
261  GenerateSlowPaths();
262
263  // Emit catch stack maps at the end of the stack map stream as expected by the
264  // runtime exception handler.
265  if (graph_->HasTryCatch()) {
266    RecordCatchBlockInfo();
267  }
268
269  // Finalize instructions in assember;
270  Finalize(allocator);
271}
272
273void CodeGenerator::Finalize(CodeAllocator* allocator) {
274  size_t code_size = GetAssembler()->CodeSize();
275  uint8_t* buffer = allocator->Allocate(code_size);
276
277  MemoryRegion code(buffer, code_size);
278  GetAssembler()->FinalizeInstructions(code);
279}
280
281void CodeGenerator::EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches ATTRIBUTE_UNUSED) {
282  // No linker patches by default.
283}
284
285void CodeGenerator::InitializeCodeGeneration(size_t number_of_spill_slots,
286                                             size_t maximum_number_of_live_core_registers,
287                                             size_t maximum_number_of_live_fpu_registers,
288                                             size_t number_of_out_slots,
289                                             const ArenaVector<HBasicBlock*>& block_order) {
290  block_order_ = &block_order;
291  DCHECK(!block_order.empty());
292  DCHECK(block_order[0] == GetGraph()->GetEntryBlock());
293  ComputeSpillMask();
294  first_register_slot_in_slow_path_ = (number_of_out_slots + number_of_spill_slots) * kVRegSize;
295
296  if (number_of_spill_slots == 0
297      && !HasAllocatedCalleeSaveRegisters()
298      && IsLeafMethod()
299      && !RequiresCurrentMethod()) {
300    DCHECK_EQ(maximum_number_of_live_core_registers, 0u);
301    DCHECK_EQ(maximum_number_of_live_fpu_registers, 0u);
302    SetFrameSize(CallPushesPC() ? GetWordSize() : 0);
303  } else {
304    SetFrameSize(RoundUp(
305        number_of_spill_slots * kVRegSize
306        + number_of_out_slots * kVRegSize
307        + maximum_number_of_live_core_registers * GetWordSize()
308        + maximum_number_of_live_fpu_registers * GetFloatingPointSpillSlotSize()
309        + FrameEntrySpillSize(),
310        kStackAlignment));
311  }
312}
313
314void CodeGenerator::CreateCommonInvokeLocationSummary(
315    HInvoke* invoke, InvokeDexCallingConventionVisitor* visitor) {
316  ArenaAllocator* allocator = invoke->GetBlock()->GetGraph()->GetArena();
317  LocationSummary* locations = new (allocator) LocationSummary(invoke, LocationSummary::kCall);
318
319  for (size_t i = 0; i < invoke->GetNumberOfArguments(); i++) {
320    HInstruction* input = invoke->InputAt(i);
321    locations->SetInAt(i, visitor->GetNextLocation(input->GetType()));
322  }
323
324  locations->SetOut(visitor->GetReturnLocation(invoke->GetType()));
325
326  if (invoke->IsInvokeStaticOrDirect()) {
327    HInvokeStaticOrDirect* call = invoke->AsInvokeStaticOrDirect();
328    switch (call->GetMethodLoadKind()) {
329      case HInvokeStaticOrDirect::MethodLoadKind::kRecursive:
330        locations->SetInAt(call->GetSpecialInputIndex(), visitor->GetMethodLocation());
331        break;
332      case HInvokeStaticOrDirect::MethodLoadKind::kDexCacheViaMethod:
333        locations->AddTemp(visitor->GetMethodLocation());
334        locations->SetInAt(call->GetSpecialInputIndex(), Location::RequiresRegister());
335        break;
336      default:
337        locations->AddTemp(visitor->GetMethodLocation());
338        break;
339    }
340  } else {
341    locations->AddTemp(visitor->GetMethodLocation());
342  }
343}
344
345void CodeGenerator::GenerateInvokeUnresolvedRuntimeCall(HInvokeUnresolved* invoke) {
346  MoveConstant(invoke->GetLocations()->GetTemp(0), invoke->GetDexMethodIndex());
347
348  // Initialize to anything to silent compiler warnings.
349  QuickEntrypointEnum entrypoint = kQuickInvokeStaticTrampolineWithAccessCheck;
350  switch (invoke->GetOriginalInvokeType()) {
351    case kStatic:
352      entrypoint = kQuickInvokeStaticTrampolineWithAccessCheck;
353      break;
354    case kDirect:
355      entrypoint = kQuickInvokeDirectTrampolineWithAccessCheck;
356      break;
357    case kVirtual:
358      entrypoint = kQuickInvokeVirtualTrampolineWithAccessCheck;
359      break;
360    case kSuper:
361      entrypoint = kQuickInvokeSuperTrampolineWithAccessCheck;
362      break;
363    case kInterface:
364      entrypoint = kQuickInvokeInterfaceTrampolineWithAccessCheck;
365      break;
366  }
367  InvokeRuntime(entrypoint, invoke, invoke->GetDexPc(), nullptr);
368}
369
370void CodeGenerator::CreateUnresolvedFieldLocationSummary(
371    HInstruction* field_access,
372    Primitive::Type field_type,
373    const FieldAccessCallingConvention& calling_convention) {
374  bool is_instance = field_access->IsUnresolvedInstanceFieldGet()
375      || field_access->IsUnresolvedInstanceFieldSet();
376  bool is_get = field_access->IsUnresolvedInstanceFieldGet()
377      || field_access->IsUnresolvedStaticFieldGet();
378
379  ArenaAllocator* allocator = field_access->GetBlock()->GetGraph()->GetArena();
380  LocationSummary* locations =
381      new (allocator) LocationSummary(field_access, LocationSummary::kCall);
382
383  locations->AddTemp(calling_convention.GetFieldIndexLocation());
384
385  if (is_instance) {
386    // Add the `this` object for instance field accesses.
387    locations->SetInAt(0, calling_convention.GetObjectLocation());
388  }
389
390  // Note that pSetXXStatic/pGetXXStatic always takes/returns an int or int64
391  // regardless of the the type. Because of that we forced to special case
392  // the access to floating point values.
393  if (is_get) {
394    if (Primitive::IsFloatingPointType(field_type)) {
395      // The return value will be stored in regular registers while register
396      // allocator expects it in a floating point register.
397      // Note We don't need to request additional temps because the return
398      // register(s) are already blocked due the call and they may overlap with
399      // the input or field index.
400      // The transfer between the two will be done at codegen level.
401      locations->SetOut(calling_convention.GetFpuLocation(field_type));
402    } else {
403      locations->SetOut(calling_convention.GetReturnLocation(field_type));
404    }
405  } else {
406     size_t set_index = is_instance ? 1 : 0;
407     if (Primitive::IsFloatingPointType(field_type)) {
408      // The set value comes from a float location while the calling convention
409      // expects it in a regular register location. Allocate a temp for it and
410      // make the transfer at codegen.
411      AddLocationAsTemp(calling_convention.GetSetValueLocation(field_type, is_instance), locations);
412      locations->SetInAt(set_index, calling_convention.GetFpuLocation(field_type));
413    } else {
414      locations->SetInAt(set_index,
415          calling_convention.GetSetValueLocation(field_type, is_instance));
416    }
417  }
418}
419
420void CodeGenerator::GenerateUnresolvedFieldAccess(
421    HInstruction* field_access,
422    Primitive::Type field_type,
423    uint32_t field_index,
424    uint32_t dex_pc,
425    const FieldAccessCallingConvention& calling_convention) {
426  LocationSummary* locations = field_access->GetLocations();
427
428  MoveConstant(locations->GetTemp(0), field_index);
429
430  bool is_instance = field_access->IsUnresolvedInstanceFieldGet()
431      || field_access->IsUnresolvedInstanceFieldSet();
432  bool is_get = field_access->IsUnresolvedInstanceFieldGet()
433      || field_access->IsUnresolvedStaticFieldGet();
434
435  if (!is_get && Primitive::IsFloatingPointType(field_type)) {
436    // Copy the float value to be set into the calling convention register.
437    // Note that using directly the temp location is problematic as we don't
438    // support temp register pairs. To avoid boilerplate conversion code, use
439    // the location from the calling convention.
440    MoveLocation(calling_convention.GetSetValueLocation(field_type, is_instance),
441                 locations->InAt(is_instance ? 1 : 0),
442                 (Primitive::Is64BitType(field_type) ? Primitive::kPrimLong : Primitive::kPrimInt));
443  }
444
445  QuickEntrypointEnum entrypoint = kQuickSet8Static;  // Initialize to anything to avoid warnings.
446  switch (field_type) {
447    case Primitive::kPrimBoolean:
448      entrypoint = is_instance
449          ? (is_get ? kQuickGetBooleanInstance : kQuickSet8Instance)
450          : (is_get ? kQuickGetBooleanStatic : kQuickSet8Static);
451      break;
452    case Primitive::kPrimByte:
453      entrypoint = is_instance
454          ? (is_get ? kQuickGetByteInstance : kQuickSet8Instance)
455          : (is_get ? kQuickGetByteStatic : kQuickSet8Static);
456      break;
457    case Primitive::kPrimShort:
458      entrypoint = is_instance
459          ? (is_get ? kQuickGetShortInstance : kQuickSet16Instance)
460          : (is_get ? kQuickGetShortStatic : kQuickSet16Static);
461      break;
462    case Primitive::kPrimChar:
463      entrypoint = is_instance
464          ? (is_get ? kQuickGetCharInstance : kQuickSet16Instance)
465          : (is_get ? kQuickGetCharStatic : kQuickSet16Static);
466      break;
467    case Primitive::kPrimInt:
468    case Primitive::kPrimFloat:
469      entrypoint = is_instance
470          ? (is_get ? kQuickGet32Instance : kQuickSet32Instance)
471          : (is_get ? kQuickGet32Static : kQuickSet32Static);
472      break;
473    case Primitive::kPrimNot:
474      entrypoint = is_instance
475          ? (is_get ? kQuickGetObjInstance : kQuickSetObjInstance)
476          : (is_get ? kQuickGetObjStatic : kQuickSetObjStatic);
477      break;
478    case Primitive::kPrimLong:
479    case Primitive::kPrimDouble:
480      entrypoint = is_instance
481          ? (is_get ? kQuickGet64Instance : kQuickSet64Instance)
482          : (is_get ? kQuickGet64Static : kQuickSet64Static);
483      break;
484    default:
485      LOG(FATAL) << "Invalid type " << field_type;
486  }
487  InvokeRuntime(entrypoint, field_access, dex_pc, nullptr);
488
489  if (is_get && Primitive::IsFloatingPointType(field_type)) {
490    MoveLocation(locations->Out(), calling_convention.GetReturnLocation(field_type), field_type);
491  }
492}
493
494// TODO: Remove argument `code_generator_supports_read_barrier` when
495// all code generators have read barrier support.
496void CodeGenerator::CreateLoadClassLocationSummary(HLoadClass* cls,
497                                                   Location runtime_type_index_location,
498                                                   Location runtime_return_location,
499                                                   bool code_generator_supports_read_barrier) {
500  ArenaAllocator* allocator = cls->GetBlock()->GetGraph()->GetArena();
501  LocationSummary::CallKind call_kind = cls->NeedsAccessCheck()
502      ? LocationSummary::kCall
503      : (((code_generator_supports_read_barrier && kEmitCompilerReadBarrier) ||
504          cls->CanCallRuntime())
505            ? LocationSummary::kCallOnSlowPath
506            : LocationSummary::kNoCall);
507  LocationSummary* locations = new (allocator) LocationSummary(cls, call_kind);
508  if (cls->NeedsAccessCheck()) {
509    locations->SetInAt(0, Location::NoLocation());
510    locations->AddTemp(runtime_type_index_location);
511    locations->SetOut(runtime_return_location);
512  } else {
513    locations->SetInAt(0, Location::RequiresRegister());
514    locations->SetOut(Location::RequiresRegister());
515  }
516}
517
518
519void CodeGenerator::BlockIfInRegister(Location location, bool is_out) const {
520  // The DCHECKS below check that a register is not specified twice in
521  // the summary. The out location can overlap with an input, so we need
522  // to special case it.
523  if (location.IsRegister()) {
524    DCHECK(is_out || !blocked_core_registers_[location.reg()]);
525    blocked_core_registers_[location.reg()] = true;
526  } else if (location.IsFpuRegister()) {
527    DCHECK(is_out || !blocked_fpu_registers_[location.reg()]);
528    blocked_fpu_registers_[location.reg()] = true;
529  } else if (location.IsFpuRegisterPair()) {
530    DCHECK(is_out || !blocked_fpu_registers_[location.AsFpuRegisterPairLow<int>()]);
531    blocked_fpu_registers_[location.AsFpuRegisterPairLow<int>()] = true;
532    DCHECK(is_out || !blocked_fpu_registers_[location.AsFpuRegisterPairHigh<int>()]);
533    blocked_fpu_registers_[location.AsFpuRegisterPairHigh<int>()] = true;
534  } else if (location.IsRegisterPair()) {
535    DCHECK(is_out || !blocked_core_registers_[location.AsRegisterPairLow<int>()]);
536    blocked_core_registers_[location.AsRegisterPairLow<int>()] = true;
537    DCHECK(is_out || !blocked_core_registers_[location.AsRegisterPairHigh<int>()]);
538    blocked_core_registers_[location.AsRegisterPairHigh<int>()] = true;
539  }
540}
541
542void CodeGenerator::AllocateLocations(HInstruction* instruction) {
543  instruction->Accept(GetLocationBuilder());
544  DCHECK(CheckTypeConsistency(instruction));
545  LocationSummary* locations = instruction->GetLocations();
546  if (!instruction->IsSuspendCheckEntry()) {
547    if (locations != nullptr) {
548      if (locations->CanCall()) {
549        MarkNotLeaf();
550      } else if (locations->Intrinsified() &&
551                 instruction->IsInvokeStaticOrDirect() &&
552                 !instruction->AsInvokeStaticOrDirect()->HasCurrentMethodInput()) {
553        // A static method call that has been fully intrinsified, and cannot call on the slow
554        // path or refer to the current method directly, no longer needs current method.
555        return;
556      }
557    }
558    if (instruction->NeedsCurrentMethod()) {
559      SetRequiresCurrentMethod();
560    }
561  }
562}
563
564void CodeGenerator::MaybeRecordStat(MethodCompilationStat compilation_stat, size_t count) const {
565  if (stats_ != nullptr) {
566    stats_->RecordStat(compilation_stat, count);
567  }
568}
569
570std::unique_ptr<CodeGenerator> CodeGenerator::Create(HGraph* graph,
571                                                     InstructionSet instruction_set,
572                                                     const InstructionSetFeatures& isa_features,
573                                                     const CompilerOptions& compiler_options,
574                                                     OptimizingCompilerStats* stats) {
575  ArenaAllocator* arena = graph->GetArena();
576  switch (instruction_set) {
577#ifdef ART_ENABLE_CODEGEN_arm
578    case kArm:
579    case kThumb2: {
580      return std::unique_ptr<CodeGenerator>(
581          new (arena) arm::CodeGeneratorARM(graph,
582                                            *isa_features.AsArmInstructionSetFeatures(),
583                                            compiler_options,
584                                            stats));
585    }
586#endif
587#ifdef ART_ENABLE_CODEGEN_arm64
588    case kArm64: {
589      return std::unique_ptr<CodeGenerator>(
590          new (arena) arm64::CodeGeneratorARM64(graph,
591                                                *isa_features.AsArm64InstructionSetFeatures(),
592                                                compiler_options,
593                                                stats));
594    }
595#endif
596#ifdef ART_ENABLE_CODEGEN_mips
597    case kMips: {
598      return std::unique_ptr<CodeGenerator>(
599          new (arena) mips::CodeGeneratorMIPS(graph,
600                                              *isa_features.AsMipsInstructionSetFeatures(),
601                                              compiler_options,
602                                              stats));
603    }
604#endif
605#ifdef ART_ENABLE_CODEGEN_mips64
606    case kMips64: {
607      return std::unique_ptr<CodeGenerator>(
608          new (arena) mips64::CodeGeneratorMIPS64(graph,
609                                                  *isa_features.AsMips64InstructionSetFeatures(),
610                                                  compiler_options,
611                                                  stats));
612    }
613#endif
614#ifdef ART_ENABLE_CODEGEN_x86
615    case kX86: {
616      return std::unique_ptr<CodeGenerator>(
617          new (arena) x86::CodeGeneratorX86(graph,
618                                            *isa_features.AsX86InstructionSetFeatures(),
619                                            compiler_options,
620                                            stats));
621    }
622#endif
623#ifdef ART_ENABLE_CODEGEN_x86_64
624    case kX86_64: {
625      return std::unique_ptr<CodeGenerator>(
626          new (arena) x86_64::CodeGeneratorX86_64(graph,
627                                                  *isa_features.AsX86_64InstructionSetFeatures(),
628                                                  compiler_options,
629                                                  stats));
630    }
631#endif
632    default:
633      return nullptr;
634  }
635}
636
637size_t CodeGenerator::ComputeStackMapsSize() {
638  return stack_map_stream_.PrepareForFillIn();
639}
640
641static void CheckCovers(uint32_t dex_pc,
642                        const HGraph& graph,
643                        const CodeInfo& code_info,
644                        const ArenaVector<HSuspendCheck*>& loop_headers,
645                        ArenaVector<size_t>* covered) {
646  CodeInfoEncoding encoding = code_info.ExtractEncoding();
647  for (size_t i = 0; i < loop_headers.size(); ++i) {
648    if (loop_headers[i]->GetDexPc() == dex_pc) {
649      if (graph.IsCompilingOsr()) {
650        DCHECK(code_info.GetOsrStackMapForDexPc(dex_pc, encoding).IsValid());
651      }
652      ++(*covered)[i];
653    }
654  }
655}
656
657// Debug helper to ensure loop entries in compiled code are matched by
658// dex branch instructions.
659static void CheckLoopEntriesCanBeUsedForOsr(const HGraph& graph,
660                                            const CodeInfo& code_info,
661                                            const DexFile::CodeItem& code_item) {
662  if (graph.HasTryCatch()) {
663    // One can write loops through try/catch, which we do not support for OSR anyway.
664    return;
665  }
666  ArenaVector<HSuspendCheck*> loop_headers(graph.GetArena()->Adapter(kArenaAllocMisc));
667  for (HReversePostOrderIterator it(graph); !it.Done(); it.Advance()) {
668    if (it.Current()->IsLoopHeader()) {
669      HSuspendCheck* suspend_check = it.Current()->GetLoopInformation()->GetSuspendCheck();
670      if (!suspend_check->GetEnvironment()->IsFromInlinedInvoke()) {
671        loop_headers.push_back(suspend_check);
672      }
673    }
674  }
675  ArenaVector<size_t> covered(loop_headers.size(), 0, graph.GetArena()->Adapter(kArenaAllocMisc));
676  const uint16_t* code_ptr = code_item.insns_;
677  const uint16_t* code_end = code_item.insns_ + code_item.insns_size_in_code_units_;
678
679  size_t dex_pc = 0;
680  while (code_ptr < code_end) {
681    const Instruction& instruction = *Instruction::At(code_ptr);
682    if (instruction.IsBranch()) {
683      uint32_t target = dex_pc + instruction.GetTargetOffset();
684      CheckCovers(target, graph, code_info, loop_headers, &covered);
685    } else if (instruction.IsSwitch()) {
686      DexSwitchTable table(instruction, dex_pc);
687      uint16_t num_entries = table.GetNumEntries();
688      size_t offset = table.GetFirstValueIndex();
689
690      // Use a larger loop counter type to avoid overflow issues.
691      for (size_t i = 0; i < num_entries; ++i) {
692        // The target of the case.
693        uint32_t target = dex_pc + table.GetEntryAt(i + offset);
694        CheckCovers(target, graph, code_info, loop_headers, &covered);
695      }
696    }
697    dex_pc += instruction.SizeInCodeUnits();
698    code_ptr += instruction.SizeInCodeUnits();
699  }
700
701  for (size_t i = 0; i < covered.size(); ++i) {
702    DCHECK_NE(covered[i], 0u) << "Loop in compiled code has no dex branch equivalent";
703  }
704}
705
706void CodeGenerator::BuildStackMaps(MemoryRegion region, const DexFile::CodeItem& code_item) {
707  stack_map_stream_.FillIn(region);
708  if (kIsDebugBuild) {
709    CheckLoopEntriesCanBeUsedForOsr(*graph_, CodeInfo(region), code_item);
710  }
711}
712
713void CodeGenerator::RecordPcInfo(HInstruction* instruction,
714                                 uint32_t dex_pc,
715                                 SlowPathCode* slow_path) {
716  if (instruction != nullptr) {
717    // The code generated for some type conversions
718    // may call the runtime, thus normally requiring a subsequent
719    // call to this method. However, the method verifier does not
720    // produce PC information for certain instructions, which are
721    // considered "atomic" (they cannot join a GC).
722    // Therefore we do not currently record PC information for such
723    // instructions.  As this may change later, we added this special
724    // case so that code generators may nevertheless call
725    // CodeGenerator::RecordPcInfo without triggering an error in
726    // CodeGenerator::BuildNativeGCMap ("Missing ref for dex pc 0x")
727    // thereafter.
728    if (instruction->IsTypeConversion()) {
729      return;
730    }
731    if (instruction->IsRem()) {
732      Primitive::Type type = instruction->AsRem()->GetResultType();
733      if ((type == Primitive::kPrimFloat) || (type == Primitive::kPrimDouble)) {
734        return;
735      }
736    }
737  }
738
739  uint32_t outer_dex_pc = dex_pc;
740  uint32_t outer_environment_size = 0;
741  uint32_t inlining_depth = 0;
742  if (instruction != nullptr) {
743    for (HEnvironment* environment = instruction->GetEnvironment();
744         environment != nullptr;
745         environment = environment->GetParent()) {
746      outer_dex_pc = environment->GetDexPc();
747      outer_environment_size = environment->Size();
748      if (environment != instruction->GetEnvironment()) {
749        inlining_depth++;
750      }
751    }
752  }
753
754  // Collect PC infos for the mapping table.
755  uint32_t native_pc = GetAssembler()->CodeSize();
756
757  if (instruction == nullptr) {
758    // For stack overflow checks and native-debug-info entries without dex register
759    // mapping (i.e. start of basic block or start of slow path).
760    stack_map_stream_.BeginStackMapEntry(outer_dex_pc, native_pc, 0, 0, 0, 0);
761    stack_map_stream_.EndStackMapEntry();
762    return;
763  }
764  LocationSummary* locations = instruction->GetLocations();
765
766  uint32_t register_mask = locations->GetRegisterMask();
767  if (locations->OnlyCallsOnSlowPath()) {
768    // In case of slow path, we currently set the location of caller-save registers
769    // to register (instead of their stack location when pushed before the slow-path
770    // call). Therefore register_mask contains both callee-save and caller-save
771    // registers that hold objects. We must remove the caller-save from the mask, since
772    // they will be overwritten by the callee.
773    register_mask &= core_callee_save_mask_;
774  }
775  // The register mask must be a subset of callee-save registers.
776  DCHECK_EQ(register_mask & core_callee_save_mask_, register_mask);
777  stack_map_stream_.BeginStackMapEntry(outer_dex_pc,
778                                       native_pc,
779                                       register_mask,
780                                       locations->GetStackMask(),
781                                       outer_environment_size,
782                                       inlining_depth);
783
784  EmitEnvironment(instruction->GetEnvironment(), slow_path);
785  stack_map_stream_.EndStackMapEntry();
786
787  HLoopInformation* info = instruction->GetBlock()->GetLoopInformation();
788  if (instruction->IsSuspendCheck() &&
789      (info != nullptr) &&
790      graph_->IsCompilingOsr() &&
791      (inlining_depth == 0)) {
792    DCHECK_EQ(info->GetSuspendCheck(), instruction);
793    // We duplicate the stack map as a marker that this stack map can be an OSR entry.
794    // Duplicating it avoids having the runtime recognize and skip an OSR stack map.
795    DCHECK(info->IsIrreducible());
796    stack_map_stream_.BeginStackMapEntry(
797        dex_pc, native_pc, register_mask, locations->GetStackMask(), outer_environment_size, 0);
798    EmitEnvironment(instruction->GetEnvironment(), slow_path);
799    stack_map_stream_.EndStackMapEntry();
800    if (kIsDebugBuild) {
801      HEnvironment* environment = instruction->GetEnvironment();
802      for (size_t i = 0, environment_size = environment->Size(); i < environment_size; ++i) {
803        HInstruction* in_environment = environment->GetInstructionAt(i);
804        if (in_environment != nullptr) {
805          DCHECK(in_environment->IsPhi() || in_environment->IsConstant());
806          Location location = environment->GetLocationAt(i);
807          DCHECK(location.IsStackSlot() ||
808                 location.IsDoubleStackSlot() ||
809                 location.IsConstant() ||
810                 location.IsInvalid());
811          if (location.IsStackSlot() || location.IsDoubleStackSlot()) {
812            DCHECK_LT(location.GetStackIndex(), static_cast<int32_t>(GetFrameSize()));
813          }
814        }
815      }
816    }
817  } else if (kIsDebugBuild) {
818    // Ensure stack maps are unique, by checking that the native pc in the stack map
819    // last emitted is different than the native pc of the stack map just emitted.
820    size_t number_of_stack_maps = stack_map_stream_.GetNumberOfStackMaps();
821    if (number_of_stack_maps > 1) {
822      DCHECK_NE(stack_map_stream_.GetStackMap(number_of_stack_maps - 1).native_pc_offset,
823                stack_map_stream_.GetStackMap(number_of_stack_maps - 2).native_pc_offset);
824    }
825  }
826}
827
828bool CodeGenerator::HasStackMapAtCurrentPc() {
829  uint32_t pc = GetAssembler()->CodeSize();
830  size_t count = stack_map_stream_.GetNumberOfStackMaps();
831  return count > 0 && stack_map_stream_.GetStackMap(count - 1).native_pc_offset == pc;
832}
833
834void CodeGenerator::MaybeRecordNativeDebugInfo(HInstruction* instruction,
835                                               uint32_t dex_pc,
836                                               SlowPathCode* slow_path) {
837  if (GetCompilerOptions().GetNativeDebuggable() && dex_pc != kNoDexPc) {
838    if (HasStackMapAtCurrentPc()) {
839      // Ensure that we do not collide with the stack map of the previous instruction.
840      GenerateNop();
841    }
842    RecordPcInfo(instruction, dex_pc, slow_path);
843  }
844}
845
846void CodeGenerator::RecordCatchBlockInfo() {
847  ArenaAllocator* arena = graph_->GetArena();
848
849  for (HBasicBlock* block : *block_order_) {
850    if (!block->IsCatchBlock()) {
851      continue;
852    }
853
854    uint32_t dex_pc = block->GetDexPc();
855    uint32_t num_vregs = graph_->GetNumberOfVRegs();
856    uint32_t inlining_depth = 0;  // Inlining of catch blocks is not supported at the moment.
857    uint32_t native_pc = GetAddressOf(block);
858    uint32_t register_mask = 0;   // Not used.
859
860    // The stack mask is not used, so we leave it empty.
861    ArenaBitVector* stack_mask =
862        ArenaBitVector::Create(arena, 0, /* expandable */ true, kArenaAllocCodeGenerator);
863
864    stack_map_stream_.BeginStackMapEntry(dex_pc,
865                                         native_pc,
866                                         register_mask,
867                                         stack_mask,
868                                         num_vregs,
869                                         inlining_depth);
870
871    HInstruction* current_phi = block->GetFirstPhi();
872    for (size_t vreg = 0; vreg < num_vregs; ++vreg) {
873    while (current_phi != nullptr && current_phi->AsPhi()->GetRegNumber() < vreg) {
874      HInstruction* next_phi = current_phi->GetNext();
875      DCHECK(next_phi == nullptr ||
876             current_phi->AsPhi()->GetRegNumber() <= next_phi->AsPhi()->GetRegNumber())
877          << "Phis need to be sorted by vreg number to keep this a linear-time loop.";
878      current_phi = next_phi;
879    }
880
881      if (current_phi == nullptr || current_phi->AsPhi()->GetRegNumber() != vreg) {
882        stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kNone, 0);
883      } else {
884        Location location = current_phi->GetLiveInterval()->ToLocation();
885        switch (location.GetKind()) {
886          case Location::kStackSlot: {
887            stack_map_stream_.AddDexRegisterEntry(
888                DexRegisterLocation::Kind::kInStack, location.GetStackIndex());
889            break;
890          }
891          case Location::kDoubleStackSlot: {
892            stack_map_stream_.AddDexRegisterEntry(
893                DexRegisterLocation::Kind::kInStack, location.GetStackIndex());
894            stack_map_stream_.AddDexRegisterEntry(
895                DexRegisterLocation::Kind::kInStack, location.GetHighStackIndex(kVRegSize));
896            ++vreg;
897            DCHECK_LT(vreg, num_vregs);
898            break;
899          }
900          default: {
901            // All catch phis must be allocated to a stack slot.
902            LOG(FATAL) << "Unexpected kind " << location.GetKind();
903            UNREACHABLE();
904          }
905        }
906      }
907    }
908
909    stack_map_stream_.EndStackMapEntry();
910  }
911}
912
913void CodeGenerator::EmitEnvironment(HEnvironment* environment, SlowPathCode* slow_path) {
914  if (environment == nullptr) return;
915
916  if (environment->GetParent() != nullptr) {
917    // We emit the parent environment first.
918    EmitEnvironment(environment->GetParent(), slow_path);
919    stack_map_stream_.BeginInlineInfoEntry(environment->GetMethodIdx(),
920                                           environment->GetDexPc(),
921                                           environment->GetInvokeType(),
922                                           environment->Size());
923  }
924
925  // Walk over the environment, and record the location of dex registers.
926  for (size_t i = 0, environment_size = environment->Size(); i < environment_size; ++i) {
927    HInstruction* current = environment->GetInstructionAt(i);
928    if (current == nullptr) {
929      stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kNone, 0);
930      continue;
931    }
932
933    Location location = environment->GetLocationAt(i);
934    switch (location.GetKind()) {
935      case Location::kConstant: {
936        DCHECK_EQ(current, location.GetConstant());
937        if (current->IsLongConstant()) {
938          int64_t value = current->AsLongConstant()->GetValue();
939          stack_map_stream_.AddDexRegisterEntry(
940              DexRegisterLocation::Kind::kConstant, Low32Bits(value));
941          stack_map_stream_.AddDexRegisterEntry(
942              DexRegisterLocation::Kind::kConstant, High32Bits(value));
943          ++i;
944          DCHECK_LT(i, environment_size);
945        } else if (current->IsDoubleConstant()) {
946          int64_t value = bit_cast<int64_t, double>(current->AsDoubleConstant()->GetValue());
947          stack_map_stream_.AddDexRegisterEntry(
948              DexRegisterLocation::Kind::kConstant, Low32Bits(value));
949          stack_map_stream_.AddDexRegisterEntry(
950              DexRegisterLocation::Kind::kConstant, High32Bits(value));
951          ++i;
952          DCHECK_LT(i, environment_size);
953        } else if (current->IsIntConstant()) {
954          int32_t value = current->AsIntConstant()->GetValue();
955          stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kConstant, value);
956        } else if (current->IsNullConstant()) {
957          stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kConstant, 0);
958        } else {
959          DCHECK(current->IsFloatConstant()) << current->DebugName();
960          int32_t value = bit_cast<int32_t, float>(current->AsFloatConstant()->GetValue());
961          stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kConstant, value);
962        }
963        break;
964      }
965
966      case Location::kStackSlot: {
967        stack_map_stream_.AddDexRegisterEntry(
968            DexRegisterLocation::Kind::kInStack, location.GetStackIndex());
969        break;
970      }
971
972      case Location::kDoubleStackSlot: {
973        stack_map_stream_.AddDexRegisterEntry(
974            DexRegisterLocation::Kind::kInStack, location.GetStackIndex());
975        stack_map_stream_.AddDexRegisterEntry(
976            DexRegisterLocation::Kind::kInStack, location.GetHighStackIndex(kVRegSize));
977        ++i;
978        DCHECK_LT(i, environment_size);
979        break;
980      }
981
982      case Location::kRegister : {
983        int id = location.reg();
984        if (slow_path != nullptr && slow_path->IsCoreRegisterSaved(id)) {
985          uint32_t offset = slow_path->GetStackOffsetOfCoreRegister(id);
986          stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kInStack, offset);
987          if (current->GetType() == Primitive::kPrimLong) {
988            stack_map_stream_.AddDexRegisterEntry(
989                DexRegisterLocation::Kind::kInStack, offset + kVRegSize);
990            ++i;
991            DCHECK_LT(i, environment_size);
992          }
993        } else {
994          stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kInRegister, id);
995          if (current->GetType() == Primitive::kPrimLong) {
996            stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kInRegisterHigh, id);
997            ++i;
998            DCHECK_LT(i, environment_size);
999          }
1000        }
1001        break;
1002      }
1003
1004      case Location::kFpuRegister : {
1005        int id = location.reg();
1006        if (slow_path != nullptr && slow_path->IsFpuRegisterSaved(id)) {
1007          uint32_t offset = slow_path->GetStackOffsetOfFpuRegister(id);
1008          stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kInStack, offset);
1009          if (current->GetType() == Primitive::kPrimDouble) {
1010            stack_map_stream_.AddDexRegisterEntry(
1011                DexRegisterLocation::Kind::kInStack, offset + kVRegSize);
1012            ++i;
1013            DCHECK_LT(i, environment_size);
1014          }
1015        } else {
1016          stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kInFpuRegister, id);
1017          if (current->GetType() == Primitive::kPrimDouble) {
1018            stack_map_stream_.AddDexRegisterEntry(
1019                DexRegisterLocation::Kind::kInFpuRegisterHigh, id);
1020            ++i;
1021            DCHECK_LT(i, environment_size);
1022          }
1023        }
1024        break;
1025      }
1026
1027      case Location::kFpuRegisterPair : {
1028        int low = location.low();
1029        int high = location.high();
1030        if (slow_path != nullptr && slow_path->IsFpuRegisterSaved(low)) {
1031          uint32_t offset = slow_path->GetStackOffsetOfFpuRegister(low);
1032          stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kInStack, offset);
1033        } else {
1034          stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kInFpuRegister, low);
1035        }
1036        if (slow_path != nullptr && slow_path->IsFpuRegisterSaved(high)) {
1037          uint32_t offset = slow_path->GetStackOffsetOfFpuRegister(high);
1038          stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kInStack, offset);
1039          ++i;
1040        } else {
1041          stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kInFpuRegister, high);
1042          ++i;
1043        }
1044        DCHECK_LT(i, environment_size);
1045        break;
1046      }
1047
1048      case Location::kRegisterPair : {
1049        int low = location.low();
1050        int high = location.high();
1051        if (slow_path != nullptr && slow_path->IsCoreRegisterSaved(low)) {
1052          uint32_t offset = slow_path->GetStackOffsetOfCoreRegister(low);
1053          stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kInStack, offset);
1054        } else {
1055          stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kInRegister, low);
1056        }
1057        if (slow_path != nullptr && slow_path->IsCoreRegisterSaved(high)) {
1058          uint32_t offset = slow_path->GetStackOffsetOfCoreRegister(high);
1059          stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kInStack, offset);
1060        } else {
1061          stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kInRegister, high);
1062        }
1063        ++i;
1064        DCHECK_LT(i, environment_size);
1065        break;
1066      }
1067
1068      case Location::kInvalid: {
1069        stack_map_stream_.AddDexRegisterEntry(DexRegisterLocation::Kind::kNone, 0);
1070        break;
1071      }
1072
1073      default:
1074        LOG(FATAL) << "Unexpected kind " << location.GetKind();
1075    }
1076  }
1077
1078  if (environment->GetParent() != nullptr) {
1079    stack_map_stream_.EndInlineInfoEntry();
1080  }
1081}
1082
1083bool CodeGenerator::IsImplicitNullCheckAllowed(HNullCheck* null_check) const {
1084  return compiler_options_.GetImplicitNullChecks() &&
1085         // Null checks which might throw into a catch block need to save live
1086         // registers and therefore cannot be done implicitly.
1087         !null_check->CanThrowIntoCatchBlock();
1088}
1089
1090bool CodeGenerator::CanMoveNullCheckToUser(HNullCheck* null_check) {
1091  HInstruction* first_next_not_move = null_check->GetNextDisregardingMoves();
1092
1093  return (first_next_not_move != nullptr)
1094      && first_next_not_move->CanDoImplicitNullCheckOn(null_check->InputAt(0));
1095}
1096
1097void CodeGenerator::MaybeRecordImplicitNullCheck(HInstruction* instr) {
1098  // If we are from a static path don't record the pc as we can't throw NPE.
1099  // NB: having the checks here makes the code much less verbose in the arch
1100  // specific code generators.
1101  if (instr->IsStaticFieldSet() || instr->IsStaticFieldGet()) {
1102    return;
1103  }
1104
1105  if (!instr->CanDoImplicitNullCheckOn(instr->InputAt(0))) {
1106    return;
1107  }
1108
1109  // Find the first previous instruction which is not a move.
1110  HInstruction* first_prev_not_move = instr->GetPreviousDisregardingMoves();
1111
1112  // If the instruction is a null check it means that `instr` is the first user
1113  // and needs to record the pc.
1114  if (first_prev_not_move != nullptr && first_prev_not_move->IsNullCheck()) {
1115    HNullCheck* null_check = first_prev_not_move->AsNullCheck();
1116    if (IsImplicitNullCheckAllowed(null_check)) {
1117      // TODO: The parallel moves modify the environment. Their changes need to be
1118      // reverted otherwise the stack maps at the throw point will not be correct.
1119      RecordPcInfo(null_check, null_check->GetDexPc());
1120    }
1121  }
1122}
1123
1124void CodeGenerator::GenerateNullCheck(HNullCheck* instruction) {
1125  if (IsImplicitNullCheckAllowed(instruction)) {
1126    MaybeRecordStat(kImplicitNullCheckGenerated);
1127    GenerateImplicitNullCheck(instruction);
1128  } else {
1129    MaybeRecordStat(kExplicitNullCheckGenerated);
1130    GenerateExplicitNullCheck(instruction);
1131  }
1132}
1133
1134void CodeGenerator::ClearSpillSlotsFromLoopPhisInStackMap(HSuspendCheck* suspend_check) const {
1135  LocationSummary* locations = suspend_check->GetLocations();
1136  HBasicBlock* block = suspend_check->GetBlock();
1137  DCHECK(block->GetLoopInformation()->GetSuspendCheck() == suspend_check);
1138  DCHECK(block->IsLoopHeader());
1139
1140  for (HInstructionIterator it(block->GetPhis()); !it.Done(); it.Advance()) {
1141    HInstruction* current = it.Current();
1142    LiveInterval* interval = current->GetLiveInterval();
1143    // We only need to clear bits of loop phis containing objects and allocated in register.
1144    // Loop phis allocated on stack already have the object in the stack.
1145    if (current->GetType() == Primitive::kPrimNot
1146        && interval->HasRegister()
1147        && interval->HasSpillSlot()) {
1148      locations->ClearStackBit(interval->GetSpillSlot() / kVRegSize);
1149    }
1150  }
1151}
1152
1153void CodeGenerator::EmitParallelMoves(Location from1,
1154                                      Location to1,
1155                                      Primitive::Type type1,
1156                                      Location from2,
1157                                      Location to2,
1158                                      Primitive::Type type2) {
1159  HParallelMove parallel_move(GetGraph()->GetArena());
1160  parallel_move.AddMove(from1, to1, type1, nullptr);
1161  parallel_move.AddMove(from2, to2, type2, nullptr);
1162  GetMoveResolver()->EmitNativeCode(&parallel_move);
1163}
1164
1165void CodeGenerator::ValidateInvokeRuntime(HInstruction* instruction, SlowPathCode* slow_path) {
1166  // Ensure that the call kind indication given to the register allocator is
1167  // coherent with the runtime call generated, and that the GC side effect is
1168  // set when required.
1169  if (slow_path == nullptr) {
1170    DCHECK(instruction->GetLocations()->WillCall())
1171        << "instruction->DebugName()=" << instruction->DebugName();
1172    DCHECK(instruction->GetSideEffects().Includes(SideEffects::CanTriggerGC()))
1173        << "instruction->DebugName()=" << instruction->DebugName()
1174        << " instruction->GetSideEffects().ToString()=" << instruction->GetSideEffects().ToString();
1175  } else {
1176    DCHECK(instruction->GetLocations()->OnlyCallsOnSlowPath() || slow_path->IsFatal())
1177        << "instruction->DebugName()=" << instruction->DebugName()
1178        << " slow_path->GetDescription()=" << slow_path->GetDescription();
1179    DCHECK(instruction->GetSideEffects().Includes(SideEffects::CanTriggerGC()) ||
1180           // When read barriers are enabled, some instructions use a
1181           // slow path to emit a read barrier, which does not trigger
1182           // GC, is not fatal, nor is emitted by HDeoptimize
1183           // instructions.
1184           (kEmitCompilerReadBarrier &&
1185            (instruction->IsInstanceFieldGet() ||
1186             instruction->IsStaticFieldGet() ||
1187             instruction->IsArraySet() ||
1188             instruction->IsArrayGet() ||
1189             instruction->IsLoadClass() ||
1190             instruction->IsLoadString() ||
1191             instruction->IsInstanceOf() ||
1192             instruction->IsCheckCast())))
1193        << "instruction->DebugName()=" << instruction->DebugName()
1194        << " instruction->GetSideEffects().ToString()=" << instruction->GetSideEffects().ToString()
1195        << " slow_path->GetDescription()=" << slow_path->GetDescription();
1196  }
1197
1198  // Check the coherency of leaf information.
1199  DCHECK(instruction->IsSuspendCheck()
1200         || ((slow_path != nullptr) && slow_path->IsFatal())
1201         || instruction->GetLocations()->CanCall()
1202         || !IsLeafMethod())
1203      << instruction->DebugName() << ((slow_path != nullptr) ? slow_path->GetDescription() : "");
1204}
1205
1206void SlowPathCode::SaveLiveRegisters(CodeGenerator* codegen, LocationSummary* locations) {
1207  RegisterSet* live_registers = locations->GetLiveRegisters();
1208  size_t stack_offset = codegen->GetFirstRegisterSlotInSlowPath();
1209
1210  for (size_t i = 0, e = codegen->GetNumberOfCoreRegisters(); i < e; ++i) {
1211    if (!codegen->IsCoreCalleeSaveRegister(i)) {
1212      if (live_registers->ContainsCoreRegister(i)) {
1213        // If the register holds an object, update the stack mask.
1214        if (locations->RegisterContainsObject(i)) {
1215          locations->SetStackBit(stack_offset / kVRegSize);
1216        }
1217        DCHECK_LT(stack_offset, codegen->GetFrameSize() - codegen->FrameEntrySpillSize());
1218        DCHECK_LT(i, kMaximumNumberOfExpectedRegisters);
1219        saved_core_stack_offsets_[i] = stack_offset;
1220        stack_offset += codegen->SaveCoreRegister(stack_offset, i);
1221      }
1222    }
1223  }
1224
1225  for (size_t i = 0, e = codegen->GetNumberOfFloatingPointRegisters(); i < e; ++i) {
1226    if (!codegen->IsFloatingPointCalleeSaveRegister(i)) {
1227      if (live_registers->ContainsFloatingPointRegister(i)) {
1228        DCHECK_LT(stack_offset, codegen->GetFrameSize() - codegen->FrameEntrySpillSize());
1229        DCHECK_LT(i, kMaximumNumberOfExpectedRegisters);
1230        saved_fpu_stack_offsets_[i] = stack_offset;
1231        stack_offset += codegen->SaveFloatingPointRegister(stack_offset, i);
1232      }
1233    }
1234  }
1235}
1236
1237void SlowPathCode::RestoreLiveRegisters(CodeGenerator* codegen, LocationSummary* locations) {
1238  RegisterSet* live_registers = locations->GetLiveRegisters();
1239  size_t stack_offset = codegen->GetFirstRegisterSlotInSlowPath();
1240
1241  for (size_t i = 0, e = codegen->GetNumberOfCoreRegisters(); i < e; ++i) {
1242    if (!codegen->IsCoreCalleeSaveRegister(i)) {
1243      if (live_registers->ContainsCoreRegister(i)) {
1244        DCHECK_LT(stack_offset, codegen->GetFrameSize() - codegen->FrameEntrySpillSize());
1245        DCHECK_LT(i, kMaximumNumberOfExpectedRegisters);
1246        stack_offset += codegen->RestoreCoreRegister(stack_offset, i);
1247      }
1248    }
1249  }
1250
1251  for (size_t i = 0, e = codegen->GetNumberOfFloatingPointRegisters(); i < e; ++i) {
1252    if (!codegen->IsFloatingPointCalleeSaveRegister(i)) {
1253      if (live_registers->ContainsFloatingPointRegister(i)) {
1254        DCHECK_LT(stack_offset, codegen->GetFrameSize() - codegen->FrameEntrySpillSize());
1255        DCHECK_LT(i, kMaximumNumberOfExpectedRegisters);
1256        stack_offset += codegen->RestoreFloatingPointRegister(stack_offset, i);
1257      }
1258    }
1259  }
1260}
1261
1262void CodeGenerator::CreateSystemArrayCopyLocationSummary(HInvoke* invoke) {
1263  // Check to see if we have known failures that will cause us to have to bail out
1264  // to the runtime, and just generate the runtime call directly.
1265  HIntConstant* src_pos = invoke->InputAt(1)->AsIntConstant();
1266  HIntConstant* dest_pos = invoke->InputAt(3)->AsIntConstant();
1267
1268  // The positions must be non-negative.
1269  if ((src_pos != nullptr && src_pos->GetValue() < 0) ||
1270      (dest_pos != nullptr && dest_pos->GetValue() < 0)) {
1271    // We will have to fail anyways.
1272    return;
1273  }
1274
1275  // The length must be >= 0.
1276  HIntConstant* length = invoke->InputAt(4)->AsIntConstant();
1277  if (length != nullptr) {
1278    int32_t len = length->GetValue();
1279    if (len < 0) {
1280      // Just call as normal.
1281      return;
1282    }
1283  }
1284
1285  SystemArrayCopyOptimizations optimizations(invoke);
1286
1287  if (optimizations.GetDestinationIsSource()) {
1288    if (src_pos != nullptr && dest_pos != nullptr && src_pos->GetValue() < dest_pos->GetValue()) {
1289      // We only support backward copying if source and destination are the same.
1290      return;
1291    }
1292  }
1293
1294  if (optimizations.GetDestinationIsPrimitiveArray() || optimizations.GetSourceIsPrimitiveArray()) {
1295    // We currently don't intrinsify primitive copying.
1296    return;
1297  }
1298
1299  ArenaAllocator* allocator = invoke->GetBlock()->GetGraph()->GetArena();
1300  LocationSummary* locations = new (allocator) LocationSummary(invoke,
1301                                                               LocationSummary::kCallOnSlowPath,
1302                                                               kIntrinsified);
1303  // arraycopy(Object src, int src_pos, Object dest, int dest_pos, int length).
1304  locations->SetInAt(0, Location::RequiresRegister());
1305  locations->SetInAt(1, Location::RegisterOrConstant(invoke->InputAt(1)));
1306  locations->SetInAt(2, Location::RequiresRegister());
1307  locations->SetInAt(3, Location::RegisterOrConstant(invoke->InputAt(3)));
1308  locations->SetInAt(4, Location::RegisterOrConstant(invoke->InputAt(4)));
1309
1310  locations->AddTemp(Location::RequiresRegister());
1311  locations->AddTemp(Location::RequiresRegister());
1312  locations->AddTemp(Location::RequiresRegister());
1313}
1314
1315uint32_t CodeGenerator::GetReferenceSlowFlagOffset() const {
1316  ScopedObjectAccess soa(Thread::Current());
1317  mirror::Class* klass = mirror::Reference::GetJavaLangRefReference();
1318  DCHECK(klass->IsInitialized());
1319  return klass->GetSlowPathFlagOffset().Uint32Value();
1320}
1321
1322uint32_t CodeGenerator::GetReferenceDisableFlagOffset() const {
1323  ScopedObjectAccess soa(Thread::Current());
1324  mirror::Class* klass = mirror::Reference::GetJavaLangRefReference();
1325  DCHECK(klass->IsInitialized());
1326  return klass->GetDisableIntrinsicFlagOffset().Uint32Value();
1327}
1328
1329}  // namespace art
1330