code_generator_arm.cc revision d8ef2e991a1a65f47a26a1eb8c6b34c92b775d6b
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_arm.h" 18 19#include "arch/arm/instruction_set_features_arm.h" 20#include "entrypoints/quick/quick_entrypoints.h" 21#include "gc/accounting/card_table.h" 22#include "intrinsics.h" 23#include "intrinsics_arm.h" 24#include "mirror/array-inl.h" 25#include "mirror/art_method.h" 26#include "mirror/class.h" 27#include "thread.h" 28#include "utils/arm/assembler_arm.h" 29#include "utils/arm/managed_register_arm.h" 30#include "utils/assembler.h" 31#include "utils/stack_checks.h" 32 33namespace art { 34 35namespace arm { 36 37static bool ExpectedPairLayout(Location location) { 38 // We expected this for both core and fpu register pairs. 39 return ((location.low() & 1) == 0) && (location.low() + 1 == location.high()); 40} 41 42static constexpr int kCurrentMethodStackOffset = 0; 43 44static constexpr Register kRuntimeParameterCoreRegisters[] = { R0, R1, R2, R3 }; 45static constexpr size_t kRuntimeParameterCoreRegistersLength = 46 arraysize(kRuntimeParameterCoreRegisters); 47static constexpr SRegister kRuntimeParameterFpuRegisters[] = { S0, S1, S2, S3 }; 48static constexpr size_t kRuntimeParameterFpuRegistersLength = 49 arraysize(kRuntimeParameterFpuRegisters); 50// We unconditionally allocate R5 to ensure we can do long operations 51// with baseline. 52static constexpr Register kCoreSavedRegisterForBaseline = R5; 53static constexpr Register kCoreCalleeSaves[] = 54 { R5, R6, R7, R8, R10, R11, PC }; 55static constexpr SRegister kFpuCalleeSaves[] = 56 { S16, S17, S18, S19, S20, S21, S22, S23, S24, S25, S26, S27, S28, S29, S30, S31 }; 57 58// D31 cannot be split into two S registers, and the register allocator only works on 59// S registers. Therefore there is no need to block it. 60static constexpr DRegister DTMP = D31; 61 62class InvokeRuntimeCallingConvention : public CallingConvention<Register, SRegister> { 63 public: 64 InvokeRuntimeCallingConvention() 65 : CallingConvention(kRuntimeParameterCoreRegisters, 66 kRuntimeParameterCoreRegistersLength, 67 kRuntimeParameterFpuRegisters, 68 kRuntimeParameterFpuRegistersLength) {} 69 70 private: 71 DISALLOW_COPY_AND_ASSIGN(InvokeRuntimeCallingConvention); 72}; 73 74#define __ reinterpret_cast<ArmAssembler*>(codegen->GetAssembler())-> 75#define QUICK_ENTRY_POINT(x) QUICK_ENTRYPOINT_OFFSET(kArmWordSize, x).Int32Value() 76 77class NullCheckSlowPathARM : public SlowPathCodeARM { 78 public: 79 explicit NullCheckSlowPathARM(HNullCheck* instruction) : instruction_(instruction) {} 80 81 void EmitNativeCode(CodeGenerator* codegen) OVERRIDE { 82 CodeGeneratorARM* arm_codegen = down_cast<CodeGeneratorARM*>(codegen); 83 __ Bind(GetEntryLabel()); 84 arm_codegen->InvokeRuntime( 85 QUICK_ENTRY_POINT(pThrowNullPointer), instruction_, instruction_->GetDexPc()); 86 } 87 88 private: 89 HNullCheck* const instruction_; 90 DISALLOW_COPY_AND_ASSIGN(NullCheckSlowPathARM); 91}; 92 93class DivZeroCheckSlowPathARM : public SlowPathCodeARM { 94 public: 95 explicit DivZeroCheckSlowPathARM(HDivZeroCheck* instruction) : instruction_(instruction) {} 96 97 void EmitNativeCode(CodeGenerator* codegen) OVERRIDE { 98 CodeGeneratorARM* arm_codegen = down_cast<CodeGeneratorARM*>(codegen); 99 __ Bind(GetEntryLabel()); 100 arm_codegen->InvokeRuntime( 101 QUICK_ENTRY_POINT(pThrowDivZero), instruction_, instruction_->GetDexPc()); 102 } 103 104 private: 105 HDivZeroCheck* const instruction_; 106 DISALLOW_COPY_AND_ASSIGN(DivZeroCheckSlowPathARM); 107}; 108 109class SuspendCheckSlowPathARM : public SlowPathCodeARM { 110 public: 111 SuspendCheckSlowPathARM(HSuspendCheck* instruction, HBasicBlock* successor) 112 : instruction_(instruction), successor_(successor) {} 113 114 void EmitNativeCode(CodeGenerator* codegen) OVERRIDE { 115 CodeGeneratorARM* arm_codegen = down_cast<CodeGeneratorARM*>(codegen); 116 __ Bind(GetEntryLabel()); 117 codegen->SaveLiveRegisters(instruction_->GetLocations()); 118 arm_codegen->InvokeRuntime( 119 QUICK_ENTRY_POINT(pTestSuspend), instruction_, instruction_->GetDexPc()); 120 codegen->RestoreLiveRegisters(instruction_->GetLocations()); 121 if (successor_ == nullptr) { 122 __ b(GetReturnLabel()); 123 } else { 124 __ b(arm_codegen->GetLabelOf(successor_)); 125 } 126 } 127 128 Label* GetReturnLabel() { 129 DCHECK(successor_ == nullptr); 130 return &return_label_; 131 } 132 133 private: 134 HSuspendCheck* const instruction_; 135 // If not null, the block to branch to after the suspend check. 136 HBasicBlock* const successor_; 137 138 // If `successor_` is null, the label to branch to after the suspend check. 139 Label return_label_; 140 141 DISALLOW_COPY_AND_ASSIGN(SuspendCheckSlowPathARM); 142}; 143 144class BoundsCheckSlowPathARM : public SlowPathCodeARM { 145 public: 146 BoundsCheckSlowPathARM(HBoundsCheck* instruction, 147 Location index_location, 148 Location length_location) 149 : instruction_(instruction), 150 index_location_(index_location), 151 length_location_(length_location) {} 152 153 void EmitNativeCode(CodeGenerator* codegen) OVERRIDE { 154 CodeGeneratorARM* arm_codegen = down_cast<CodeGeneratorARM*>(codegen); 155 __ Bind(GetEntryLabel()); 156 // We're moving two locations to locations that could overlap, so we need a parallel 157 // move resolver. 158 InvokeRuntimeCallingConvention calling_convention; 159 codegen->EmitParallelMoves( 160 index_location_, 161 Location::RegisterLocation(calling_convention.GetRegisterAt(0)), 162 length_location_, 163 Location::RegisterLocation(calling_convention.GetRegisterAt(1))); 164 arm_codegen->InvokeRuntime( 165 QUICK_ENTRY_POINT(pThrowArrayBounds), instruction_, instruction_->GetDexPc()); 166 } 167 168 private: 169 HBoundsCheck* const instruction_; 170 const Location index_location_; 171 const Location length_location_; 172 173 DISALLOW_COPY_AND_ASSIGN(BoundsCheckSlowPathARM); 174}; 175 176class LoadClassSlowPathARM : public SlowPathCodeARM { 177 public: 178 LoadClassSlowPathARM(HLoadClass* cls, 179 HInstruction* at, 180 uint32_t dex_pc, 181 bool do_clinit) 182 : cls_(cls), at_(at), dex_pc_(dex_pc), do_clinit_(do_clinit) { 183 DCHECK(at->IsLoadClass() || at->IsClinitCheck()); 184 } 185 186 void EmitNativeCode(CodeGenerator* codegen) OVERRIDE { 187 LocationSummary* locations = at_->GetLocations(); 188 189 CodeGeneratorARM* arm_codegen = down_cast<CodeGeneratorARM*>(codegen); 190 __ Bind(GetEntryLabel()); 191 codegen->SaveLiveRegisters(locations); 192 193 InvokeRuntimeCallingConvention calling_convention; 194 __ LoadImmediate(calling_convention.GetRegisterAt(0), cls_->GetTypeIndex()); 195 arm_codegen->LoadCurrentMethod(calling_convention.GetRegisterAt(1)); 196 int32_t entry_point_offset = do_clinit_ 197 ? QUICK_ENTRY_POINT(pInitializeStaticStorage) 198 : QUICK_ENTRY_POINT(pInitializeType); 199 arm_codegen->InvokeRuntime(entry_point_offset, at_, dex_pc_); 200 201 // Move the class to the desired location. 202 Location out = locations->Out(); 203 if (out.IsValid()) { 204 DCHECK(out.IsRegister() && !locations->GetLiveRegisters()->ContainsCoreRegister(out.reg())); 205 arm_codegen->Move32(locations->Out(), Location::RegisterLocation(R0)); 206 } 207 codegen->RestoreLiveRegisters(locations); 208 __ b(GetExitLabel()); 209 } 210 211 private: 212 // The class this slow path will load. 213 HLoadClass* const cls_; 214 215 // The instruction where this slow path is happening. 216 // (Might be the load class or an initialization check). 217 HInstruction* const at_; 218 219 // The dex PC of `at_`. 220 const uint32_t dex_pc_; 221 222 // Whether to initialize the class. 223 const bool do_clinit_; 224 225 DISALLOW_COPY_AND_ASSIGN(LoadClassSlowPathARM); 226}; 227 228class LoadStringSlowPathARM : public SlowPathCodeARM { 229 public: 230 explicit LoadStringSlowPathARM(HLoadString* instruction) : instruction_(instruction) {} 231 232 void EmitNativeCode(CodeGenerator* codegen) OVERRIDE { 233 LocationSummary* locations = instruction_->GetLocations(); 234 DCHECK(!locations->GetLiveRegisters()->ContainsCoreRegister(locations->Out().reg())); 235 236 CodeGeneratorARM* arm_codegen = down_cast<CodeGeneratorARM*>(codegen); 237 __ Bind(GetEntryLabel()); 238 codegen->SaveLiveRegisters(locations); 239 240 InvokeRuntimeCallingConvention calling_convention; 241 arm_codegen->LoadCurrentMethod(calling_convention.GetRegisterAt(1)); 242 __ LoadImmediate(calling_convention.GetRegisterAt(0), instruction_->GetStringIndex()); 243 arm_codegen->InvokeRuntime( 244 QUICK_ENTRY_POINT(pResolveString), instruction_, instruction_->GetDexPc()); 245 arm_codegen->Move32(locations->Out(), Location::RegisterLocation(R0)); 246 247 codegen->RestoreLiveRegisters(locations); 248 __ b(GetExitLabel()); 249 } 250 251 private: 252 HLoadString* const instruction_; 253 254 DISALLOW_COPY_AND_ASSIGN(LoadStringSlowPathARM); 255}; 256 257class TypeCheckSlowPathARM : public SlowPathCodeARM { 258 public: 259 TypeCheckSlowPathARM(HInstruction* instruction, 260 Location class_to_check, 261 Location object_class, 262 uint32_t dex_pc) 263 : instruction_(instruction), 264 class_to_check_(class_to_check), 265 object_class_(object_class), 266 dex_pc_(dex_pc) {} 267 268 void EmitNativeCode(CodeGenerator* codegen) OVERRIDE { 269 LocationSummary* locations = instruction_->GetLocations(); 270 DCHECK(instruction_->IsCheckCast() 271 || !locations->GetLiveRegisters()->ContainsCoreRegister(locations->Out().reg())); 272 273 CodeGeneratorARM* arm_codegen = down_cast<CodeGeneratorARM*>(codegen); 274 __ Bind(GetEntryLabel()); 275 codegen->SaveLiveRegisters(locations); 276 277 // We're moving two locations to locations that could overlap, so we need a parallel 278 // move resolver. 279 InvokeRuntimeCallingConvention calling_convention; 280 codegen->EmitParallelMoves( 281 class_to_check_, 282 Location::RegisterLocation(calling_convention.GetRegisterAt(0)), 283 object_class_, 284 Location::RegisterLocation(calling_convention.GetRegisterAt(1))); 285 286 if (instruction_->IsInstanceOf()) { 287 arm_codegen->InvokeRuntime(QUICK_ENTRY_POINT(pInstanceofNonTrivial), instruction_, dex_pc_); 288 arm_codegen->Move32(locations->Out(), Location::RegisterLocation(R0)); 289 } else { 290 DCHECK(instruction_->IsCheckCast()); 291 arm_codegen->InvokeRuntime(QUICK_ENTRY_POINT(pCheckCast), instruction_, dex_pc_); 292 } 293 294 codegen->RestoreLiveRegisters(locations); 295 __ b(GetExitLabel()); 296 } 297 298 private: 299 HInstruction* const instruction_; 300 const Location class_to_check_; 301 const Location object_class_; 302 uint32_t dex_pc_; 303 304 DISALLOW_COPY_AND_ASSIGN(TypeCheckSlowPathARM); 305}; 306 307#undef __ 308 309#undef __ 310#define __ reinterpret_cast<ArmAssembler*>(GetAssembler())-> 311 312inline Condition ARMCondition(IfCondition cond) { 313 switch (cond) { 314 case kCondEQ: return EQ; 315 case kCondNE: return NE; 316 case kCondLT: return LT; 317 case kCondLE: return LE; 318 case kCondGT: return GT; 319 case kCondGE: return GE; 320 default: 321 LOG(FATAL) << "Unknown if condition"; 322 } 323 return EQ; // Unreachable. 324} 325 326inline Condition ARMOppositeCondition(IfCondition cond) { 327 switch (cond) { 328 case kCondEQ: return NE; 329 case kCondNE: return EQ; 330 case kCondLT: return GE; 331 case kCondLE: return GT; 332 case kCondGT: return LE; 333 case kCondGE: return LT; 334 default: 335 LOG(FATAL) << "Unknown if condition"; 336 } 337 return EQ; // Unreachable. 338} 339 340void CodeGeneratorARM::DumpCoreRegister(std::ostream& stream, int reg) const { 341 stream << ArmManagedRegister::FromCoreRegister(Register(reg)); 342} 343 344void CodeGeneratorARM::DumpFloatingPointRegister(std::ostream& stream, int reg) const { 345 stream << ArmManagedRegister::FromSRegister(SRegister(reg)); 346} 347 348size_t CodeGeneratorARM::SaveCoreRegister(size_t stack_index, uint32_t reg_id) { 349 __ StoreToOffset(kStoreWord, static_cast<Register>(reg_id), SP, stack_index); 350 return kArmWordSize; 351} 352 353size_t CodeGeneratorARM::RestoreCoreRegister(size_t stack_index, uint32_t reg_id) { 354 __ LoadFromOffset(kLoadWord, static_cast<Register>(reg_id), SP, stack_index); 355 return kArmWordSize; 356} 357 358size_t CodeGeneratorARM::SaveFloatingPointRegister(size_t stack_index, uint32_t reg_id) { 359 __ StoreSToOffset(static_cast<SRegister>(reg_id), SP, stack_index); 360 return kArmWordSize; 361} 362 363size_t CodeGeneratorARM::RestoreFloatingPointRegister(size_t stack_index, uint32_t reg_id) { 364 __ LoadSFromOffset(static_cast<SRegister>(reg_id), SP, stack_index); 365 return kArmWordSize; 366} 367 368CodeGeneratorARM::CodeGeneratorARM(HGraph* graph, 369 const ArmInstructionSetFeatures& isa_features, 370 const CompilerOptions& compiler_options) 371 : CodeGenerator(graph, 372 kNumberOfCoreRegisters, 373 kNumberOfSRegisters, 374 kNumberOfRegisterPairs, 375 ComputeRegisterMask(reinterpret_cast<const int*>(kCoreCalleeSaves), 376 arraysize(kCoreCalleeSaves)), 377 ComputeRegisterMask(reinterpret_cast<const int*>(kFpuCalleeSaves), 378 arraysize(kFpuCalleeSaves)), 379 compiler_options), 380 block_labels_(graph->GetArena(), 0), 381 location_builder_(graph, this), 382 instruction_visitor_(graph, this), 383 move_resolver_(graph->GetArena(), this), 384 assembler_(true), 385 isa_features_(isa_features) { 386 // Save the PC register to mimic Quick. 387 AddAllocatedRegister(Location::RegisterLocation(PC)); 388} 389 390Location CodeGeneratorARM::AllocateFreeRegister(Primitive::Type type) const { 391 switch (type) { 392 case Primitive::kPrimLong: { 393 size_t reg = FindFreeEntry(blocked_register_pairs_, kNumberOfRegisterPairs); 394 ArmManagedRegister pair = 395 ArmManagedRegister::FromRegisterPair(static_cast<RegisterPair>(reg)); 396 DCHECK(!blocked_core_registers_[pair.AsRegisterPairLow()]); 397 DCHECK(!blocked_core_registers_[pair.AsRegisterPairHigh()]); 398 399 blocked_core_registers_[pair.AsRegisterPairLow()] = true; 400 blocked_core_registers_[pair.AsRegisterPairHigh()] = true; 401 UpdateBlockedPairRegisters(); 402 return Location::RegisterPairLocation(pair.AsRegisterPairLow(), pair.AsRegisterPairHigh()); 403 } 404 405 case Primitive::kPrimByte: 406 case Primitive::kPrimBoolean: 407 case Primitive::kPrimChar: 408 case Primitive::kPrimShort: 409 case Primitive::kPrimInt: 410 case Primitive::kPrimNot: { 411 int reg = FindFreeEntry(blocked_core_registers_, kNumberOfCoreRegisters); 412 // Block all register pairs that contain `reg`. 413 for (int i = 0; i < kNumberOfRegisterPairs; i++) { 414 ArmManagedRegister current = 415 ArmManagedRegister::FromRegisterPair(static_cast<RegisterPair>(i)); 416 if (current.AsRegisterPairLow() == reg || current.AsRegisterPairHigh() == reg) { 417 blocked_register_pairs_[i] = true; 418 } 419 } 420 return Location::RegisterLocation(reg); 421 } 422 423 case Primitive::kPrimFloat: { 424 int reg = FindFreeEntry(blocked_fpu_registers_, kNumberOfSRegisters); 425 return Location::FpuRegisterLocation(reg); 426 } 427 428 case Primitive::kPrimDouble: { 429 int reg = FindTwoFreeConsecutiveAlignedEntries(blocked_fpu_registers_, kNumberOfSRegisters); 430 DCHECK_EQ(reg % 2, 0); 431 return Location::FpuRegisterPairLocation(reg, reg + 1); 432 } 433 434 case Primitive::kPrimVoid: 435 LOG(FATAL) << "Unreachable type " << type; 436 } 437 438 return Location(); 439} 440 441void CodeGeneratorARM::SetupBlockedRegisters(bool is_baseline) const { 442 // Don't allocate the dalvik style register pair passing. 443 blocked_register_pairs_[R1_R2] = true; 444 445 // Stack register, LR and PC are always reserved. 446 blocked_core_registers_[SP] = true; 447 blocked_core_registers_[LR] = true; 448 blocked_core_registers_[PC] = true; 449 450 // Reserve thread register. 451 blocked_core_registers_[TR] = true; 452 453 // Reserve temp register. 454 blocked_core_registers_[IP] = true; 455 456 if (is_baseline) { 457 for (size_t i = 0; i < arraysize(kCoreCalleeSaves); ++i) { 458 blocked_core_registers_[kCoreCalleeSaves[i]] = true; 459 } 460 461 blocked_core_registers_[kCoreSavedRegisterForBaseline] = false; 462 463 for (size_t i = 0; i < arraysize(kFpuCalleeSaves); ++i) { 464 blocked_fpu_registers_[kFpuCalleeSaves[i]] = true; 465 } 466 } 467 468 UpdateBlockedPairRegisters(); 469} 470 471void CodeGeneratorARM::UpdateBlockedPairRegisters() const { 472 for (int i = 0; i < kNumberOfRegisterPairs; i++) { 473 ArmManagedRegister current = 474 ArmManagedRegister::FromRegisterPair(static_cast<RegisterPair>(i)); 475 if (blocked_core_registers_[current.AsRegisterPairLow()] 476 || blocked_core_registers_[current.AsRegisterPairHigh()]) { 477 blocked_register_pairs_[i] = true; 478 } 479 } 480} 481 482InstructionCodeGeneratorARM::InstructionCodeGeneratorARM(HGraph* graph, CodeGeneratorARM* codegen) 483 : HGraphVisitor(graph), 484 assembler_(codegen->GetAssembler()), 485 codegen_(codegen) {} 486 487static uint32_t LeastSignificantBit(uint32_t mask) { 488 // ffs starts at 1. 489 return ffs(mask) - 1; 490} 491 492void CodeGeneratorARM::ComputeSpillMask() { 493 core_spill_mask_ = allocated_registers_.GetCoreRegisters() & core_callee_save_mask_; 494 // Save one extra register for baseline. Note that on thumb2, there is no easy 495 // instruction to restore just the PC, so this actually helps both baseline 496 // and non-baseline to save and restore at least two registers at entry and exit. 497 core_spill_mask_ |= (1 << kCoreSavedRegisterForBaseline); 498 DCHECK_NE(core_spill_mask_, 0u) << "At least the return address register must be saved"; 499 fpu_spill_mask_ = allocated_registers_.GetFloatingPointRegisters() & fpu_callee_save_mask_; 500 // We use vpush and vpop for saving and restoring floating point registers, which take 501 // a SRegister and the number of registers to save/restore after that SRegister. We 502 // therefore update the `fpu_spill_mask_` to also contain those registers not allocated, 503 // but in the range. 504 if (fpu_spill_mask_ != 0) { 505 uint32_t least_significant_bit = LeastSignificantBit(fpu_spill_mask_); 506 uint32_t most_significant_bit = MostSignificantBit(fpu_spill_mask_); 507 for (uint32_t i = least_significant_bit + 1 ; i < most_significant_bit; ++i) { 508 fpu_spill_mask_ |= (1 << i); 509 } 510 } 511} 512 513void CodeGeneratorARM::GenerateFrameEntry() { 514 bool skip_overflow_check = 515 IsLeafMethod() && !FrameNeedsStackCheck(GetFrameSize(), InstructionSet::kArm); 516 DCHECK(GetCompilerOptions().GetImplicitStackOverflowChecks()); 517 __ Bind(&frame_entry_label_); 518 519 if (HasEmptyFrame()) { 520 return; 521 } 522 523 if (!skip_overflow_check) { 524 __ AddConstant(IP, SP, -static_cast<int32_t>(GetStackOverflowReservedBytes(kArm))); 525 __ LoadFromOffset(kLoadWord, IP, IP, 0); 526 RecordPcInfo(nullptr, 0); 527 } 528 529 // PC is in the list of callee-save to mimic Quick, but we need to push 530 // LR at entry instead. 531 __ PushList((core_spill_mask_ & (~(1 << PC))) | 1 << LR); 532 if (fpu_spill_mask_ != 0) { 533 SRegister start_register = SRegister(LeastSignificantBit(fpu_spill_mask_)); 534 __ vpushs(start_register, POPCOUNT(fpu_spill_mask_)); 535 } 536 __ AddConstant(SP, -(GetFrameSize() - FrameEntrySpillSize())); 537 __ StoreToOffset(kStoreWord, R0, SP, 0); 538} 539 540void CodeGeneratorARM::GenerateFrameExit() { 541 if (HasEmptyFrame()) { 542 __ bx(LR); 543 return; 544 } 545 __ AddConstant(SP, GetFrameSize() - FrameEntrySpillSize()); 546 if (fpu_spill_mask_ != 0) { 547 SRegister start_register = SRegister(LeastSignificantBit(fpu_spill_mask_)); 548 __ vpops(start_register, POPCOUNT(fpu_spill_mask_)); 549 } 550 __ PopList(core_spill_mask_); 551} 552 553void CodeGeneratorARM::Bind(HBasicBlock* block) { 554 __ Bind(GetLabelOf(block)); 555} 556 557Location CodeGeneratorARM::GetStackLocation(HLoadLocal* load) const { 558 switch (load->GetType()) { 559 case Primitive::kPrimLong: 560 case Primitive::kPrimDouble: 561 return Location::DoubleStackSlot(GetStackSlot(load->GetLocal())); 562 break; 563 564 case Primitive::kPrimInt: 565 case Primitive::kPrimNot: 566 case Primitive::kPrimFloat: 567 return Location::StackSlot(GetStackSlot(load->GetLocal())); 568 569 case Primitive::kPrimBoolean: 570 case Primitive::kPrimByte: 571 case Primitive::kPrimChar: 572 case Primitive::kPrimShort: 573 case Primitive::kPrimVoid: 574 LOG(FATAL) << "Unexpected type " << load->GetType(); 575 } 576 577 LOG(FATAL) << "Unreachable"; 578 return Location(); 579} 580 581Location InvokeDexCallingConventionVisitor::GetNextLocation(Primitive::Type type) { 582 switch (type) { 583 case Primitive::kPrimBoolean: 584 case Primitive::kPrimByte: 585 case Primitive::kPrimChar: 586 case Primitive::kPrimShort: 587 case Primitive::kPrimInt: 588 case Primitive::kPrimNot: { 589 uint32_t index = gp_index_++; 590 uint32_t stack_index = stack_index_++; 591 if (index < calling_convention.GetNumberOfRegisters()) { 592 return Location::RegisterLocation(calling_convention.GetRegisterAt(index)); 593 } else { 594 return Location::StackSlot(calling_convention.GetStackOffsetOf(stack_index)); 595 } 596 } 597 598 case Primitive::kPrimLong: { 599 uint32_t index = gp_index_; 600 uint32_t stack_index = stack_index_; 601 gp_index_ += 2; 602 stack_index_ += 2; 603 if (index + 1 < calling_convention.GetNumberOfRegisters()) { 604 if (calling_convention.GetRegisterAt(index) == R1) { 605 // Skip R1, and use R2_R3 instead. 606 gp_index_++; 607 index++; 608 } 609 } 610 if (index + 1 < calling_convention.GetNumberOfRegisters()) { 611 DCHECK_EQ(calling_convention.GetRegisterAt(index) + 1, 612 calling_convention.GetRegisterAt(index + 1)); 613 return Location::RegisterPairLocation(calling_convention.GetRegisterAt(index), 614 calling_convention.GetRegisterAt(index + 1)); 615 } else { 616 return Location::DoubleStackSlot(calling_convention.GetStackOffsetOf(stack_index)); 617 } 618 } 619 620 case Primitive::kPrimFloat: { 621 uint32_t stack_index = stack_index_++; 622 if (float_index_ % 2 == 0) { 623 float_index_ = std::max(double_index_, float_index_); 624 } 625 if (float_index_ < calling_convention.GetNumberOfFpuRegisters()) { 626 return Location::FpuRegisterLocation(calling_convention.GetFpuRegisterAt(float_index_++)); 627 } else { 628 return Location::StackSlot(calling_convention.GetStackOffsetOf(stack_index)); 629 } 630 } 631 632 case Primitive::kPrimDouble: { 633 double_index_ = std::max(double_index_, RoundUp(float_index_, 2)); 634 uint32_t stack_index = stack_index_; 635 stack_index_ += 2; 636 if (double_index_ + 1 < calling_convention.GetNumberOfFpuRegisters()) { 637 uint32_t index = double_index_; 638 double_index_ += 2; 639 Location result = Location::FpuRegisterPairLocation( 640 calling_convention.GetFpuRegisterAt(index), 641 calling_convention.GetFpuRegisterAt(index + 1)); 642 DCHECK(ExpectedPairLayout(result)); 643 return result; 644 } else { 645 return Location::DoubleStackSlot(calling_convention.GetStackOffsetOf(stack_index)); 646 } 647 } 648 649 case Primitive::kPrimVoid: 650 LOG(FATAL) << "Unexpected parameter type " << type; 651 break; 652 } 653 return Location(); 654} 655 656Location InvokeDexCallingConventionVisitor::GetReturnLocation(Primitive::Type type) { 657 switch (type) { 658 case Primitive::kPrimBoolean: 659 case Primitive::kPrimByte: 660 case Primitive::kPrimChar: 661 case Primitive::kPrimShort: 662 case Primitive::kPrimInt: 663 case Primitive::kPrimNot: { 664 return Location::RegisterLocation(R0); 665 } 666 667 case Primitive::kPrimFloat: { 668 return Location::FpuRegisterLocation(S0); 669 } 670 671 case Primitive::kPrimLong: { 672 return Location::RegisterPairLocation(R0, R1); 673 } 674 675 case Primitive::kPrimDouble: { 676 return Location::FpuRegisterPairLocation(S0, S1); 677 } 678 679 case Primitive::kPrimVoid: 680 return Location(); 681 } 682 UNREACHABLE(); 683 return Location(); 684} 685 686void CodeGeneratorARM::Move32(Location destination, Location source) { 687 if (source.Equals(destination)) { 688 return; 689 } 690 if (destination.IsRegister()) { 691 if (source.IsRegister()) { 692 __ Mov(destination.AsRegister<Register>(), source.AsRegister<Register>()); 693 } else if (source.IsFpuRegister()) { 694 __ vmovrs(destination.AsRegister<Register>(), source.AsFpuRegister<SRegister>()); 695 } else { 696 __ LoadFromOffset(kLoadWord, destination.AsRegister<Register>(), SP, source.GetStackIndex()); 697 } 698 } else if (destination.IsFpuRegister()) { 699 if (source.IsRegister()) { 700 __ vmovsr(destination.AsFpuRegister<SRegister>(), source.AsRegister<Register>()); 701 } else if (source.IsFpuRegister()) { 702 __ vmovs(destination.AsFpuRegister<SRegister>(), source.AsFpuRegister<SRegister>()); 703 } else { 704 __ LoadSFromOffset(destination.AsFpuRegister<SRegister>(), SP, source.GetStackIndex()); 705 } 706 } else { 707 DCHECK(destination.IsStackSlot()) << destination; 708 if (source.IsRegister()) { 709 __ StoreToOffset(kStoreWord, source.AsRegister<Register>(), SP, destination.GetStackIndex()); 710 } else if (source.IsFpuRegister()) { 711 __ StoreSToOffset(source.AsFpuRegister<SRegister>(), SP, destination.GetStackIndex()); 712 } else { 713 DCHECK(source.IsStackSlot()) << source; 714 __ LoadFromOffset(kLoadWord, IP, SP, source.GetStackIndex()); 715 __ StoreToOffset(kStoreWord, IP, SP, destination.GetStackIndex()); 716 } 717 } 718} 719 720void CodeGeneratorARM::Move64(Location destination, Location source) { 721 if (source.Equals(destination)) { 722 return; 723 } 724 if (destination.IsRegisterPair()) { 725 if (source.IsRegisterPair()) { 726 EmitParallelMoves( 727 Location::RegisterLocation(source.AsRegisterPairHigh<Register>()), 728 Location::RegisterLocation(destination.AsRegisterPairHigh<Register>()), 729 Location::RegisterLocation(source.AsRegisterPairLow<Register>()), 730 Location::RegisterLocation(destination.AsRegisterPairLow<Register>())); 731 } else if (source.IsFpuRegister()) { 732 UNIMPLEMENTED(FATAL); 733 } else { 734 DCHECK(source.IsDoubleStackSlot()); 735 DCHECK(ExpectedPairLayout(destination)); 736 __ LoadFromOffset(kLoadWordPair, destination.AsRegisterPairLow<Register>(), 737 SP, source.GetStackIndex()); 738 } 739 } else if (destination.IsFpuRegisterPair()) { 740 if (source.IsDoubleStackSlot()) { 741 __ LoadDFromOffset(FromLowSToD(destination.AsFpuRegisterPairLow<SRegister>()), 742 SP, 743 source.GetStackIndex()); 744 } else { 745 UNIMPLEMENTED(FATAL); 746 } 747 } else { 748 DCHECK(destination.IsDoubleStackSlot()); 749 if (source.IsRegisterPair()) { 750 // No conflict possible, so just do the moves. 751 if (source.AsRegisterPairLow<Register>() == R1) { 752 DCHECK_EQ(source.AsRegisterPairHigh<Register>(), R2); 753 __ StoreToOffset(kStoreWord, R1, SP, destination.GetStackIndex()); 754 __ StoreToOffset(kStoreWord, R2, SP, destination.GetHighStackIndex(kArmWordSize)); 755 } else { 756 __ StoreToOffset(kStoreWordPair, source.AsRegisterPairLow<Register>(), 757 SP, destination.GetStackIndex()); 758 } 759 } else if (source.IsFpuRegisterPair()) { 760 __ StoreDToOffset(FromLowSToD(source.AsFpuRegisterPairLow<SRegister>()), 761 SP, 762 destination.GetStackIndex()); 763 } else { 764 DCHECK(source.IsDoubleStackSlot()); 765 EmitParallelMoves( 766 Location::StackSlot(source.GetStackIndex()), 767 Location::StackSlot(destination.GetStackIndex()), 768 Location::StackSlot(source.GetHighStackIndex(kArmWordSize)), 769 Location::StackSlot(destination.GetHighStackIndex(kArmWordSize))); 770 } 771 } 772} 773 774void CodeGeneratorARM::Move(HInstruction* instruction, Location location, HInstruction* move_for) { 775 LocationSummary* locations = instruction->GetLocations(); 776 if (locations != nullptr && locations->Out().Equals(location)) { 777 return; 778 } 779 780 if (locations != nullptr && locations->Out().IsConstant()) { 781 HConstant* const_to_move = locations->Out().GetConstant(); 782 if (const_to_move->IsIntConstant() || const_to_move->IsNullConstant()) { 783 int32_t value = GetInt32ValueOf(const_to_move); 784 if (location.IsRegister()) { 785 __ LoadImmediate(location.AsRegister<Register>(), value); 786 } else { 787 DCHECK(location.IsStackSlot()); 788 __ LoadImmediate(IP, value); 789 __ StoreToOffset(kStoreWord, IP, SP, location.GetStackIndex()); 790 } 791 } else { 792 DCHECK(const_to_move->IsLongConstant()) << const_to_move->DebugName(); 793 int64_t value = const_to_move->AsLongConstant()->GetValue(); 794 if (location.IsRegisterPair()) { 795 __ LoadImmediate(location.AsRegisterPairLow<Register>(), Low32Bits(value)); 796 __ LoadImmediate(location.AsRegisterPairHigh<Register>(), High32Bits(value)); 797 } else { 798 DCHECK(location.IsDoubleStackSlot()); 799 __ LoadImmediate(IP, Low32Bits(value)); 800 __ StoreToOffset(kStoreWord, IP, SP, location.GetStackIndex()); 801 __ LoadImmediate(IP, High32Bits(value)); 802 __ StoreToOffset(kStoreWord, IP, SP, location.GetHighStackIndex(kArmWordSize)); 803 } 804 } 805 } else if (instruction->IsLoadLocal()) { 806 uint32_t stack_slot = GetStackSlot(instruction->AsLoadLocal()->GetLocal()); 807 switch (instruction->GetType()) { 808 case Primitive::kPrimBoolean: 809 case Primitive::kPrimByte: 810 case Primitive::kPrimChar: 811 case Primitive::kPrimShort: 812 case Primitive::kPrimInt: 813 case Primitive::kPrimNot: 814 case Primitive::kPrimFloat: 815 Move32(location, Location::StackSlot(stack_slot)); 816 break; 817 818 case Primitive::kPrimLong: 819 case Primitive::kPrimDouble: 820 Move64(location, Location::DoubleStackSlot(stack_slot)); 821 break; 822 823 default: 824 LOG(FATAL) << "Unexpected type " << instruction->GetType(); 825 } 826 } else if (instruction->IsTemporary()) { 827 Location temp_location = GetTemporaryLocation(instruction->AsTemporary()); 828 if (temp_location.IsStackSlot()) { 829 Move32(location, temp_location); 830 } else { 831 DCHECK(temp_location.IsDoubleStackSlot()); 832 Move64(location, temp_location); 833 } 834 } else { 835 DCHECK((instruction->GetNext() == move_for) || instruction->GetNext()->IsTemporary()); 836 switch (instruction->GetType()) { 837 case Primitive::kPrimBoolean: 838 case Primitive::kPrimByte: 839 case Primitive::kPrimChar: 840 case Primitive::kPrimShort: 841 case Primitive::kPrimNot: 842 case Primitive::kPrimInt: 843 case Primitive::kPrimFloat: 844 Move32(location, locations->Out()); 845 break; 846 847 case Primitive::kPrimLong: 848 case Primitive::kPrimDouble: 849 Move64(location, locations->Out()); 850 break; 851 852 default: 853 LOG(FATAL) << "Unexpected type " << instruction->GetType(); 854 } 855 } 856} 857 858void CodeGeneratorARM::InvokeRuntime(int32_t entry_point_offset, 859 HInstruction* instruction, 860 uint32_t dex_pc) { 861 __ LoadFromOffset(kLoadWord, LR, TR, entry_point_offset); 862 __ blx(LR); 863 RecordPcInfo(instruction, dex_pc); 864 DCHECK(instruction->IsSuspendCheck() 865 || instruction->IsBoundsCheck() 866 || instruction->IsNullCheck() 867 || instruction->IsDivZeroCheck() 868 || instruction->GetLocations()->CanCall() 869 || !IsLeafMethod()); 870} 871 872void LocationsBuilderARM::VisitGoto(HGoto* got) { 873 got->SetLocations(nullptr); 874} 875 876void InstructionCodeGeneratorARM::VisitGoto(HGoto* got) { 877 HBasicBlock* successor = got->GetSuccessor(); 878 DCHECK(!successor->IsExitBlock()); 879 880 HBasicBlock* block = got->GetBlock(); 881 HInstruction* previous = got->GetPrevious(); 882 883 HLoopInformation* info = block->GetLoopInformation(); 884 if (info != nullptr && info->IsBackEdge(block) && info->HasSuspendCheck()) { 885 codegen_->ClearSpillSlotsFromLoopPhisInStackMap(info->GetSuspendCheck()); 886 GenerateSuspendCheck(info->GetSuspendCheck(), successor); 887 return; 888 } 889 890 if (block->IsEntryBlock() && (previous != nullptr) && previous->IsSuspendCheck()) { 891 GenerateSuspendCheck(previous->AsSuspendCheck(), nullptr); 892 } 893 if (!codegen_->GoesToNextBlock(got->GetBlock(), successor)) { 894 __ b(codegen_->GetLabelOf(successor)); 895 } 896} 897 898void LocationsBuilderARM::VisitExit(HExit* exit) { 899 exit->SetLocations(nullptr); 900} 901 902void InstructionCodeGeneratorARM::VisitExit(HExit* exit) { 903 UNUSED(exit); 904 if (kIsDebugBuild) { 905 __ Comment("Unreachable"); 906 __ bkpt(0); 907 } 908} 909 910void LocationsBuilderARM::VisitIf(HIf* if_instr) { 911 LocationSummary* locations = 912 new (GetGraph()->GetArena()) LocationSummary(if_instr, LocationSummary::kNoCall); 913 HInstruction* cond = if_instr->InputAt(0); 914 if (!cond->IsCondition() || cond->AsCondition()->NeedsMaterialization()) { 915 locations->SetInAt(0, Location::RequiresRegister()); 916 } 917} 918 919void InstructionCodeGeneratorARM::VisitIf(HIf* if_instr) { 920 HInstruction* cond = if_instr->InputAt(0); 921 if (cond->IsIntConstant()) { 922 // Constant condition, statically compared against 1. 923 int32_t cond_value = cond->AsIntConstant()->GetValue(); 924 if (cond_value == 1) { 925 if (!codegen_->GoesToNextBlock(if_instr->GetBlock(), 926 if_instr->IfTrueSuccessor())) { 927 __ b(codegen_->GetLabelOf(if_instr->IfTrueSuccessor())); 928 } 929 return; 930 } else { 931 DCHECK_EQ(cond_value, 0); 932 } 933 } else { 934 if (!cond->IsCondition() || cond->AsCondition()->NeedsMaterialization()) { 935 // Condition has been materialized, compare the output to 0 936 DCHECK(if_instr->GetLocations()->InAt(0).IsRegister()); 937 __ cmp(if_instr->GetLocations()->InAt(0).AsRegister<Register>(), 938 ShifterOperand(0)); 939 __ b(codegen_->GetLabelOf(if_instr->IfTrueSuccessor()), NE); 940 } else { 941 // Condition has not been materialized, use its inputs as the 942 // comparison and its condition as the branch condition. 943 LocationSummary* locations = cond->GetLocations(); 944 DCHECK(locations->InAt(0).IsRegister()) << locations->InAt(0); 945 Register left = locations->InAt(0).AsRegister<Register>(); 946 if (locations->InAt(1).IsRegister()) { 947 __ cmp(left, ShifterOperand(locations->InAt(1).AsRegister<Register>())); 948 } else { 949 DCHECK(locations->InAt(1).IsConstant()); 950 HConstant* constant = locations->InAt(1).GetConstant(); 951 int32_t value = CodeGenerator::GetInt32ValueOf(constant); 952 ShifterOperand operand; 953 if (GetAssembler()->ShifterOperandCanHold(R0, left, CMP, value, &operand)) { 954 __ cmp(left, operand); 955 } else { 956 Register temp = IP; 957 __ LoadImmediate(temp, value); 958 __ cmp(left, ShifterOperand(temp)); 959 } 960 } 961 __ b(codegen_->GetLabelOf(if_instr->IfTrueSuccessor()), 962 ARMCondition(cond->AsCondition()->GetCondition())); 963 } 964 } 965 if (!codegen_->GoesToNextBlock(if_instr->GetBlock(), 966 if_instr->IfFalseSuccessor())) { 967 __ b(codegen_->GetLabelOf(if_instr->IfFalseSuccessor())); 968 } 969} 970 971 972void LocationsBuilderARM::VisitCondition(HCondition* comp) { 973 LocationSummary* locations = 974 new (GetGraph()->GetArena()) LocationSummary(comp, LocationSummary::kNoCall); 975 locations->SetInAt(0, Location::RequiresRegister()); 976 locations->SetInAt(1, Location::RegisterOrConstant(comp->InputAt(1))); 977 if (comp->NeedsMaterialization()) { 978 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 979 } 980} 981 982void InstructionCodeGeneratorARM::VisitCondition(HCondition* comp) { 983 if (!comp->NeedsMaterialization()) return; 984 LocationSummary* locations = comp->GetLocations(); 985 Register left = locations->InAt(0).AsRegister<Register>(); 986 987 if (locations->InAt(1).IsRegister()) { 988 __ cmp(left, ShifterOperand(locations->InAt(1).AsRegister<Register>())); 989 } else { 990 DCHECK(locations->InAt(1).IsConstant()); 991 int32_t value = locations->InAt(1).GetConstant()->AsIntConstant()->GetValue(); 992 ShifterOperand operand; 993 if (GetAssembler()->ShifterOperandCanHold(R0, left, CMP, value, &operand)) { 994 __ cmp(left, operand); 995 } else { 996 Register temp = IP; 997 __ LoadImmediate(temp, value); 998 __ cmp(left, ShifterOperand(temp)); 999 } 1000 } 1001 __ it(ARMCondition(comp->GetCondition()), kItElse); 1002 __ mov(locations->Out().AsRegister<Register>(), ShifterOperand(1), 1003 ARMCondition(comp->GetCondition())); 1004 __ mov(locations->Out().AsRegister<Register>(), ShifterOperand(0), 1005 ARMOppositeCondition(comp->GetCondition())); 1006} 1007 1008void LocationsBuilderARM::VisitEqual(HEqual* comp) { 1009 VisitCondition(comp); 1010} 1011 1012void InstructionCodeGeneratorARM::VisitEqual(HEqual* comp) { 1013 VisitCondition(comp); 1014} 1015 1016void LocationsBuilderARM::VisitNotEqual(HNotEqual* comp) { 1017 VisitCondition(comp); 1018} 1019 1020void InstructionCodeGeneratorARM::VisitNotEqual(HNotEqual* comp) { 1021 VisitCondition(comp); 1022} 1023 1024void LocationsBuilderARM::VisitLessThan(HLessThan* comp) { 1025 VisitCondition(comp); 1026} 1027 1028void InstructionCodeGeneratorARM::VisitLessThan(HLessThan* comp) { 1029 VisitCondition(comp); 1030} 1031 1032void LocationsBuilderARM::VisitLessThanOrEqual(HLessThanOrEqual* comp) { 1033 VisitCondition(comp); 1034} 1035 1036void InstructionCodeGeneratorARM::VisitLessThanOrEqual(HLessThanOrEqual* comp) { 1037 VisitCondition(comp); 1038} 1039 1040void LocationsBuilderARM::VisitGreaterThan(HGreaterThan* comp) { 1041 VisitCondition(comp); 1042} 1043 1044void InstructionCodeGeneratorARM::VisitGreaterThan(HGreaterThan* comp) { 1045 VisitCondition(comp); 1046} 1047 1048void LocationsBuilderARM::VisitGreaterThanOrEqual(HGreaterThanOrEqual* comp) { 1049 VisitCondition(comp); 1050} 1051 1052void InstructionCodeGeneratorARM::VisitGreaterThanOrEqual(HGreaterThanOrEqual* comp) { 1053 VisitCondition(comp); 1054} 1055 1056void LocationsBuilderARM::VisitLocal(HLocal* local) { 1057 local->SetLocations(nullptr); 1058} 1059 1060void InstructionCodeGeneratorARM::VisitLocal(HLocal* local) { 1061 DCHECK_EQ(local->GetBlock(), GetGraph()->GetEntryBlock()); 1062} 1063 1064void LocationsBuilderARM::VisitLoadLocal(HLoadLocal* load) { 1065 load->SetLocations(nullptr); 1066} 1067 1068void InstructionCodeGeneratorARM::VisitLoadLocal(HLoadLocal* load) { 1069 // Nothing to do, this is driven by the code generator. 1070 UNUSED(load); 1071} 1072 1073void LocationsBuilderARM::VisitStoreLocal(HStoreLocal* store) { 1074 LocationSummary* locations = 1075 new (GetGraph()->GetArena()) LocationSummary(store, LocationSummary::kNoCall); 1076 switch (store->InputAt(1)->GetType()) { 1077 case Primitive::kPrimBoolean: 1078 case Primitive::kPrimByte: 1079 case Primitive::kPrimChar: 1080 case Primitive::kPrimShort: 1081 case Primitive::kPrimInt: 1082 case Primitive::kPrimNot: 1083 case Primitive::kPrimFloat: 1084 locations->SetInAt(1, Location::StackSlot(codegen_->GetStackSlot(store->GetLocal()))); 1085 break; 1086 1087 case Primitive::kPrimLong: 1088 case Primitive::kPrimDouble: 1089 locations->SetInAt(1, Location::DoubleStackSlot(codegen_->GetStackSlot(store->GetLocal()))); 1090 break; 1091 1092 default: 1093 LOG(FATAL) << "Unexpected local type " << store->InputAt(1)->GetType(); 1094 } 1095} 1096 1097void InstructionCodeGeneratorARM::VisitStoreLocal(HStoreLocal* store) { 1098 UNUSED(store); 1099} 1100 1101void LocationsBuilderARM::VisitIntConstant(HIntConstant* constant) { 1102 LocationSummary* locations = 1103 new (GetGraph()->GetArena()) LocationSummary(constant, LocationSummary::kNoCall); 1104 locations->SetOut(Location::ConstantLocation(constant)); 1105} 1106 1107void InstructionCodeGeneratorARM::VisitIntConstant(HIntConstant* constant) { 1108 // Will be generated at use site. 1109 UNUSED(constant); 1110} 1111 1112void LocationsBuilderARM::VisitNullConstant(HNullConstant* constant) { 1113 LocationSummary* locations = 1114 new (GetGraph()->GetArena()) LocationSummary(constant, LocationSummary::kNoCall); 1115 locations->SetOut(Location::ConstantLocation(constant)); 1116} 1117 1118void InstructionCodeGeneratorARM::VisitNullConstant(HNullConstant* constant) { 1119 // Will be generated at use site. 1120 UNUSED(constant); 1121} 1122 1123void LocationsBuilderARM::VisitLongConstant(HLongConstant* constant) { 1124 LocationSummary* locations = 1125 new (GetGraph()->GetArena()) LocationSummary(constant, LocationSummary::kNoCall); 1126 locations->SetOut(Location::ConstantLocation(constant)); 1127} 1128 1129void InstructionCodeGeneratorARM::VisitLongConstant(HLongConstant* constant) { 1130 // Will be generated at use site. 1131 UNUSED(constant); 1132} 1133 1134void LocationsBuilderARM::VisitFloatConstant(HFloatConstant* constant) { 1135 LocationSummary* locations = 1136 new (GetGraph()->GetArena()) LocationSummary(constant, LocationSummary::kNoCall); 1137 locations->SetOut(Location::ConstantLocation(constant)); 1138} 1139 1140void InstructionCodeGeneratorARM::VisitFloatConstant(HFloatConstant* constant) { 1141 // Will be generated at use site. 1142 UNUSED(constant); 1143} 1144 1145void LocationsBuilderARM::VisitDoubleConstant(HDoubleConstant* constant) { 1146 LocationSummary* locations = 1147 new (GetGraph()->GetArena()) LocationSummary(constant, LocationSummary::kNoCall); 1148 locations->SetOut(Location::ConstantLocation(constant)); 1149} 1150 1151void InstructionCodeGeneratorARM::VisitDoubleConstant(HDoubleConstant* constant) { 1152 // Will be generated at use site. 1153 UNUSED(constant); 1154} 1155 1156void LocationsBuilderARM::VisitReturnVoid(HReturnVoid* ret) { 1157 ret->SetLocations(nullptr); 1158} 1159 1160void InstructionCodeGeneratorARM::VisitReturnVoid(HReturnVoid* ret) { 1161 UNUSED(ret); 1162 codegen_->GenerateFrameExit(); 1163} 1164 1165void LocationsBuilderARM::VisitReturn(HReturn* ret) { 1166 LocationSummary* locations = 1167 new (GetGraph()->GetArena()) LocationSummary(ret, LocationSummary::kNoCall); 1168 locations->SetInAt(0, parameter_visitor_.GetReturnLocation(ret->InputAt(0)->GetType())); 1169} 1170 1171void InstructionCodeGeneratorARM::VisitReturn(HReturn* ret) { 1172 UNUSED(ret); 1173 codegen_->GenerateFrameExit(); 1174} 1175 1176void LocationsBuilderARM::VisitInvokeStaticOrDirect(HInvokeStaticOrDirect* invoke) { 1177 IntrinsicLocationsBuilderARM intrinsic(GetGraph()->GetArena(), 1178 codegen_->GetInstructionSetFeatures()); 1179 if (intrinsic.TryDispatch(invoke)) { 1180 return; 1181 } 1182 1183 HandleInvoke(invoke); 1184} 1185 1186void CodeGeneratorARM::LoadCurrentMethod(Register reg) { 1187 DCHECK(RequiresCurrentMethod()); 1188 __ LoadFromOffset(kLoadWord, reg, SP, kCurrentMethodStackOffset); 1189} 1190 1191static bool TryGenerateIntrinsicCode(HInvoke* invoke, CodeGeneratorARM* codegen) { 1192 if (invoke->GetLocations()->Intrinsified()) { 1193 IntrinsicCodeGeneratorARM intrinsic(codegen); 1194 intrinsic.Dispatch(invoke); 1195 return true; 1196 } 1197 return false; 1198} 1199 1200void InstructionCodeGeneratorARM::VisitInvokeStaticOrDirect(HInvokeStaticOrDirect* invoke) { 1201 if (TryGenerateIntrinsicCode(invoke, codegen_)) { 1202 return; 1203 } 1204 1205 Register temp = invoke->GetLocations()->GetTemp(0).AsRegister<Register>(); 1206 1207 codegen_->GenerateStaticOrDirectCall(invoke, temp); 1208} 1209 1210void LocationsBuilderARM::HandleInvoke(HInvoke* invoke) { 1211 LocationSummary* locations = 1212 new (GetGraph()->GetArena()) LocationSummary(invoke, LocationSummary::kCall); 1213 locations->AddTemp(Location::RegisterLocation(R0)); 1214 1215 InvokeDexCallingConventionVisitor calling_convention_visitor; 1216 for (size_t i = 0; i < invoke->InputCount(); i++) { 1217 HInstruction* input = invoke->InputAt(i); 1218 locations->SetInAt(i, calling_convention_visitor.GetNextLocation(input->GetType())); 1219 } 1220 1221 locations->SetOut(calling_convention_visitor.GetReturnLocation(invoke->GetType())); 1222} 1223 1224void LocationsBuilderARM::VisitInvokeVirtual(HInvokeVirtual* invoke) { 1225 IntrinsicLocationsBuilderARM intrinsic(GetGraph()->GetArena(), 1226 codegen_->GetInstructionSetFeatures()); 1227 if (intrinsic.TryDispatch(invoke)) { 1228 return; 1229 } 1230 1231 HandleInvoke(invoke); 1232} 1233 1234void InstructionCodeGeneratorARM::VisitInvokeVirtual(HInvokeVirtual* invoke) { 1235 if (TryGenerateIntrinsicCode(invoke, codegen_)) { 1236 return; 1237 } 1238 1239 Register temp = invoke->GetLocations()->GetTemp(0).AsRegister<Register>(); 1240 uint32_t method_offset = mirror::Class::EmbeddedVTableOffset().Uint32Value() + 1241 invoke->GetVTableIndex() * sizeof(mirror::Class::VTableEntry); 1242 LocationSummary* locations = invoke->GetLocations(); 1243 Location receiver = locations->InAt(0); 1244 uint32_t class_offset = mirror::Object::ClassOffset().Int32Value(); 1245 // temp = object->GetClass(); 1246 if (receiver.IsStackSlot()) { 1247 __ LoadFromOffset(kLoadWord, temp, SP, receiver.GetStackIndex()); 1248 __ LoadFromOffset(kLoadWord, temp, temp, class_offset); 1249 } else { 1250 __ LoadFromOffset(kLoadWord, temp, receiver.AsRegister<Register>(), class_offset); 1251 } 1252 codegen_->MaybeRecordImplicitNullCheck(invoke); 1253 // temp = temp->GetMethodAt(method_offset); 1254 uint32_t entry_point = mirror::ArtMethod::EntryPointFromQuickCompiledCodeOffset( 1255 kArmWordSize).Int32Value(); 1256 __ LoadFromOffset(kLoadWord, temp, temp, method_offset); 1257 // LR = temp->GetEntryPoint(); 1258 __ LoadFromOffset(kLoadWord, LR, temp, entry_point); 1259 // LR(); 1260 __ blx(LR); 1261 DCHECK(!codegen_->IsLeafMethod()); 1262 codegen_->RecordPcInfo(invoke, invoke->GetDexPc()); 1263} 1264 1265void LocationsBuilderARM::VisitInvokeInterface(HInvokeInterface* invoke) { 1266 HandleInvoke(invoke); 1267 // Add the hidden argument. 1268 invoke->GetLocations()->AddTemp(Location::RegisterLocation(R12)); 1269} 1270 1271void InstructionCodeGeneratorARM::VisitInvokeInterface(HInvokeInterface* invoke) { 1272 // TODO: b/18116999, our IMTs can miss an IncompatibleClassChangeError. 1273 Register temp = invoke->GetLocations()->GetTemp(0).AsRegister<Register>(); 1274 uint32_t method_offset = mirror::Class::EmbeddedImTableOffset().Uint32Value() + 1275 (invoke->GetImtIndex() % mirror::Class::kImtSize) * sizeof(mirror::Class::ImTableEntry); 1276 LocationSummary* locations = invoke->GetLocations(); 1277 Location receiver = locations->InAt(0); 1278 uint32_t class_offset = mirror::Object::ClassOffset().Int32Value(); 1279 1280 // Set the hidden argument. 1281 __ LoadImmediate(invoke->GetLocations()->GetTemp(1).AsRegister<Register>(), 1282 invoke->GetDexMethodIndex()); 1283 1284 // temp = object->GetClass(); 1285 if (receiver.IsStackSlot()) { 1286 __ LoadFromOffset(kLoadWord, temp, SP, receiver.GetStackIndex()); 1287 __ LoadFromOffset(kLoadWord, temp, temp, class_offset); 1288 } else { 1289 __ LoadFromOffset(kLoadWord, temp, receiver.AsRegister<Register>(), class_offset); 1290 } 1291 codegen_->MaybeRecordImplicitNullCheck(invoke); 1292 // temp = temp->GetImtEntryAt(method_offset); 1293 uint32_t entry_point = mirror::ArtMethod::EntryPointFromQuickCompiledCodeOffset( 1294 kArmWordSize).Int32Value(); 1295 __ LoadFromOffset(kLoadWord, temp, temp, method_offset); 1296 // LR = temp->GetEntryPoint(); 1297 __ LoadFromOffset(kLoadWord, LR, temp, entry_point); 1298 // LR(); 1299 __ blx(LR); 1300 DCHECK(!codegen_->IsLeafMethod()); 1301 codegen_->RecordPcInfo(invoke, invoke->GetDexPc()); 1302} 1303 1304void LocationsBuilderARM::VisitNeg(HNeg* neg) { 1305 LocationSummary* locations = 1306 new (GetGraph()->GetArena()) LocationSummary(neg, LocationSummary::kNoCall); 1307 switch (neg->GetResultType()) { 1308 case Primitive::kPrimInt: { 1309 locations->SetInAt(0, Location::RequiresRegister()); 1310 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 1311 break; 1312 } 1313 case Primitive::kPrimLong: { 1314 locations->SetInAt(0, Location::RequiresRegister()); 1315 locations->SetOut(Location::RequiresRegister(), Location::kOutputOverlap); 1316 break; 1317 } 1318 1319 case Primitive::kPrimFloat: 1320 case Primitive::kPrimDouble: 1321 locations->SetInAt(0, Location::RequiresFpuRegister()); 1322 locations->SetOut(Location::RequiresFpuRegister(), Location::kNoOutputOverlap); 1323 break; 1324 1325 default: 1326 LOG(FATAL) << "Unexpected neg type " << neg->GetResultType(); 1327 } 1328} 1329 1330void InstructionCodeGeneratorARM::VisitNeg(HNeg* neg) { 1331 LocationSummary* locations = neg->GetLocations(); 1332 Location out = locations->Out(); 1333 Location in = locations->InAt(0); 1334 switch (neg->GetResultType()) { 1335 case Primitive::kPrimInt: 1336 DCHECK(in.IsRegister()); 1337 __ rsb(out.AsRegister<Register>(), in.AsRegister<Register>(), ShifterOperand(0)); 1338 break; 1339 1340 case Primitive::kPrimLong: 1341 DCHECK(in.IsRegisterPair()); 1342 // out.lo = 0 - in.lo (and update the carry/borrow (C) flag) 1343 __ rsbs(out.AsRegisterPairLow<Register>(), 1344 in.AsRegisterPairLow<Register>(), 1345 ShifterOperand(0)); 1346 // We cannot emit an RSC (Reverse Subtract with Carry) 1347 // instruction here, as it does not exist in the Thumb-2 1348 // instruction set. We use the following approach 1349 // using SBC and SUB instead. 1350 // 1351 // out.hi = -C 1352 __ sbc(out.AsRegisterPairHigh<Register>(), 1353 out.AsRegisterPairHigh<Register>(), 1354 ShifterOperand(out.AsRegisterPairHigh<Register>())); 1355 // out.hi = out.hi - in.hi 1356 __ sub(out.AsRegisterPairHigh<Register>(), 1357 out.AsRegisterPairHigh<Register>(), 1358 ShifterOperand(in.AsRegisterPairHigh<Register>())); 1359 break; 1360 1361 case Primitive::kPrimFloat: 1362 DCHECK(in.IsFpuRegister()); 1363 __ vnegs(out.AsFpuRegister<SRegister>(), in.AsFpuRegister<SRegister>()); 1364 break; 1365 1366 case Primitive::kPrimDouble: 1367 DCHECK(in.IsFpuRegisterPair()); 1368 __ vnegd(FromLowSToD(out.AsFpuRegisterPairLow<SRegister>()), 1369 FromLowSToD(in.AsFpuRegisterPairLow<SRegister>())); 1370 break; 1371 1372 default: 1373 LOG(FATAL) << "Unexpected neg type " << neg->GetResultType(); 1374 } 1375} 1376 1377void LocationsBuilderARM::VisitTypeConversion(HTypeConversion* conversion) { 1378 Primitive::Type result_type = conversion->GetResultType(); 1379 Primitive::Type input_type = conversion->GetInputType(); 1380 DCHECK_NE(result_type, input_type); 1381 1382 // The float-to-long and double-to-long type conversions rely on a 1383 // call to the runtime. 1384 LocationSummary::CallKind call_kind = 1385 ((input_type == Primitive::kPrimFloat || input_type == Primitive::kPrimDouble) 1386 && result_type == Primitive::kPrimLong) 1387 ? LocationSummary::kCall 1388 : LocationSummary::kNoCall; 1389 LocationSummary* locations = 1390 new (GetGraph()->GetArena()) LocationSummary(conversion, call_kind); 1391 1392 switch (result_type) { 1393 case Primitive::kPrimByte: 1394 switch (input_type) { 1395 case Primitive::kPrimShort: 1396 case Primitive::kPrimInt: 1397 case Primitive::kPrimChar: 1398 // Processing a Dex `int-to-byte' instruction. 1399 locations->SetInAt(0, Location::RequiresRegister()); 1400 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 1401 break; 1402 1403 default: 1404 LOG(FATAL) << "Unexpected type conversion from " << input_type 1405 << " to " << result_type; 1406 } 1407 break; 1408 1409 case Primitive::kPrimShort: 1410 switch (input_type) { 1411 case Primitive::kPrimByte: 1412 case Primitive::kPrimInt: 1413 case Primitive::kPrimChar: 1414 // Processing a Dex `int-to-short' instruction. 1415 locations->SetInAt(0, Location::RequiresRegister()); 1416 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 1417 break; 1418 1419 default: 1420 LOG(FATAL) << "Unexpected type conversion from " << input_type 1421 << " to " << result_type; 1422 } 1423 break; 1424 1425 case Primitive::kPrimInt: 1426 switch (input_type) { 1427 case Primitive::kPrimLong: 1428 // Processing a Dex `long-to-int' instruction. 1429 locations->SetInAt(0, Location::Any()); 1430 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 1431 break; 1432 1433 case Primitive::kPrimFloat: 1434 // Processing a Dex `float-to-int' instruction. 1435 locations->SetInAt(0, Location::RequiresFpuRegister()); 1436 locations->SetOut(Location::RequiresRegister()); 1437 locations->AddTemp(Location::RequiresFpuRegister()); 1438 break; 1439 1440 case Primitive::kPrimDouble: 1441 // Processing a Dex `double-to-int' instruction. 1442 locations->SetInAt(0, Location::RequiresFpuRegister()); 1443 locations->SetOut(Location::RequiresRegister()); 1444 locations->AddTemp(Location::RequiresFpuRegister()); 1445 break; 1446 1447 default: 1448 LOG(FATAL) << "Unexpected type conversion from " << input_type 1449 << " to " << result_type; 1450 } 1451 break; 1452 1453 case Primitive::kPrimLong: 1454 switch (input_type) { 1455 case Primitive::kPrimByte: 1456 case Primitive::kPrimShort: 1457 case Primitive::kPrimInt: 1458 case Primitive::kPrimChar: 1459 // Processing a Dex `int-to-long' instruction. 1460 locations->SetInAt(0, Location::RequiresRegister()); 1461 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 1462 break; 1463 1464 case Primitive::kPrimFloat: { 1465 // Processing a Dex `float-to-long' instruction. 1466 InvokeRuntimeCallingConvention calling_convention; 1467 locations->SetInAt(0, Location::FpuRegisterLocation( 1468 calling_convention.GetFpuRegisterAt(0))); 1469 locations->SetOut(Location::RegisterPairLocation(R0, R1)); 1470 break; 1471 } 1472 1473 case Primitive::kPrimDouble: { 1474 // Processing a Dex `double-to-long' instruction. 1475 InvokeRuntimeCallingConvention calling_convention; 1476 locations->SetInAt(0, Location::FpuRegisterPairLocation( 1477 calling_convention.GetFpuRegisterAt(0), 1478 calling_convention.GetFpuRegisterAt(1))); 1479 locations->SetOut(Location::RegisterPairLocation(R0, R1)); 1480 break; 1481 } 1482 1483 default: 1484 LOG(FATAL) << "Unexpected type conversion from " << input_type 1485 << " to " << result_type; 1486 } 1487 break; 1488 1489 case Primitive::kPrimChar: 1490 switch (input_type) { 1491 case Primitive::kPrimByte: 1492 case Primitive::kPrimShort: 1493 case Primitive::kPrimInt: 1494 // Processing a Dex `int-to-char' instruction. 1495 locations->SetInAt(0, Location::RequiresRegister()); 1496 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 1497 break; 1498 1499 default: 1500 LOG(FATAL) << "Unexpected type conversion from " << input_type 1501 << " to " << result_type; 1502 } 1503 break; 1504 1505 case Primitive::kPrimFloat: 1506 switch (input_type) { 1507 case Primitive::kPrimByte: 1508 case Primitive::kPrimShort: 1509 case Primitive::kPrimInt: 1510 case Primitive::kPrimChar: 1511 // Processing a Dex `int-to-float' instruction. 1512 locations->SetInAt(0, Location::RequiresRegister()); 1513 locations->SetOut(Location::RequiresFpuRegister()); 1514 break; 1515 1516 case Primitive::kPrimLong: 1517 // Processing a Dex `long-to-float' instruction. 1518 locations->SetInAt(0, Location::RequiresRegister()); 1519 locations->SetOut(Location::RequiresFpuRegister()); 1520 locations->AddTemp(Location::RequiresRegister()); 1521 locations->AddTemp(Location::RequiresRegister()); 1522 locations->AddTemp(Location::RequiresFpuRegister()); 1523 locations->AddTemp(Location::RequiresFpuRegister()); 1524 break; 1525 1526 case Primitive::kPrimDouble: 1527 // Processing a Dex `double-to-float' instruction. 1528 locations->SetInAt(0, Location::RequiresFpuRegister()); 1529 locations->SetOut(Location::RequiresFpuRegister(), Location::kNoOutputOverlap); 1530 break; 1531 1532 default: 1533 LOG(FATAL) << "Unexpected type conversion from " << input_type 1534 << " to " << result_type; 1535 }; 1536 break; 1537 1538 case Primitive::kPrimDouble: 1539 switch (input_type) { 1540 case Primitive::kPrimByte: 1541 case Primitive::kPrimShort: 1542 case Primitive::kPrimInt: 1543 case Primitive::kPrimChar: 1544 // Processing a Dex `int-to-double' instruction. 1545 locations->SetInAt(0, Location::RequiresRegister()); 1546 locations->SetOut(Location::RequiresFpuRegister()); 1547 break; 1548 1549 case Primitive::kPrimLong: 1550 // Processing a Dex `long-to-double' instruction. 1551 locations->SetInAt(0, Location::RequiresRegister()); 1552 locations->SetOut(Location::RequiresFpuRegister()); 1553 locations->AddTemp(Location::RequiresRegister()); 1554 locations->AddTemp(Location::RequiresRegister()); 1555 locations->AddTemp(Location::RequiresFpuRegister()); 1556 break; 1557 1558 case Primitive::kPrimFloat: 1559 // Processing a Dex `float-to-double' instruction. 1560 locations->SetInAt(0, Location::RequiresFpuRegister()); 1561 locations->SetOut(Location::RequiresFpuRegister(), Location::kNoOutputOverlap); 1562 break; 1563 1564 default: 1565 LOG(FATAL) << "Unexpected type conversion from " << input_type 1566 << " to " << result_type; 1567 }; 1568 break; 1569 1570 default: 1571 LOG(FATAL) << "Unexpected type conversion from " << input_type 1572 << " to " << result_type; 1573 } 1574} 1575 1576void InstructionCodeGeneratorARM::VisitTypeConversion(HTypeConversion* conversion) { 1577 LocationSummary* locations = conversion->GetLocations(); 1578 Location out = locations->Out(); 1579 Location in = locations->InAt(0); 1580 Primitive::Type result_type = conversion->GetResultType(); 1581 Primitive::Type input_type = conversion->GetInputType(); 1582 DCHECK_NE(result_type, input_type); 1583 switch (result_type) { 1584 case Primitive::kPrimByte: 1585 switch (input_type) { 1586 case Primitive::kPrimShort: 1587 case Primitive::kPrimInt: 1588 case Primitive::kPrimChar: 1589 // Processing a Dex `int-to-byte' instruction. 1590 __ sbfx(out.AsRegister<Register>(), in.AsRegister<Register>(), 0, 8); 1591 break; 1592 1593 default: 1594 LOG(FATAL) << "Unexpected type conversion from " << input_type 1595 << " to " << result_type; 1596 } 1597 break; 1598 1599 case Primitive::kPrimShort: 1600 switch (input_type) { 1601 case Primitive::kPrimByte: 1602 case Primitive::kPrimInt: 1603 case Primitive::kPrimChar: 1604 // Processing a Dex `int-to-short' instruction. 1605 __ sbfx(out.AsRegister<Register>(), in.AsRegister<Register>(), 0, 16); 1606 break; 1607 1608 default: 1609 LOG(FATAL) << "Unexpected type conversion from " << input_type 1610 << " to " << result_type; 1611 } 1612 break; 1613 1614 case Primitive::kPrimInt: 1615 switch (input_type) { 1616 case Primitive::kPrimLong: 1617 // Processing a Dex `long-to-int' instruction. 1618 DCHECK(out.IsRegister()); 1619 if (in.IsRegisterPair()) { 1620 __ Mov(out.AsRegister<Register>(), in.AsRegisterPairLow<Register>()); 1621 } else if (in.IsDoubleStackSlot()) { 1622 __ LoadFromOffset(kLoadWord, out.AsRegister<Register>(), SP, in.GetStackIndex()); 1623 } else { 1624 DCHECK(in.IsConstant()); 1625 DCHECK(in.GetConstant()->IsLongConstant()); 1626 int64_t value = in.GetConstant()->AsLongConstant()->GetValue(); 1627 __ LoadImmediate(out.AsRegister<Register>(), static_cast<int32_t>(value)); 1628 } 1629 break; 1630 1631 case Primitive::kPrimFloat: { 1632 // Processing a Dex `float-to-int' instruction. 1633 SRegister temp = locations->GetTemp(0).AsFpuRegisterPairLow<SRegister>(); 1634 __ vmovs(temp, in.AsFpuRegister<SRegister>()); 1635 __ vcvtis(temp, temp); 1636 __ vmovrs(out.AsRegister<Register>(), temp); 1637 break; 1638 } 1639 1640 case Primitive::kPrimDouble: { 1641 // Processing a Dex `double-to-int' instruction. 1642 SRegister temp_s = locations->GetTemp(0).AsFpuRegisterPairLow<SRegister>(); 1643 DRegister temp_d = FromLowSToD(temp_s); 1644 __ vmovd(temp_d, FromLowSToD(in.AsFpuRegisterPairLow<SRegister>())); 1645 __ vcvtid(temp_s, temp_d); 1646 __ vmovrs(out.AsRegister<Register>(), temp_s); 1647 break; 1648 } 1649 1650 default: 1651 LOG(FATAL) << "Unexpected type conversion from " << input_type 1652 << " to " << result_type; 1653 } 1654 break; 1655 1656 case Primitive::kPrimLong: 1657 switch (input_type) { 1658 case Primitive::kPrimByte: 1659 case Primitive::kPrimShort: 1660 case Primitive::kPrimInt: 1661 case Primitive::kPrimChar: 1662 // Processing a Dex `int-to-long' instruction. 1663 DCHECK(out.IsRegisterPair()); 1664 DCHECK(in.IsRegister()); 1665 __ Mov(out.AsRegisterPairLow<Register>(), in.AsRegister<Register>()); 1666 // Sign extension. 1667 __ Asr(out.AsRegisterPairHigh<Register>(), 1668 out.AsRegisterPairLow<Register>(), 1669 31); 1670 break; 1671 1672 case Primitive::kPrimFloat: 1673 // Processing a Dex `float-to-long' instruction. 1674 codegen_->InvokeRuntime(QUICK_ENTRY_POINT(pF2l), 1675 conversion, 1676 conversion->GetDexPc()); 1677 break; 1678 1679 case Primitive::kPrimDouble: 1680 // Processing a Dex `double-to-long' instruction. 1681 codegen_->InvokeRuntime(QUICK_ENTRY_POINT(pD2l), 1682 conversion, 1683 conversion->GetDexPc()); 1684 break; 1685 1686 default: 1687 LOG(FATAL) << "Unexpected type conversion from " << input_type 1688 << " to " << result_type; 1689 } 1690 break; 1691 1692 case Primitive::kPrimChar: 1693 switch (input_type) { 1694 case Primitive::kPrimByte: 1695 case Primitive::kPrimShort: 1696 case Primitive::kPrimInt: 1697 // Processing a Dex `int-to-char' instruction. 1698 __ ubfx(out.AsRegister<Register>(), in.AsRegister<Register>(), 0, 16); 1699 break; 1700 1701 default: 1702 LOG(FATAL) << "Unexpected type conversion from " << input_type 1703 << " to " << result_type; 1704 } 1705 break; 1706 1707 case Primitive::kPrimFloat: 1708 switch (input_type) { 1709 case Primitive::kPrimByte: 1710 case Primitive::kPrimShort: 1711 case Primitive::kPrimInt: 1712 case Primitive::kPrimChar: { 1713 // Processing a Dex `int-to-float' instruction. 1714 __ vmovsr(out.AsFpuRegister<SRegister>(), in.AsRegister<Register>()); 1715 __ vcvtsi(out.AsFpuRegister<SRegister>(), out.AsFpuRegister<SRegister>()); 1716 break; 1717 } 1718 1719 case Primitive::kPrimLong: { 1720 // Processing a Dex `long-to-float' instruction. 1721 Register low = in.AsRegisterPairLow<Register>(); 1722 Register high = in.AsRegisterPairHigh<Register>(); 1723 SRegister output = out.AsFpuRegister<SRegister>(); 1724 Register constant_low = locations->GetTemp(0).AsRegister<Register>(); 1725 Register constant_high = locations->GetTemp(1).AsRegister<Register>(); 1726 SRegister temp1_s = locations->GetTemp(2).AsFpuRegisterPairLow<SRegister>(); 1727 DRegister temp1_d = FromLowSToD(temp1_s); 1728 SRegister temp2_s = locations->GetTemp(3).AsFpuRegisterPairLow<SRegister>(); 1729 DRegister temp2_d = FromLowSToD(temp2_s); 1730 1731 // Operations use doubles for precision reasons (each 32-bit 1732 // half of a long fits in the 53-bit mantissa of a double, 1733 // but not in the 24-bit mantissa of a float). This is 1734 // especially important for the low bits. The result is 1735 // eventually converted to float. 1736 1737 // temp1_d = int-to-double(high) 1738 __ vmovsr(temp1_s, high); 1739 __ vcvtdi(temp1_d, temp1_s); 1740 // Using vmovd to load the `k2Pow32EncodingForDouble` constant 1741 // as an immediate value into `temp2_d` does not work, as 1742 // this instruction only transfers 8 significant bits of its 1743 // immediate operand. Instead, use two 32-bit core 1744 // registers to load `k2Pow32EncodingForDouble` into 1745 // `temp2_d`. 1746 __ LoadImmediate(constant_low, Low32Bits(k2Pow32EncodingForDouble)); 1747 __ LoadImmediate(constant_high, High32Bits(k2Pow32EncodingForDouble)); 1748 __ vmovdrr(temp2_d, constant_low, constant_high); 1749 // temp1_d = temp1_d * 2^32 1750 __ vmuld(temp1_d, temp1_d, temp2_d); 1751 // temp2_d = unsigned-to-double(low) 1752 __ vmovsr(temp2_s, low); 1753 __ vcvtdu(temp2_d, temp2_s); 1754 // temp1_d = temp1_d + temp2_d 1755 __ vaddd(temp1_d, temp1_d, temp2_d); 1756 // output = double-to-float(temp1_d); 1757 __ vcvtsd(output, temp1_d); 1758 break; 1759 } 1760 1761 case Primitive::kPrimDouble: 1762 // Processing a Dex `double-to-float' instruction. 1763 __ vcvtsd(out.AsFpuRegister<SRegister>(), 1764 FromLowSToD(in.AsFpuRegisterPairLow<SRegister>())); 1765 break; 1766 1767 default: 1768 LOG(FATAL) << "Unexpected type conversion from " << input_type 1769 << " to " << result_type; 1770 }; 1771 break; 1772 1773 case Primitive::kPrimDouble: 1774 switch (input_type) { 1775 case Primitive::kPrimByte: 1776 case Primitive::kPrimShort: 1777 case Primitive::kPrimInt: 1778 case Primitive::kPrimChar: { 1779 // Processing a Dex `int-to-double' instruction. 1780 __ vmovsr(out.AsFpuRegisterPairLow<SRegister>(), in.AsRegister<Register>()); 1781 __ vcvtdi(FromLowSToD(out.AsFpuRegisterPairLow<SRegister>()), 1782 out.AsFpuRegisterPairLow<SRegister>()); 1783 break; 1784 } 1785 1786 case Primitive::kPrimLong: { 1787 // Processing a Dex `long-to-double' instruction. 1788 Register low = in.AsRegisterPairLow<Register>(); 1789 Register high = in.AsRegisterPairHigh<Register>(); 1790 SRegister out_s = out.AsFpuRegisterPairLow<SRegister>(); 1791 DRegister out_d = FromLowSToD(out_s); 1792 Register constant_low = locations->GetTemp(0).AsRegister<Register>(); 1793 Register constant_high = locations->GetTemp(1).AsRegister<Register>(); 1794 SRegister temp_s = locations->GetTemp(2).AsFpuRegisterPairLow<SRegister>(); 1795 DRegister temp_d = FromLowSToD(temp_s); 1796 1797 // out_d = int-to-double(high) 1798 __ vmovsr(out_s, high); 1799 __ vcvtdi(out_d, out_s); 1800 // Using vmovd to load the `k2Pow32EncodingForDouble` constant 1801 // as an immediate value into `temp_d` does not work, as 1802 // this instruction only transfers 8 significant bits of its 1803 // immediate operand. Instead, use two 32-bit core 1804 // registers to load `k2Pow32EncodingForDouble` into `temp_d`. 1805 __ LoadImmediate(constant_low, Low32Bits(k2Pow32EncodingForDouble)); 1806 __ LoadImmediate(constant_high, High32Bits(k2Pow32EncodingForDouble)); 1807 __ vmovdrr(temp_d, constant_low, constant_high); 1808 // out_d = out_d * 2^32 1809 __ vmuld(out_d, out_d, temp_d); 1810 // temp_d = unsigned-to-double(low) 1811 __ vmovsr(temp_s, low); 1812 __ vcvtdu(temp_d, temp_s); 1813 // out_d = out_d + temp_d 1814 __ vaddd(out_d, out_d, temp_d); 1815 break; 1816 } 1817 1818 case Primitive::kPrimFloat: 1819 // Processing a Dex `float-to-double' instruction. 1820 __ vcvtds(FromLowSToD(out.AsFpuRegisterPairLow<SRegister>()), 1821 in.AsFpuRegister<SRegister>()); 1822 break; 1823 1824 default: 1825 LOG(FATAL) << "Unexpected type conversion from " << input_type 1826 << " to " << result_type; 1827 }; 1828 break; 1829 1830 default: 1831 LOG(FATAL) << "Unexpected type conversion from " << input_type 1832 << " to " << result_type; 1833 } 1834} 1835 1836void LocationsBuilderARM::VisitAdd(HAdd* add) { 1837 LocationSummary* locations = 1838 new (GetGraph()->GetArena()) LocationSummary(add, LocationSummary::kNoCall); 1839 switch (add->GetResultType()) { 1840 case Primitive::kPrimInt: { 1841 locations->SetInAt(0, Location::RequiresRegister()); 1842 locations->SetInAt(1, Location::RegisterOrConstant(add->InputAt(1))); 1843 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 1844 break; 1845 } 1846 1847 case Primitive::kPrimLong: { 1848 locations->SetInAt(0, Location::RequiresRegister()); 1849 locations->SetInAt(1, Location::RequiresRegister()); 1850 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 1851 break; 1852 } 1853 1854 case Primitive::kPrimFloat: 1855 case Primitive::kPrimDouble: { 1856 locations->SetInAt(0, Location::RequiresFpuRegister()); 1857 locations->SetInAt(1, Location::RequiresFpuRegister()); 1858 locations->SetOut(Location::RequiresFpuRegister(), Location::kNoOutputOverlap); 1859 break; 1860 } 1861 1862 default: 1863 LOG(FATAL) << "Unexpected add type " << add->GetResultType(); 1864 } 1865} 1866 1867void InstructionCodeGeneratorARM::VisitAdd(HAdd* add) { 1868 LocationSummary* locations = add->GetLocations(); 1869 Location out = locations->Out(); 1870 Location first = locations->InAt(0); 1871 Location second = locations->InAt(1); 1872 switch (add->GetResultType()) { 1873 case Primitive::kPrimInt: 1874 if (second.IsRegister()) { 1875 __ add(out.AsRegister<Register>(), 1876 first.AsRegister<Register>(), 1877 ShifterOperand(second.AsRegister<Register>())); 1878 } else { 1879 __ AddConstant(out.AsRegister<Register>(), 1880 first.AsRegister<Register>(), 1881 second.GetConstant()->AsIntConstant()->GetValue()); 1882 } 1883 break; 1884 1885 case Primitive::kPrimLong: { 1886 DCHECK(second.IsRegisterPair()); 1887 __ adds(out.AsRegisterPairLow<Register>(), 1888 first.AsRegisterPairLow<Register>(), 1889 ShifterOperand(second.AsRegisterPairLow<Register>())); 1890 __ adc(out.AsRegisterPairHigh<Register>(), 1891 first.AsRegisterPairHigh<Register>(), 1892 ShifterOperand(second.AsRegisterPairHigh<Register>())); 1893 break; 1894 } 1895 1896 case Primitive::kPrimFloat: 1897 __ vadds(out.AsFpuRegister<SRegister>(), 1898 first.AsFpuRegister<SRegister>(), 1899 second.AsFpuRegister<SRegister>()); 1900 break; 1901 1902 case Primitive::kPrimDouble: 1903 __ vaddd(FromLowSToD(out.AsFpuRegisterPairLow<SRegister>()), 1904 FromLowSToD(first.AsFpuRegisterPairLow<SRegister>()), 1905 FromLowSToD(second.AsFpuRegisterPairLow<SRegister>())); 1906 break; 1907 1908 default: 1909 LOG(FATAL) << "Unexpected add type " << add->GetResultType(); 1910 } 1911} 1912 1913void LocationsBuilderARM::VisitSub(HSub* sub) { 1914 LocationSummary* locations = 1915 new (GetGraph()->GetArena()) LocationSummary(sub, LocationSummary::kNoCall); 1916 switch (sub->GetResultType()) { 1917 case Primitive::kPrimInt: { 1918 locations->SetInAt(0, Location::RequiresRegister()); 1919 locations->SetInAt(1, Location::RegisterOrConstant(sub->InputAt(1))); 1920 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 1921 break; 1922 } 1923 1924 case Primitive::kPrimLong: { 1925 locations->SetInAt(0, Location::RequiresRegister()); 1926 locations->SetInAt(1, Location::RequiresRegister()); 1927 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 1928 break; 1929 } 1930 case Primitive::kPrimFloat: 1931 case Primitive::kPrimDouble: { 1932 locations->SetInAt(0, Location::RequiresFpuRegister()); 1933 locations->SetInAt(1, Location::RequiresFpuRegister()); 1934 locations->SetOut(Location::RequiresFpuRegister(), Location::kNoOutputOverlap); 1935 break; 1936 } 1937 default: 1938 LOG(FATAL) << "Unexpected sub type " << sub->GetResultType(); 1939 } 1940} 1941 1942void InstructionCodeGeneratorARM::VisitSub(HSub* sub) { 1943 LocationSummary* locations = sub->GetLocations(); 1944 Location out = locations->Out(); 1945 Location first = locations->InAt(0); 1946 Location second = locations->InAt(1); 1947 switch (sub->GetResultType()) { 1948 case Primitive::kPrimInt: { 1949 if (second.IsRegister()) { 1950 __ sub(out.AsRegister<Register>(), 1951 first.AsRegister<Register>(), 1952 ShifterOperand(second.AsRegister<Register>())); 1953 } else { 1954 __ AddConstant(out.AsRegister<Register>(), 1955 first.AsRegister<Register>(), 1956 -second.GetConstant()->AsIntConstant()->GetValue()); 1957 } 1958 break; 1959 } 1960 1961 case Primitive::kPrimLong: { 1962 DCHECK(second.IsRegisterPair()); 1963 __ subs(out.AsRegisterPairLow<Register>(), 1964 first.AsRegisterPairLow<Register>(), 1965 ShifterOperand(second.AsRegisterPairLow<Register>())); 1966 __ sbc(out.AsRegisterPairHigh<Register>(), 1967 first.AsRegisterPairHigh<Register>(), 1968 ShifterOperand(second.AsRegisterPairHigh<Register>())); 1969 break; 1970 } 1971 1972 case Primitive::kPrimFloat: { 1973 __ vsubs(out.AsFpuRegister<SRegister>(), 1974 first.AsFpuRegister<SRegister>(), 1975 second.AsFpuRegister<SRegister>()); 1976 break; 1977 } 1978 1979 case Primitive::kPrimDouble: { 1980 __ vsubd(FromLowSToD(out.AsFpuRegisterPairLow<SRegister>()), 1981 FromLowSToD(first.AsFpuRegisterPairLow<SRegister>()), 1982 FromLowSToD(second.AsFpuRegisterPairLow<SRegister>())); 1983 break; 1984 } 1985 1986 1987 default: 1988 LOG(FATAL) << "Unexpected sub type " << sub->GetResultType(); 1989 } 1990} 1991 1992void LocationsBuilderARM::VisitMul(HMul* mul) { 1993 LocationSummary* locations = 1994 new (GetGraph()->GetArena()) LocationSummary(mul, LocationSummary::kNoCall); 1995 switch (mul->GetResultType()) { 1996 case Primitive::kPrimInt: 1997 case Primitive::kPrimLong: { 1998 locations->SetInAt(0, Location::RequiresRegister()); 1999 locations->SetInAt(1, Location::RequiresRegister()); 2000 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 2001 break; 2002 } 2003 2004 case Primitive::kPrimFloat: 2005 case Primitive::kPrimDouble: { 2006 locations->SetInAt(0, Location::RequiresFpuRegister()); 2007 locations->SetInAt(1, Location::RequiresFpuRegister()); 2008 locations->SetOut(Location::RequiresFpuRegister(), Location::kNoOutputOverlap); 2009 break; 2010 } 2011 2012 default: 2013 LOG(FATAL) << "Unexpected mul type " << mul->GetResultType(); 2014 } 2015} 2016 2017void InstructionCodeGeneratorARM::VisitMul(HMul* mul) { 2018 LocationSummary* locations = mul->GetLocations(); 2019 Location out = locations->Out(); 2020 Location first = locations->InAt(0); 2021 Location second = locations->InAt(1); 2022 switch (mul->GetResultType()) { 2023 case Primitive::kPrimInt: { 2024 __ mul(out.AsRegister<Register>(), 2025 first.AsRegister<Register>(), 2026 second.AsRegister<Register>()); 2027 break; 2028 } 2029 case Primitive::kPrimLong: { 2030 Register out_hi = out.AsRegisterPairHigh<Register>(); 2031 Register out_lo = out.AsRegisterPairLow<Register>(); 2032 Register in1_hi = first.AsRegisterPairHigh<Register>(); 2033 Register in1_lo = first.AsRegisterPairLow<Register>(); 2034 Register in2_hi = second.AsRegisterPairHigh<Register>(); 2035 Register in2_lo = second.AsRegisterPairLow<Register>(); 2036 2037 // Extra checks to protect caused by the existence of R1_R2. 2038 // The algorithm is wrong if out.hi is either in1.lo or in2.lo: 2039 // (e.g. in1=r0_r1, in2=r2_r3 and out=r1_r2); 2040 DCHECK_NE(out_hi, in1_lo); 2041 DCHECK_NE(out_hi, in2_lo); 2042 2043 // input: in1 - 64 bits, in2 - 64 bits 2044 // output: out 2045 // formula: out.hi : out.lo = (in1.lo * in2.hi + in1.hi * in2.lo)* 2^32 + in1.lo * in2.lo 2046 // parts: out.hi = in1.lo * in2.hi + in1.hi * in2.lo + (in1.lo * in2.lo)[63:32] 2047 // parts: out.lo = (in1.lo * in2.lo)[31:0] 2048 2049 // IP <- in1.lo * in2.hi 2050 __ mul(IP, in1_lo, in2_hi); 2051 // out.hi <- in1.lo * in2.hi + in1.hi * in2.lo 2052 __ mla(out_hi, in1_hi, in2_lo, IP); 2053 // out.lo <- (in1.lo * in2.lo)[31:0]; 2054 __ umull(out_lo, IP, in1_lo, in2_lo); 2055 // out.hi <- in2.hi * in1.lo + in2.lo * in1.hi + (in1.lo * in2.lo)[63:32] 2056 __ add(out_hi, out_hi, ShifterOperand(IP)); 2057 break; 2058 } 2059 2060 case Primitive::kPrimFloat: { 2061 __ vmuls(out.AsFpuRegister<SRegister>(), 2062 first.AsFpuRegister<SRegister>(), 2063 second.AsFpuRegister<SRegister>()); 2064 break; 2065 } 2066 2067 case Primitive::kPrimDouble: { 2068 __ vmuld(FromLowSToD(out.AsFpuRegisterPairLow<SRegister>()), 2069 FromLowSToD(first.AsFpuRegisterPairLow<SRegister>()), 2070 FromLowSToD(second.AsFpuRegisterPairLow<SRegister>())); 2071 break; 2072 } 2073 2074 default: 2075 LOG(FATAL) << "Unexpected mul type " << mul->GetResultType(); 2076 } 2077} 2078 2079void LocationsBuilderARM::VisitDiv(HDiv* div) { 2080 LocationSummary::CallKind call_kind = div->GetResultType() == Primitive::kPrimLong 2081 ? LocationSummary::kCall 2082 : LocationSummary::kNoCall; 2083 LocationSummary* locations = new (GetGraph()->GetArena()) LocationSummary(div, call_kind); 2084 2085 switch (div->GetResultType()) { 2086 case Primitive::kPrimInt: { 2087 locations->SetInAt(0, Location::RequiresRegister()); 2088 locations->SetInAt(1, Location::RequiresRegister()); 2089 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 2090 break; 2091 } 2092 case Primitive::kPrimLong: { 2093 InvokeRuntimeCallingConvention calling_convention; 2094 locations->SetInAt(0, Location::RegisterPairLocation( 2095 calling_convention.GetRegisterAt(0), calling_convention.GetRegisterAt(1))); 2096 locations->SetInAt(1, Location::RegisterPairLocation( 2097 calling_convention.GetRegisterAt(2), calling_convention.GetRegisterAt(3))); 2098 locations->SetOut(Location::RegisterPairLocation(R0, R1)); 2099 break; 2100 } 2101 case Primitive::kPrimFloat: 2102 case Primitive::kPrimDouble: { 2103 locations->SetInAt(0, Location::RequiresFpuRegister()); 2104 locations->SetInAt(1, Location::RequiresFpuRegister()); 2105 locations->SetOut(Location::RequiresFpuRegister(), Location::kNoOutputOverlap); 2106 break; 2107 } 2108 2109 default: 2110 LOG(FATAL) << "Unexpected div type " << div->GetResultType(); 2111 } 2112} 2113 2114void InstructionCodeGeneratorARM::VisitDiv(HDiv* div) { 2115 LocationSummary* locations = div->GetLocations(); 2116 Location out = locations->Out(); 2117 Location first = locations->InAt(0); 2118 Location second = locations->InAt(1); 2119 2120 switch (div->GetResultType()) { 2121 case Primitive::kPrimInt: { 2122 __ sdiv(out.AsRegister<Register>(), 2123 first.AsRegister<Register>(), 2124 second.AsRegister<Register>()); 2125 break; 2126 } 2127 2128 case Primitive::kPrimLong: { 2129 InvokeRuntimeCallingConvention calling_convention; 2130 DCHECK_EQ(calling_convention.GetRegisterAt(0), first.AsRegisterPairLow<Register>()); 2131 DCHECK_EQ(calling_convention.GetRegisterAt(1), first.AsRegisterPairHigh<Register>()); 2132 DCHECK_EQ(calling_convention.GetRegisterAt(2), second.AsRegisterPairLow<Register>()); 2133 DCHECK_EQ(calling_convention.GetRegisterAt(3), second.AsRegisterPairHigh<Register>()); 2134 DCHECK_EQ(R0, out.AsRegisterPairLow<Register>()); 2135 DCHECK_EQ(R1, out.AsRegisterPairHigh<Register>()); 2136 2137 codegen_->InvokeRuntime(QUICK_ENTRY_POINT(pLdiv), div, div->GetDexPc()); 2138 break; 2139 } 2140 2141 case Primitive::kPrimFloat: { 2142 __ vdivs(out.AsFpuRegister<SRegister>(), 2143 first.AsFpuRegister<SRegister>(), 2144 second.AsFpuRegister<SRegister>()); 2145 break; 2146 } 2147 2148 case Primitive::kPrimDouble: { 2149 __ vdivd(FromLowSToD(out.AsFpuRegisterPairLow<SRegister>()), 2150 FromLowSToD(first.AsFpuRegisterPairLow<SRegister>()), 2151 FromLowSToD(second.AsFpuRegisterPairLow<SRegister>())); 2152 break; 2153 } 2154 2155 default: 2156 LOG(FATAL) << "Unexpected div type " << div->GetResultType(); 2157 } 2158} 2159 2160void LocationsBuilderARM::VisitRem(HRem* rem) { 2161 Primitive::Type type = rem->GetResultType(); 2162 LocationSummary::CallKind call_kind = type == Primitive::kPrimInt 2163 ? LocationSummary::kNoCall 2164 : LocationSummary::kCall; 2165 LocationSummary* locations = new (GetGraph()->GetArena()) LocationSummary(rem, call_kind); 2166 2167 switch (type) { 2168 case Primitive::kPrimInt: { 2169 locations->SetInAt(0, Location::RequiresRegister()); 2170 locations->SetInAt(1, Location::RequiresRegister()); 2171 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 2172 locations->AddTemp(Location::RequiresRegister()); 2173 break; 2174 } 2175 case Primitive::kPrimLong: { 2176 InvokeRuntimeCallingConvention calling_convention; 2177 locations->SetInAt(0, Location::RegisterPairLocation( 2178 calling_convention.GetRegisterAt(0), calling_convention.GetRegisterAt(1))); 2179 locations->SetInAt(1, Location::RegisterPairLocation( 2180 calling_convention.GetRegisterAt(2), calling_convention.GetRegisterAt(3))); 2181 // The runtime helper puts the output in R2,R3. 2182 locations->SetOut(Location::RegisterPairLocation(R2, R3)); 2183 break; 2184 } 2185 case Primitive::kPrimFloat: { 2186 InvokeRuntimeCallingConvention calling_convention; 2187 locations->SetInAt(0, Location::FpuRegisterLocation(calling_convention.GetFpuRegisterAt(0))); 2188 locations->SetInAt(1, Location::FpuRegisterLocation(calling_convention.GetFpuRegisterAt(1))); 2189 locations->SetOut(Location::FpuRegisterLocation(S0)); 2190 break; 2191 } 2192 2193 case Primitive::kPrimDouble: { 2194 InvokeRuntimeCallingConvention calling_convention; 2195 locations->SetInAt(0, Location::FpuRegisterPairLocation( 2196 calling_convention.GetFpuRegisterAt(0), calling_convention.GetFpuRegisterAt(1))); 2197 locations->SetInAt(1, Location::FpuRegisterPairLocation( 2198 calling_convention.GetFpuRegisterAt(2), calling_convention.GetFpuRegisterAt(3))); 2199 locations->SetOut(Location::Location::FpuRegisterPairLocation(S0, S1)); 2200 break; 2201 } 2202 2203 default: 2204 LOG(FATAL) << "Unexpected rem type " << type; 2205 } 2206} 2207 2208void InstructionCodeGeneratorARM::VisitRem(HRem* rem) { 2209 LocationSummary* locations = rem->GetLocations(); 2210 Location out = locations->Out(); 2211 Location first = locations->InAt(0); 2212 Location second = locations->InAt(1); 2213 2214 Primitive::Type type = rem->GetResultType(); 2215 switch (type) { 2216 case Primitive::kPrimInt: { 2217 Register reg1 = first.AsRegister<Register>(); 2218 Register reg2 = second.AsRegister<Register>(); 2219 Register temp = locations->GetTemp(0).AsRegister<Register>(); 2220 2221 // temp = reg1 / reg2 (integer division) 2222 // temp = temp * reg2 2223 // dest = reg1 - temp 2224 __ sdiv(temp, reg1, reg2); 2225 __ mul(temp, temp, reg2); 2226 __ sub(out.AsRegister<Register>(), reg1, ShifterOperand(temp)); 2227 break; 2228 } 2229 2230 case Primitive::kPrimLong: { 2231 codegen_->InvokeRuntime(QUICK_ENTRY_POINT(pLmod), rem, rem->GetDexPc()); 2232 break; 2233 } 2234 2235 case Primitive::kPrimFloat: { 2236 codegen_->InvokeRuntime(QUICK_ENTRY_POINT(pFmodf), rem, rem->GetDexPc()); 2237 break; 2238 } 2239 2240 case Primitive::kPrimDouble: { 2241 codegen_->InvokeRuntime(QUICK_ENTRY_POINT(pFmod), rem, rem->GetDexPc()); 2242 break; 2243 } 2244 2245 default: 2246 LOG(FATAL) << "Unexpected rem type " << type; 2247 } 2248} 2249 2250void LocationsBuilderARM::VisitDivZeroCheck(HDivZeroCheck* instruction) { 2251 LocationSummary* locations = 2252 new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kNoCall); 2253 locations->SetInAt(0, Location::RegisterOrConstant(instruction->InputAt(0))); 2254 if (instruction->HasUses()) { 2255 locations->SetOut(Location::SameAsFirstInput()); 2256 } 2257} 2258 2259void InstructionCodeGeneratorARM::VisitDivZeroCheck(HDivZeroCheck* instruction) { 2260 SlowPathCodeARM* slow_path = new (GetGraph()->GetArena()) DivZeroCheckSlowPathARM(instruction); 2261 codegen_->AddSlowPath(slow_path); 2262 2263 LocationSummary* locations = instruction->GetLocations(); 2264 Location value = locations->InAt(0); 2265 2266 switch (instruction->GetType()) { 2267 case Primitive::kPrimInt: { 2268 if (value.IsRegister()) { 2269 __ cmp(value.AsRegister<Register>(), ShifterOperand(0)); 2270 __ b(slow_path->GetEntryLabel(), EQ); 2271 } else { 2272 DCHECK(value.IsConstant()) << value; 2273 if (value.GetConstant()->AsIntConstant()->GetValue() == 0) { 2274 __ b(slow_path->GetEntryLabel()); 2275 } 2276 } 2277 break; 2278 } 2279 case Primitive::kPrimLong: { 2280 if (value.IsRegisterPair()) { 2281 __ orrs(IP, 2282 value.AsRegisterPairLow<Register>(), 2283 ShifterOperand(value.AsRegisterPairHigh<Register>())); 2284 __ b(slow_path->GetEntryLabel(), EQ); 2285 } else { 2286 DCHECK(value.IsConstant()) << value; 2287 if (value.GetConstant()->AsLongConstant()->GetValue() == 0) { 2288 __ b(slow_path->GetEntryLabel()); 2289 } 2290 } 2291 break; 2292 default: 2293 LOG(FATAL) << "Unexpected type for HDivZeroCheck " << instruction->GetType(); 2294 } 2295 } 2296} 2297 2298void LocationsBuilderARM::HandleShift(HBinaryOperation* op) { 2299 DCHECK(op->IsShl() || op->IsShr() || op->IsUShr()); 2300 2301 LocationSummary::CallKind call_kind = op->GetResultType() == Primitive::kPrimLong 2302 ? LocationSummary::kCall 2303 : LocationSummary::kNoCall; 2304 LocationSummary* locations = new (GetGraph()->GetArena()) LocationSummary(op, call_kind); 2305 2306 switch (op->GetResultType()) { 2307 case Primitive::kPrimInt: { 2308 locations->SetInAt(0, Location::RequiresRegister()); 2309 locations->SetInAt(1, Location::RegisterOrConstant(op->InputAt(1))); 2310 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 2311 break; 2312 } 2313 case Primitive::kPrimLong: { 2314 InvokeRuntimeCallingConvention calling_convention; 2315 locations->SetInAt(0, Location::RegisterPairLocation( 2316 calling_convention.GetRegisterAt(0), calling_convention.GetRegisterAt(1))); 2317 locations->SetInAt(1, Location::RegisterLocation(calling_convention.GetRegisterAt(2))); 2318 // The runtime helper puts the output in R0,R1. 2319 locations->SetOut(Location::RegisterPairLocation(R0, R1)); 2320 break; 2321 } 2322 default: 2323 LOG(FATAL) << "Unexpected operation type " << op->GetResultType(); 2324 } 2325} 2326 2327void InstructionCodeGeneratorARM::HandleShift(HBinaryOperation* op) { 2328 DCHECK(op->IsShl() || op->IsShr() || op->IsUShr()); 2329 2330 LocationSummary* locations = op->GetLocations(); 2331 Location out = locations->Out(); 2332 Location first = locations->InAt(0); 2333 Location second = locations->InAt(1); 2334 2335 Primitive::Type type = op->GetResultType(); 2336 switch (type) { 2337 case Primitive::kPrimInt: { 2338 Register out_reg = out.AsRegister<Register>(); 2339 Register first_reg = first.AsRegister<Register>(); 2340 // Arm doesn't mask the shift count so we need to do it ourselves. 2341 if (second.IsRegister()) { 2342 Register second_reg = second.AsRegister<Register>(); 2343 __ and_(second_reg, second_reg, ShifterOperand(kMaxIntShiftValue)); 2344 if (op->IsShl()) { 2345 __ Lsl(out_reg, first_reg, second_reg); 2346 } else if (op->IsShr()) { 2347 __ Asr(out_reg, first_reg, second_reg); 2348 } else { 2349 __ Lsr(out_reg, first_reg, second_reg); 2350 } 2351 } else { 2352 int32_t cst = second.GetConstant()->AsIntConstant()->GetValue(); 2353 uint32_t shift_value = static_cast<uint32_t>(cst & kMaxIntShiftValue); 2354 if (shift_value == 0) { // arm does not support shifting with 0 immediate. 2355 __ Mov(out_reg, first_reg); 2356 } else if (op->IsShl()) { 2357 __ Lsl(out_reg, first_reg, shift_value); 2358 } else if (op->IsShr()) { 2359 __ Asr(out_reg, first_reg, shift_value); 2360 } else { 2361 __ Lsr(out_reg, first_reg, shift_value); 2362 } 2363 } 2364 break; 2365 } 2366 case Primitive::kPrimLong: { 2367 // TODO: Inline the assembly instead of calling the runtime. 2368 InvokeRuntimeCallingConvention calling_convention; 2369 DCHECK_EQ(calling_convention.GetRegisterAt(0), first.AsRegisterPairLow<Register>()); 2370 DCHECK_EQ(calling_convention.GetRegisterAt(1), first.AsRegisterPairHigh<Register>()); 2371 DCHECK_EQ(calling_convention.GetRegisterAt(2), second.AsRegister<Register>()); 2372 DCHECK_EQ(R0, out.AsRegisterPairLow<Register>()); 2373 DCHECK_EQ(R1, out.AsRegisterPairHigh<Register>()); 2374 2375 int32_t entry_point_offset; 2376 if (op->IsShl()) { 2377 entry_point_offset = QUICK_ENTRY_POINT(pShlLong); 2378 } else if (op->IsShr()) { 2379 entry_point_offset = QUICK_ENTRY_POINT(pShrLong); 2380 } else { 2381 entry_point_offset = QUICK_ENTRY_POINT(pUshrLong); 2382 } 2383 __ LoadFromOffset(kLoadWord, LR, TR, entry_point_offset); 2384 __ blx(LR); 2385 break; 2386 } 2387 default: 2388 LOG(FATAL) << "Unexpected operation type " << type; 2389 } 2390} 2391 2392void LocationsBuilderARM::VisitShl(HShl* shl) { 2393 HandleShift(shl); 2394} 2395 2396void InstructionCodeGeneratorARM::VisitShl(HShl* shl) { 2397 HandleShift(shl); 2398} 2399 2400void LocationsBuilderARM::VisitShr(HShr* shr) { 2401 HandleShift(shr); 2402} 2403 2404void InstructionCodeGeneratorARM::VisitShr(HShr* shr) { 2405 HandleShift(shr); 2406} 2407 2408void LocationsBuilderARM::VisitUShr(HUShr* ushr) { 2409 HandleShift(ushr); 2410} 2411 2412void InstructionCodeGeneratorARM::VisitUShr(HUShr* ushr) { 2413 HandleShift(ushr); 2414} 2415 2416void LocationsBuilderARM::VisitNewInstance(HNewInstance* instruction) { 2417 LocationSummary* locations = 2418 new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kCall); 2419 InvokeRuntimeCallingConvention calling_convention; 2420 locations->AddTemp(Location::RegisterLocation(calling_convention.GetRegisterAt(0))); 2421 locations->AddTemp(Location::RegisterLocation(calling_convention.GetRegisterAt(1))); 2422 locations->SetOut(Location::RegisterLocation(R0)); 2423} 2424 2425void InstructionCodeGeneratorARM::VisitNewInstance(HNewInstance* instruction) { 2426 InvokeRuntimeCallingConvention calling_convention; 2427 codegen_->LoadCurrentMethod(calling_convention.GetRegisterAt(1)); 2428 __ LoadImmediate(calling_convention.GetRegisterAt(0), instruction->GetTypeIndex()); 2429 codegen_->InvokeRuntime(GetThreadOffset<kArmWordSize>(instruction->GetEntrypoint()).Int32Value(), 2430 instruction, 2431 instruction->GetDexPc()); 2432} 2433 2434void LocationsBuilderARM::VisitNewArray(HNewArray* instruction) { 2435 LocationSummary* locations = 2436 new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kCall); 2437 InvokeRuntimeCallingConvention calling_convention; 2438 locations->AddTemp(Location::RegisterLocation(calling_convention.GetRegisterAt(0))); 2439 locations->AddTemp(Location::RegisterLocation(calling_convention.GetRegisterAt(2))); 2440 locations->SetOut(Location::RegisterLocation(R0)); 2441 locations->SetInAt(0, Location::RegisterLocation(calling_convention.GetRegisterAt(1))); 2442} 2443 2444void InstructionCodeGeneratorARM::VisitNewArray(HNewArray* instruction) { 2445 InvokeRuntimeCallingConvention calling_convention; 2446 codegen_->LoadCurrentMethod(calling_convention.GetRegisterAt(2)); 2447 __ LoadImmediate(calling_convention.GetRegisterAt(0), instruction->GetTypeIndex()); 2448 codegen_->InvokeRuntime(GetThreadOffset<kArmWordSize>(instruction->GetEntrypoint()).Int32Value(), 2449 instruction, 2450 instruction->GetDexPc()); 2451} 2452 2453void LocationsBuilderARM::VisitParameterValue(HParameterValue* instruction) { 2454 LocationSummary* locations = 2455 new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kNoCall); 2456 Location location = parameter_visitor_.GetNextLocation(instruction->GetType()); 2457 if (location.IsStackSlot()) { 2458 location = Location::StackSlot(location.GetStackIndex() + codegen_->GetFrameSize()); 2459 } else if (location.IsDoubleStackSlot()) { 2460 location = Location::DoubleStackSlot(location.GetStackIndex() + codegen_->GetFrameSize()); 2461 } 2462 locations->SetOut(location); 2463} 2464 2465void InstructionCodeGeneratorARM::VisitParameterValue(HParameterValue* instruction) { 2466 // Nothing to do, the parameter is already at its location. 2467 UNUSED(instruction); 2468} 2469 2470void LocationsBuilderARM::VisitNot(HNot* not_) { 2471 LocationSummary* locations = 2472 new (GetGraph()->GetArena()) LocationSummary(not_, LocationSummary::kNoCall); 2473 locations->SetInAt(0, Location::RequiresRegister()); 2474 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 2475} 2476 2477void InstructionCodeGeneratorARM::VisitNot(HNot* not_) { 2478 LocationSummary* locations = not_->GetLocations(); 2479 Location out = locations->Out(); 2480 Location in = locations->InAt(0); 2481 switch (not_->GetResultType()) { 2482 case Primitive::kPrimInt: 2483 __ mvn(out.AsRegister<Register>(), ShifterOperand(in.AsRegister<Register>())); 2484 break; 2485 2486 case Primitive::kPrimLong: 2487 __ mvn(out.AsRegisterPairLow<Register>(), 2488 ShifterOperand(in.AsRegisterPairLow<Register>())); 2489 __ mvn(out.AsRegisterPairHigh<Register>(), 2490 ShifterOperand(in.AsRegisterPairHigh<Register>())); 2491 break; 2492 2493 default: 2494 LOG(FATAL) << "Unimplemented type for not operation " << not_->GetResultType(); 2495 } 2496} 2497 2498void LocationsBuilderARM::VisitCompare(HCompare* compare) { 2499 LocationSummary* locations = 2500 new (GetGraph()->GetArena()) LocationSummary(compare, LocationSummary::kNoCall); 2501 switch (compare->InputAt(0)->GetType()) { 2502 case Primitive::kPrimLong: { 2503 locations->SetInAt(0, Location::RequiresRegister()); 2504 locations->SetInAt(1, Location::RequiresRegister()); 2505 // Output overlaps because it is written before doing the low comparison. 2506 locations->SetOut(Location::RequiresRegister(), Location::kOutputOverlap); 2507 break; 2508 } 2509 case Primitive::kPrimFloat: 2510 case Primitive::kPrimDouble: { 2511 locations->SetInAt(0, Location::RequiresFpuRegister()); 2512 locations->SetInAt(1, Location::RequiresFpuRegister()); 2513 locations->SetOut(Location::RequiresRegister()); 2514 break; 2515 } 2516 default: 2517 LOG(FATAL) << "Unexpected type for compare operation " << compare->InputAt(0)->GetType(); 2518 } 2519} 2520 2521void InstructionCodeGeneratorARM::VisitCompare(HCompare* compare) { 2522 LocationSummary* locations = compare->GetLocations(); 2523 Register out = locations->Out().AsRegister<Register>(); 2524 Location left = locations->InAt(0); 2525 Location right = locations->InAt(1); 2526 2527 Label less, greater, done; 2528 Primitive::Type type = compare->InputAt(0)->GetType(); 2529 switch (type) { 2530 case Primitive::kPrimLong: { 2531 __ cmp(left.AsRegisterPairHigh<Register>(), 2532 ShifterOperand(right.AsRegisterPairHigh<Register>())); // Signed compare. 2533 __ b(&less, LT); 2534 __ b(&greater, GT); 2535 // Do LoadImmediate before any `cmp`, as LoadImmediate might affect the status flags. 2536 __ LoadImmediate(out, 0); 2537 __ cmp(left.AsRegisterPairLow<Register>(), 2538 ShifterOperand(right.AsRegisterPairLow<Register>())); // Unsigned compare. 2539 break; 2540 } 2541 case Primitive::kPrimFloat: 2542 case Primitive::kPrimDouble: { 2543 __ LoadImmediate(out, 0); 2544 if (type == Primitive::kPrimFloat) { 2545 __ vcmps(left.AsFpuRegister<SRegister>(), right.AsFpuRegister<SRegister>()); 2546 } else { 2547 __ vcmpd(FromLowSToD(left.AsFpuRegisterPairLow<SRegister>()), 2548 FromLowSToD(right.AsFpuRegisterPairLow<SRegister>())); 2549 } 2550 __ vmstat(); // transfer FP status register to ARM APSR. 2551 __ b(compare->IsGtBias() ? &greater : &less, VS); // VS for unordered. 2552 break; 2553 } 2554 default: 2555 LOG(FATAL) << "Unexpected compare type " << type; 2556 } 2557 __ b(&done, EQ); 2558 __ b(&less, CC); // CC is for both: unsigned compare for longs and 'less than' for floats. 2559 2560 __ Bind(&greater); 2561 __ LoadImmediate(out, 1); 2562 __ b(&done); 2563 2564 __ Bind(&less); 2565 __ LoadImmediate(out, -1); 2566 2567 __ Bind(&done); 2568} 2569 2570void LocationsBuilderARM::VisitPhi(HPhi* instruction) { 2571 LocationSummary* locations = 2572 new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kNoCall); 2573 for (size_t i = 0, e = instruction->InputCount(); i < e; ++i) { 2574 locations->SetInAt(i, Location::Any()); 2575 } 2576 locations->SetOut(Location::Any()); 2577} 2578 2579void InstructionCodeGeneratorARM::VisitPhi(HPhi* instruction) { 2580 UNUSED(instruction); 2581 LOG(FATAL) << "Unreachable"; 2582} 2583 2584void InstructionCodeGeneratorARM::GenerateMemoryBarrier(MemBarrierKind kind) { 2585 // TODO (ported from quick): revisit Arm barrier kinds 2586 DmbOptions flavour = DmbOptions::ISH; // quiet c++ warnings 2587 switch (kind) { 2588 case MemBarrierKind::kAnyStore: 2589 case MemBarrierKind::kLoadAny: 2590 case MemBarrierKind::kAnyAny: { 2591 flavour = DmbOptions::ISH; 2592 break; 2593 } 2594 case MemBarrierKind::kStoreStore: { 2595 flavour = DmbOptions::ISHST; 2596 break; 2597 } 2598 default: 2599 LOG(FATAL) << "Unexpected memory barrier " << kind; 2600 } 2601 __ dmb(flavour); 2602} 2603 2604void InstructionCodeGeneratorARM::GenerateWideAtomicLoad(Register addr, 2605 uint32_t offset, 2606 Register out_lo, 2607 Register out_hi) { 2608 if (offset != 0) { 2609 __ LoadImmediate(out_lo, offset); 2610 __ add(IP, addr, ShifterOperand(out_lo)); 2611 addr = IP; 2612 } 2613 __ ldrexd(out_lo, out_hi, addr); 2614} 2615 2616void InstructionCodeGeneratorARM::GenerateWideAtomicStore(Register addr, 2617 uint32_t offset, 2618 Register value_lo, 2619 Register value_hi, 2620 Register temp1, 2621 Register temp2, 2622 HInstruction* instruction) { 2623 Label fail; 2624 if (offset != 0) { 2625 __ LoadImmediate(temp1, offset); 2626 __ add(IP, addr, ShifterOperand(temp1)); 2627 addr = IP; 2628 } 2629 __ Bind(&fail); 2630 // We need a load followed by store. (The address used in a STREX instruction must 2631 // be the same as the address in the most recently executed LDREX instruction.) 2632 __ ldrexd(temp1, temp2, addr); 2633 codegen_->MaybeRecordImplicitNullCheck(instruction); 2634 __ strexd(temp1, value_lo, value_hi, addr); 2635 __ cmp(temp1, ShifterOperand(0)); 2636 __ b(&fail, NE); 2637} 2638 2639void LocationsBuilderARM::HandleFieldSet(HInstruction* instruction, const FieldInfo& field_info) { 2640 DCHECK(instruction->IsInstanceFieldSet() || instruction->IsStaticFieldSet()); 2641 2642 LocationSummary* locations = 2643 new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kNoCall); 2644 locations->SetInAt(0, Location::RequiresRegister()); 2645 locations->SetInAt(1, Location::RequiresRegister()); 2646 2647 2648 Primitive::Type field_type = field_info.GetFieldType(); 2649 bool is_wide = field_type == Primitive::kPrimLong || field_type == Primitive::kPrimDouble; 2650 bool generate_volatile = field_info.IsVolatile() 2651 && is_wide 2652 && !codegen_->GetInstructionSetFeatures().HasAtomicLdrdAndStrd(); 2653 // Temporary registers for the write barrier. 2654 // TODO: consider renaming StoreNeedsWriteBarrier to StoreNeedsGCMark. 2655 if (CodeGenerator::StoreNeedsWriteBarrier(field_type, instruction->InputAt(1))) { 2656 locations->AddTemp(Location::RequiresRegister()); 2657 locations->AddTemp(Location::RequiresRegister()); 2658 } else if (generate_volatile) { 2659 // Arm encoding have some additional constraints for ldrexd/strexd: 2660 // - registers need to be consecutive 2661 // - the first register should be even but not R14. 2662 // We don't test for Arm yet, and the assertion makes sure that we revisit this if we ever 2663 // enable Arm encoding. 2664 DCHECK_EQ(InstructionSet::kThumb2, codegen_->GetInstructionSet()); 2665 2666 locations->AddTemp(Location::RequiresRegister()); 2667 locations->AddTemp(Location::RequiresRegister()); 2668 if (field_type == Primitive::kPrimDouble) { 2669 // For doubles we need two more registers to copy the value. 2670 locations->AddTemp(Location::RegisterLocation(R2)); 2671 locations->AddTemp(Location::RegisterLocation(R3)); 2672 } 2673 } 2674} 2675 2676void InstructionCodeGeneratorARM::HandleFieldSet(HInstruction* instruction, 2677 const FieldInfo& field_info) { 2678 DCHECK(instruction->IsInstanceFieldSet() || instruction->IsStaticFieldSet()); 2679 2680 LocationSummary* locations = instruction->GetLocations(); 2681 Register base = locations->InAt(0).AsRegister<Register>(); 2682 Location value = locations->InAt(1); 2683 2684 bool is_volatile = field_info.IsVolatile(); 2685 bool atomic_ldrd_strd = codegen_->GetInstructionSetFeatures().HasAtomicLdrdAndStrd(); 2686 Primitive::Type field_type = field_info.GetFieldType(); 2687 uint32_t offset = field_info.GetFieldOffset().Uint32Value(); 2688 2689 if (is_volatile) { 2690 GenerateMemoryBarrier(MemBarrierKind::kAnyStore); 2691 } 2692 2693 switch (field_type) { 2694 case Primitive::kPrimBoolean: 2695 case Primitive::kPrimByte: { 2696 __ StoreToOffset(kStoreByte, value.AsRegister<Register>(), base, offset); 2697 break; 2698 } 2699 2700 case Primitive::kPrimShort: 2701 case Primitive::kPrimChar: { 2702 __ StoreToOffset(kStoreHalfword, value.AsRegister<Register>(), base, offset); 2703 break; 2704 } 2705 2706 case Primitive::kPrimInt: 2707 case Primitive::kPrimNot: { 2708 __ StoreToOffset(kStoreWord, value.AsRegister<Register>(), base, offset); 2709 break; 2710 } 2711 2712 case Primitive::kPrimLong: { 2713 if (is_volatile && !atomic_ldrd_strd) { 2714 GenerateWideAtomicStore(base, offset, 2715 value.AsRegisterPairLow<Register>(), 2716 value.AsRegisterPairHigh<Register>(), 2717 locations->GetTemp(0).AsRegister<Register>(), 2718 locations->GetTemp(1).AsRegister<Register>(), 2719 instruction); 2720 } else { 2721 __ StoreToOffset(kStoreWordPair, value.AsRegisterPairLow<Register>(), base, offset); 2722 codegen_->MaybeRecordImplicitNullCheck(instruction); 2723 } 2724 break; 2725 } 2726 2727 case Primitive::kPrimFloat: { 2728 __ StoreSToOffset(value.AsFpuRegister<SRegister>(), base, offset); 2729 break; 2730 } 2731 2732 case Primitive::kPrimDouble: { 2733 DRegister value_reg = FromLowSToD(value.AsFpuRegisterPairLow<SRegister>()); 2734 if (is_volatile && !atomic_ldrd_strd) { 2735 Register value_reg_lo = locations->GetTemp(0).AsRegister<Register>(); 2736 Register value_reg_hi = locations->GetTemp(1).AsRegister<Register>(); 2737 2738 __ vmovrrd(value_reg_lo, value_reg_hi, value_reg); 2739 2740 GenerateWideAtomicStore(base, offset, 2741 value_reg_lo, 2742 value_reg_hi, 2743 locations->GetTemp(2).AsRegister<Register>(), 2744 locations->GetTemp(3).AsRegister<Register>(), 2745 instruction); 2746 } else { 2747 __ StoreDToOffset(value_reg, base, offset); 2748 codegen_->MaybeRecordImplicitNullCheck(instruction); 2749 } 2750 break; 2751 } 2752 2753 case Primitive::kPrimVoid: 2754 LOG(FATAL) << "Unreachable type " << field_type; 2755 UNREACHABLE(); 2756 } 2757 2758 // Longs and doubles are handled in the switch. 2759 if (field_type != Primitive::kPrimLong && field_type != Primitive::kPrimDouble) { 2760 codegen_->MaybeRecordImplicitNullCheck(instruction); 2761 } 2762 2763 if (CodeGenerator::StoreNeedsWriteBarrier(field_type, instruction->InputAt(1))) { 2764 Register temp = locations->GetTemp(0).AsRegister<Register>(); 2765 Register card = locations->GetTemp(1).AsRegister<Register>(); 2766 codegen_->MarkGCCard(temp, card, base, value.AsRegister<Register>()); 2767 } 2768 2769 if (is_volatile) { 2770 GenerateMemoryBarrier(MemBarrierKind::kAnyAny); 2771 } 2772} 2773 2774void LocationsBuilderARM::HandleFieldGet(HInstruction* instruction, const FieldInfo& field_info) { 2775 DCHECK(instruction->IsInstanceFieldGet() || instruction->IsStaticFieldGet()); 2776 LocationSummary* locations = 2777 new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kNoCall); 2778 locations->SetInAt(0, Location::RequiresRegister()); 2779 2780 bool volatile_for_double = field_info.IsVolatile() 2781 && (field_info.GetFieldType() == Primitive::kPrimDouble) 2782 && !codegen_->GetInstructionSetFeatures().HasAtomicLdrdAndStrd(); 2783 bool overlap = field_info.IsVolatile() && (field_info.GetFieldType() == Primitive::kPrimLong); 2784 locations->SetOut(Location::RequiresRegister(), 2785 (overlap ? Location::kOutputOverlap : Location::kNoOutputOverlap)); 2786 if (volatile_for_double) { 2787 // Arm encoding have some additional constraints for ldrexd/strexd: 2788 // - registers need to be consecutive 2789 // - the first register should be even but not R14. 2790 // We don't test for Arm yet, and the assertion makes sure that we revisit this if we ever 2791 // enable Arm encoding. 2792 DCHECK_EQ(InstructionSet::kThumb2, codegen_->GetInstructionSet()); 2793 locations->AddTemp(Location::RequiresRegister()); 2794 locations->AddTemp(Location::RequiresRegister()); 2795 } 2796} 2797 2798void InstructionCodeGeneratorARM::HandleFieldGet(HInstruction* instruction, 2799 const FieldInfo& field_info) { 2800 DCHECK(instruction->IsInstanceFieldGet() || instruction->IsStaticFieldGet()); 2801 2802 LocationSummary* locations = instruction->GetLocations(); 2803 Register base = locations->InAt(0).AsRegister<Register>(); 2804 Location out = locations->Out(); 2805 bool is_volatile = field_info.IsVolatile(); 2806 bool atomic_ldrd_strd = codegen_->GetInstructionSetFeatures().HasAtomicLdrdAndStrd(); 2807 Primitive::Type field_type = field_info.GetFieldType(); 2808 uint32_t offset = field_info.GetFieldOffset().Uint32Value(); 2809 2810 switch (field_type) { 2811 case Primitive::kPrimBoolean: { 2812 __ LoadFromOffset(kLoadUnsignedByte, out.AsRegister<Register>(), base, offset); 2813 break; 2814 } 2815 2816 case Primitive::kPrimByte: { 2817 __ LoadFromOffset(kLoadSignedByte, out.AsRegister<Register>(), base, offset); 2818 break; 2819 } 2820 2821 case Primitive::kPrimShort: { 2822 __ LoadFromOffset(kLoadSignedHalfword, out.AsRegister<Register>(), base, offset); 2823 break; 2824 } 2825 2826 case Primitive::kPrimChar: { 2827 __ LoadFromOffset(kLoadUnsignedHalfword, out.AsRegister<Register>(), base, offset); 2828 break; 2829 } 2830 2831 case Primitive::kPrimInt: 2832 case Primitive::kPrimNot: { 2833 __ LoadFromOffset(kLoadWord, out.AsRegister<Register>(), base, offset); 2834 break; 2835 } 2836 2837 case Primitive::kPrimLong: { 2838 if (is_volatile && !atomic_ldrd_strd) { 2839 GenerateWideAtomicLoad(base, offset, 2840 out.AsRegisterPairLow<Register>(), 2841 out.AsRegisterPairHigh<Register>()); 2842 } else { 2843 __ LoadFromOffset(kLoadWordPair, out.AsRegisterPairLow<Register>(), base, offset); 2844 } 2845 break; 2846 } 2847 2848 case Primitive::kPrimFloat: { 2849 __ LoadSFromOffset(out.AsFpuRegister<SRegister>(), base, offset); 2850 break; 2851 } 2852 2853 case Primitive::kPrimDouble: { 2854 DRegister out_reg = FromLowSToD(out.AsFpuRegisterPairLow<SRegister>()); 2855 if (is_volatile && !atomic_ldrd_strd) { 2856 Register lo = locations->GetTemp(0).AsRegister<Register>(); 2857 Register hi = locations->GetTemp(1).AsRegister<Register>(); 2858 GenerateWideAtomicLoad(base, offset, lo, hi); 2859 codegen_->MaybeRecordImplicitNullCheck(instruction); 2860 __ vmovdrr(out_reg, lo, hi); 2861 } else { 2862 __ LoadDFromOffset(out_reg, base, offset); 2863 codegen_->MaybeRecordImplicitNullCheck(instruction); 2864 } 2865 break; 2866 } 2867 2868 case Primitive::kPrimVoid: 2869 LOG(FATAL) << "Unreachable type " << field_type; 2870 UNREACHABLE(); 2871 } 2872 2873 // Doubles are handled in the switch. 2874 if (field_type != Primitive::kPrimDouble) { 2875 codegen_->MaybeRecordImplicitNullCheck(instruction); 2876 } 2877 2878 if (is_volatile) { 2879 GenerateMemoryBarrier(MemBarrierKind::kLoadAny); 2880 } 2881} 2882 2883void LocationsBuilderARM::VisitInstanceFieldSet(HInstanceFieldSet* instruction) { 2884 HandleFieldSet(instruction, instruction->GetFieldInfo()); 2885} 2886 2887void InstructionCodeGeneratorARM::VisitInstanceFieldSet(HInstanceFieldSet* instruction) { 2888 HandleFieldSet(instruction, instruction->GetFieldInfo()); 2889} 2890 2891void LocationsBuilderARM::VisitInstanceFieldGet(HInstanceFieldGet* instruction) { 2892 HandleFieldGet(instruction, instruction->GetFieldInfo()); 2893} 2894 2895void InstructionCodeGeneratorARM::VisitInstanceFieldGet(HInstanceFieldGet* instruction) { 2896 HandleFieldGet(instruction, instruction->GetFieldInfo()); 2897} 2898 2899void LocationsBuilderARM::VisitStaticFieldGet(HStaticFieldGet* instruction) { 2900 HandleFieldGet(instruction, instruction->GetFieldInfo()); 2901} 2902 2903void InstructionCodeGeneratorARM::VisitStaticFieldGet(HStaticFieldGet* instruction) { 2904 HandleFieldGet(instruction, instruction->GetFieldInfo()); 2905} 2906 2907void LocationsBuilderARM::VisitStaticFieldSet(HStaticFieldSet* instruction) { 2908 HandleFieldSet(instruction, instruction->GetFieldInfo()); 2909} 2910 2911void InstructionCodeGeneratorARM::VisitStaticFieldSet(HStaticFieldSet* instruction) { 2912 HandleFieldSet(instruction, instruction->GetFieldInfo()); 2913} 2914 2915void LocationsBuilderARM::VisitNullCheck(HNullCheck* instruction) { 2916 LocationSummary* locations = 2917 new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kNoCall); 2918 locations->SetInAt(0, Location::RequiresRegister()); 2919 if (instruction->HasUses()) { 2920 locations->SetOut(Location::SameAsFirstInput()); 2921 } 2922} 2923 2924void InstructionCodeGeneratorARM::GenerateImplicitNullCheck(HNullCheck* instruction) { 2925 if (codegen_->CanMoveNullCheckToUser(instruction)) { 2926 return; 2927 } 2928 Location obj = instruction->GetLocations()->InAt(0); 2929 2930 __ LoadFromOffset(kLoadWord, IP, obj.AsRegister<Register>(), 0); 2931 codegen_->RecordPcInfo(instruction, instruction->GetDexPc()); 2932} 2933 2934void InstructionCodeGeneratorARM::GenerateExplicitNullCheck(HNullCheck* instruction) { 2935 SlowPathCodeARM* slow_path = new (GetGraph()->GetArena()) NullCheckSlowPathARM(instruction); 2936 codegen_->AddSlowPath(slow_path); 2937 2938 LocationSummary* locations = instruction->GetLocations(); 2939 Location obj = locations->InAt(0); 2940 2941 __ cmp(obj.AsRegister<Register>(), ShifterOperand(0)); 2942 __ b(slow_path->GetEntryLabel(), EQ); 2943} 2944 2945void InstructionCodeGeneratorARM::VisitNullCheck(HNullCheck* instruction) { 2946 if (codegen_->GetCompilerOptions().GetImplicitNullChecks()) { 2947 GenerateImplicitNullCheck(instruction); 2948 } else { 2949 GenerateExplicitNullCheck(instruction); 2950 } 2951} 2952 2953void LocationsBuilderARM::VisitArrayGet(HArrayGet* instruction) { 2954 LocationSummary* locations = 2955 new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kNoCall); 2956 locations->SetInAt(0, Location::RequiresRegister()); 2957 locations->SetInAt(1, Location::RegisterOrConstant(instruction->InputAt(1))); 2958 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 2959} 2960 2961void InstructionCodeGeneratorARM::VisitArrayGet(HArrayGet* instruction) { 2962 LocationSummary* locations = instruction->GetLocations(); 2963 Register obj = locations->InAt(0).AsRegister<Register>(); 2964 Location index = locations->InAt(1); 2965 2966 switch (instruction->GetType()) { 2967 case Primitive::kPrimBoolean: { 2968 uint32_t data_offset = mirror::Array::DataOffset(sizeof(uint8_t)).Uint32Value(); 2969 Register out = locations->Out().AsRegister<Register>(); 2970 if (index.IsConstant()) { 2971 size_t offset = 2972 (index.GetConstant()->AsIntConstant()->GetValue() << TIMES_1) + data_offset; 2973 __ LoadFromOffset(kLoadUnsignedByte, out, obj, offset); 2974 } else { 2975 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>())); 2976 __ LoadFromOffset(kLoadUnsignedByte, out, IP, data_offset); 2977 } 2978 break; 2979 } 2980 2981 case Primitive::kPrimByte: { 2982 uint32_t data_offset = mirror::Array::DataOffset(sizeof(int8_t)).Uint32Value(); 2983 Register out = locations->Out().AsRegister<Register>(); 2984 if (index.IsConstant()) { 2985 size_t offset = 2986 (index.GetConstant()->AsIntConstant()->GetValue() << TIMES_1) + data_offset; 2987 __ LoadFromOffset(kLoadSignedByte, out, obj, offset); 2988 } else { 2989 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>())); 2990 __ LoadFromOffset(kLoadSignedByte, out, IP, data_offset); 2991 } 2992 break; 2993 } 2994 2995 case Primitive::kPrimShort: { 2996 uint32_t data_offset = mirror::Array::DataOffset(sizeof(int16_t)).Uint32Value(); 2997 Register out = locations->Out().AsRegister<Register>(); 2998 if (index.IsConstant()) { 2999 size_t offset = 3000 (index.GetConstant()->AsIntConstant()->GetValue() << TIMES_2) + data_offset; 3001 __ LoadFromOffset(kLoadSignedHalfword, out, obj, offset); 3002 } else { 3003 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_2)); 3004 __ LoadFromOffset(kLoadSignedHalfword, out, IP, data_offset); 3005 } 3006 break; 3007 } 3008 3009 case Primitive::kPrimChar: { 3010 uint32_t data_offset = mirror::Array::DataOffset(sizeof(uint16_t)).Uint32Value(); 3011 Register out = locations->Out().AsRegister<Register>(); 3012 if (index.IsConstant()) { 3013 size_t offset = 3014 (index.GetConstant()->AsIntConstant()->GetValue() << TIMES_2) + data_offset; 3015 __ LoadFromOffset(kLoadUnsignedHalfword, out, obj, offset); 3016 } else { 3017 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_2)); 3018 __ LoadFromOffset(kLoadUnsignedHalfword, out, IP, data_offset); 3019 } 3020 break; 3021 } 3022 3023 case Primitive::kPrimInt: 3024 case Primitive::kPrimNot: { 3025 DCHECK_EQ(sizeof(mirror::HeapReference<mirror::Object>), sizeof(int32_t)); 3026 uint32_t data_offset = mirror::Array::DataOffset(sizeof(int32_t)).Uint32Value(); 3027 Register out = locations->Out().AsRegister<Register>(); 3028 if (index.IsConstant()) { 3029 size_t offset = 3030 (index.GetConstant()->AsIntConstant()->GetValue() << TIMES_4) + data_offset; 3031 __ LoadFromOffset(kLoadWord, out, obj, offset); 3032 } else { 3033 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_4)); 3034 __ LoadFromOffset(kLoadWord, out, IP, data_offset); 3035 } 3036 break; 3037 } 3038 3039 case Primitive::kPrimLong: { 3040 uint32_t data_offset = mirror::Array::DataOffset(sizeof(int64_t)).Uint32Value(); 3041 Location out = locations->Out(); 3042 if (index.IsConstant()) { 3043 size_t offset = 3044 (index.GetConstant()->AsIntConstant()->GetValue() << TIMES_8) + data_offset; 3045 __ LoadFromOffset(kLoadWordPair, out.AsRegisterPairLow<Register>(), obj, offset); 3046 } else { 3047 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_8)); 3048 __ LoadFromOffset(kLoadWordPair, out.AsRegisterPairLow<Register>(), IP, data_offset); 3049 } 3050 break; 3051 } 3052 3053 case Primitive::kPrimFloat: { 3054 uint32_t data_offset = mirror::Array::DataOffset(sizeof(float)).Uint32Value(); 3055 Location out = locations->Out(); 3056 DCHECK(out.IsFpuRegister()); 3057 if (index.IsConstant()) { 3058 size_t offset = (index.GetConstant()->AsIntConstant()->GetValue() << TIMES_4) + data_offset; 3059 __ LoadSFromOffset(out.AsFpuRegister<SRegister>(), obj, offset); 3060 } else { 3061 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_4)); 3062 __ LoadSFromOffset(out.AsFpuRegister<SRegister>(), IP, data_offset); 3063 } 3064 break; 3065 } 3066 3067 case Primitive::kPrimDouble: { 3068 uint32_t data_offset = mirror::Array::DataOffset(sizeof(double)).Uint32Value(); 3069 Location out = locations->Out(); 3070 DCHECK(out.IsFpuRegisterPair()); 3071 if (index.IsConstant()) { 3072 size_t offset = (index.GetConstant()->AsIntConstant()->GetValue() << TIMES_8) + data_offset; 3073 __ LoadDFromOffset(FromLowSToD(out.AsFpuRegisterPairLow<SRegister>()), obj, offset); 3074 } else { 3075 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_8)); 3076 __ LoadDFromOffset(FromLowSToD(out.AsFpuRegisterPairLow<SRegister>()), IP, data_offset); 3077 } 3078 break; 3079 } 3080 3081 case Primitive::kPrimVoid: 3082 LOG(FATAL) << "Unreachable type " << instruction->GetType(); 3083 UNREACHABLE(); 3084 } 3085 codegen_->MaybeRecordImplicitNullCheck(instruction); 3086} 3087 3088void LocationsBuilderARM::VisitArraySet(HArraySet* instruction) { 3089 Primitive::Type value_type = instruction->GetComponentType(); 3090 3091 bool needs_write_barrier = 3092 CodeGenerator::StoreNeedsWriteBarrier(value_type, instruction->GetValue()); 3093 bool needs_runtime_call = instruction->NeedsTypeCheck(); 3094 3095 LocationSummary* locations = new (GetGraph()->GetArena()) LocationSummary( 3096 instruction, needs_runtime_call ? LocationSummary::kCall : LocationSummary::kNoCall); 3097 if (needs_runtime_call) { 3098 InvokeRuntimeCallingConvention calling_convention; 3099 locations->SetInAt(0, Location::RegisterLocation(calling_convention.GetRegisterAt(0))); 3100 locations->SetInAt(1, Location::RegisterLocation(calling_convention.GetRegisterAt(1))); 3101 locations->SetInAt(2, Location::RegisterLocation(calling_convention.GetRegisterAt(2))); 3102 } else { 3103 locations->SetInAt(0, Location::RequiresRegister()); 3104 locations->SetInAt(1, Location::RegisterOrConstant(instruction->InputAt(1))); 3105 locations->SetInAt(2, Location::RequiresRegister()); 3106 3107 if (needs_write_barrier) { 3108 // Temporary registers for the write barrier. 3109 locations->AddTemp(Location::RequiresRegister()); 3110 locations->AddTemp(Location::RequiresRegister()); 3111 } 3112 } 3113} 3114 3115void InstructionCodeGeneratorARM::VisitArraySet(HArraySet* instruction) { 3116 LocationSummary* locations = instruction->GetLocations(); 3117 Register obj = locations->InAt(0).AsRegister<Register>(); 3118 Location index = locations->InAt(1); 3119 Primitive::Type value_type = instruction->GetComponentType(); 3120 bool needs_runtime_call = locations->WillCall(); 3121 bool needs_write_barrier = 3122 CodeGenerator::StoreNeedsWriteBarrier(value_type, instruction->GetValue()); 3123 3124 switch (value_type) { 3125 case Primitive::kPrimBoolean: 3126 case Primitive::kPrimByte: { 3127 uint32_t data_offset = mirror::Array::DataOffset(sizeof(uint8_t)).Uint32Value(); 3128 Register value = locations->InAt(2).AsRegister<Register>(); 3129 if (index.IsConstant()) { 3130 size_t offset = 3131 (index.GetConstant()->AsIntConstant()->GetValue() << TIMES_1) + data_offset; 3132 __ StoreToOffset(kStoreByte, value, obj, offset); 3133 } else { 3134 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>())); 3135 __ StoreToOffset(kStoreByte, value, IP, data_offset); 3136 } 3137 break; 3138 } 3139 3140 case Primitive::kPrimShort: 3141 case Primitive::kPrimChar: { 3142 uint32_t data_offset = mirror::Array::DataOffset(sizeof(uint16_t)).Uint32Value(); 3143 Register value = locations->InAt(2).AsRegister<Register>(); 3144 if (index.IsConstant()) { 3145 size_t offset = 3146 (index.GetConstant()->AsIntConstant()->GetValue() << TIMES_2) + data_offset; 3147 __ StoreToOffset(kStoreHalfword, value, obj, offset); 3148 } else { 3149 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_2)); 3150 __ StoreToOffset(kStoreHalfword, value, IP, data_offset); 3151 } 3152 break; 3153 } 3154 3155 case Primitive::kPrimInt: 3156 case Primitive::kPrimNot: { 3157 if (!needs_runtime_call) { 3158 uint32_t data_offset = mirror::Array::DataOffset(sizeof(int32_t)).Uint32Value(); 3159 Register value = locations->InAt(2).AsRegister<Register>(); 3160 if (index.IsConstant()) { 3161 size_t offset = 3162 (index.GetConstant()->AsIntConstant()->GetValue() << TIMES_4) + data_offset; 3163 __ StoreToOffset(kStoreWord, value, obj, offset); 3164 } else { 3165 DCHECK(index.IsRegister()) << index; 3166 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_4)); 3167 __ StoreToOffset(kStoreWord, value, IP, data_offset); 3168 } 3169 codegen_->MaybeRecordImplicitNullCheck(instruction); 3170 if (needs_write_barrier) { 3171 DCHECK_EQ(value_type, Primitive::kPrimNot); 3172 Register temp = locations->GetTemp(0).AsRegister<Register>(); 3173 Register card = locations->GetTemp(1).AsRegister<Register>(); 3174 codegen_->MarkGCCard(temp, card, obj, value); 3175 } 3176 } else { 3177 DCHECK_EQ(value_type, Primitive::kPrimNot); 3178 codegen_->InvokeRuntime(QUICK_ENTRY_POINT(pAputObject), 3179 instruction, 3180 instruction->GetDexPc()); 3181 } 3182 break; 3183 } 3184 3185 case Primitive::kPrimLong: { 3186 uint32_t data_offset = mirror::Array::DataOffset(sizeof(int64_t)).Uint32Value(); 3187 Location value = locations->InAt(2); 3188 if (index.IsConstant()) { 3189 size_t offset = 3190 (index.GetConstant()->AsIntConstant()->GetValue() << TIMES_8) + data_offset; 3191 __ StoreToOffset(kStoreWordPair, value.AsRegisterPairLow<Register>(), obj, offset); 3192 } else { 3193 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_8)); 3194 __ StoreToOffset(kStoreWordPair, value.AsRegisterPairLow<Register>(), IP, data_offset); 3195 } 3196 break; 3197 } 3198 3199 case Primitive::kPrimFloat: { 3200 uint32_t data_offset = mirror::Array::DataOffset(sizeof(float)).Uint32Value(); 3201 Location value = locations->InAt(2); 3202 DCHECK(value.IsFpuRegister()); 3203 if (index.IsConstant()) { 3204 size_t offset = (index.GetConstant()->AsIntConstant()->GetValue() << TIMES_4) + data_offset; 3205 __ StoreSToOffset(value.AsFpuRegister<SRegister>(), obj, offset); 3206 } else { 3207 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_4)); 3208 __ StoreSToOffset(value.AsFpuRegister<SRegister>(), IP, data_offset); 3209 } 3210 break; 3211 } 3212 3213 case Primitive::kPrimDouble: { 3214 uint32_t data_offset = mirror::Array::DataOffset(sizeof(double)).Uint32Value(); 3215 Location value = locations->InAt(2); 3216 DCHECK(value.IsFpuRegisterPair()); 3217 if (index.IsConstant()) { 3218 size_t offset = (index.GetConstant()->AsIntConstant()->GetValue() << TIMES_8) + data_offset; 3219 __ StoreDToOffset(FromLowSToD(value.AsFpuRegisterPairLow<SRegister>()), obj, offset); 3220 } else { 3221 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_8)); 3222 __ StoreDToOffset(FromLowSToD(value.AsFpuRegisterPairLow<SRegister>()), IP, data_offset); 3223 } 3224 3225 break; 3226 } 3227 3228 case Primitive::kPrimVoid: 3229 LOG(FATAL) << "Unreachable type " << value_type; 3230 UNREACHABLE(); 3231 } 3232 3233 // Ints and objects are handled in the switch. 3234 if (value_type != Primitive::kPrimInt && value_type != Primitive::kPrimNot) { 3235 codegen_->MaybeRecordImplicitNullCheck(instruction); 3236 } 3237} 3238 3239void LocationsBuilderARM::VisitArrayLength(HArrayLength* instruction) { 3240 LocationSummary* locations = 3241 new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kNoCall); 3242 locations->SetInAt(0, Location::RequiresRegister()); 3243 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 3244} 3245 3246void InstructionCodeGeneratorARM::VisitArrayLength(HArrayLength* instruction) { 3247 LocationSummary* locations = instruction->GetLocations(); 3248 uint32_t offset = mirror::Array::LengthOffset().Uint32Value(); 3249 Register obj = locations->InAt(0).AsRegister<Register>(); 3250 Register out = locations->Out().AsRegister<Register>(); 3251 __ LoadFromOffset(kLoadWord, out, obj, offset); 3252 codegen_->MaybeRecordImplicitNullCheck(instruction); 3253} 3254 3255void LocationsBuilderARM::VisitBoundsCheck(HBoundsCheck* instruction) { 3256 LocationSummary* locations = 3257 new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kNoCall); 3258 locations->SetInAt(0, Location::RequiresRegister()); 3259 locations->SetInAt(1, Location::RequiresRegister()); 3260 if (instruction->HasUses()) { 3261 locations->SetOut(Location::SameAsFirstInput()); 3262 } 3263} 3264 3265void InstructionCodeGeneratorARM::VisitBoundsCheck(HBoundsCheck* instruction) { 3266 LocationSummary* locations = instruction->GetLocations(); 3267 SlowPathCodeARM* slow_path = new (GetGraph()->GetArena()) BoundsCheckSlowPathARM( 3268 instruction, locations->InAt(0), locations->InAt(1)); 3269 codegen_->AddSlowPath(slow_path); 3270 3271 Register index = locations->InAt(0).AsRegister<Register>(); 3272 Register length = locations->InAt(1).AsRegister<Register>(); 3273 3274 __ cmp(index, ShifterOperand(length)); 3275 __ b(slow_path->GetEntryLabel(), CS); 3276} 3277 3278void CodeGeneratorARM::MarkGCCard(Register temp, Register card, Register object, Register value) { 3279 Label is_null; 3280 __ CompareAndBranchIfZero(value, &is_null); 3281 __ LoadFromOffset(kLoadWord, card, TR, Thread::CardTableOffset<kArmWordSize>().Int32Value()); 3282 __ Lsr(temp, object, gc::accounting::CardTable::kCardShift); 3283 __ strb(card, Address(card, temp)); 3284 __ Bind(&is_null); 3285} 3286 3287void LocationsBuilderARM::VisitTemporary(HTemporary* temp) { 3288 temp->SetLocations(nullptr); 3289} 3290 3291void InstructionCodeGeneratorARM::VisitTemporary(HTemporary* temp) { 3292 // Nothing to do, this is driven by the code generator. 3293 UNUSED(temp); 3294} 3295 3296void LocationsBuilderARM::VisitParallelMove(HParallelMove* instruction) { 3297 UNUSED(instruction); 3298 LOG(FATAL) << "Unreachable"; 3299} 3300 3301void InstructionCodeGeneratorARM::VisitParallelMove(HParallelMove* instruction) { 3302 codegen_->GetMoveResolver()->EmitNativeCode(instruction); 3303} 3304 3305void LocationsBuilderARM::VisitSuspendCheck(HSuspendCheck* instruction) { 3306 new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kCallOnSlowPath); 3307} 3308 3309void InstructionCodeGeneratorARM::VisitSuspendCheck(HSuspendCheck* instruction) { 3310 HBasicBlock* block = instruction->GetBlock(); 3311 if (block->GetLoopInformation() != nullptr) { 3312 DCHECK(block->GetLoopInformation()->GetSuspendCheck() == instruction); 3313 // The back edge will generate the suspend check. 3314 return; 3315 } 3316 if (block->IsEntryBlock() && instruction->GetNext()->IsGoto()) { 3317 // The goto will generate the suspend check. 3318 return; 3319 } 3320 GenerateSuspendCheck(instruction, nullptr); 3321} 3322 3323void InstructionCodeGeneratorARM::GenerateSuspendCheck(HSuspendCheck* instruction, 3324 HBasicBlock* successor) { 3325 SuspendCheckSlowPathARM* slow_path = 3326 new (GetGraph()->GetArena()) SuspendCheckSlowPathARM(instruction, successor); 3327 codegen_->AddSlowPath(slow_path); 3328 3329 __ LoadFromOffset( 3330 kLoadUnsignedHalfword, IP, TR, Thread::ThreadFlagsOffset<kArmWordSize>().Int32Value()); 3331 __ cmp(IP, ShifterOperand(0)); 3332 // TODO: Figure out the branch offsets and use cbz/cbnz. 3333 if (successor == nullptr) { 3334 __ b(slow_path->GetEntryLabel(), NE); 3335 __ Bind(slow_path->GetReturnLabel()); 3336 } else { 3337 __ b(codegen_->GetLabelOf(successor), EQ); 3338 __ b(slow_path->GetEntryLabel()); 3339 } 3340} 3341 3342ArmAssembler* ParallelMoveResolverARM::GetAssembler() const { 3343 return codegen_->GetAssembler(); 3344} 3345 3346void ParallelMoveResolverARM::EmitMove(size_t index) { 3347 MoveOperands* move = moves_.Get(index); 3348 Location source = move->GetSource(); 3349 Location destination = move->GetDestination(); 3350 3351 if (source.IsRegister()) { 3352 if (destination.IsRegister()) { 3353 __ Mov(destination.AsRegister<Register>(), source.AsRegister<Register>()); 3354 } else { 3355 DCHECK(destination.IsStackSlot()); 3356 __ StoreToOffset(kStoreWord, source.AsRegister<Register>(), 3357 SP, destination.GetStackIndex()); 3358 } 3359 } else if (source.IsStackSlot()) { 3360 if (destination.IsRegister()) { 3361 __ LoadFromOffset(kLoadWord, destination.AsRegister<Register>(), 3362 SP, source.GetStackIndex()); 3363 } else if (destination.IsFpuRegister()) { 3364 __ LoadSFromOffset(destination.AsFpuRegister<SRegister>(), SP, source.GetStackIndex()); 3365 } else { 3366 DCHECK(destination.IsStackSlot()); 3367 __ LoadFromOffset(kLoadWord, IP, SP, source.GetStackIndex()); 3368 __ StoreToOffset(kStoreWord, IP, SP, destination.GetStackIndex()); 3369 } 3370 } else if (source.IsFpuRegister()) { 3371 if (destination.IsFpuRegister()) { 3372 __ vmovs(destination.AsFpuRegister<SRegister>(), source.AsFpuRegister<SRegister>()); 3373 } else { 3374 DCHECK(destination.IsStackSlot()); 3375 __ StoreSToOffset(source.AsFpuRegister<SRegister>(), SP, destination.GetStackIndex()); 3376 } 3377 } else if (source.IsDoubleStackSlot()) { 3378 if (destination.IsDoubleStackSlot()) { 3379 __ LoadDFromOffset(DTMP, SP, source.GetStackIndex()); 3380 __ StoreDToOffset(DTMP, SP, destination.GetStackIndex()); 3381 } else if (destination.IsRegisterPair()) { 3382 DCHECK(ExpectedPairLayout(destination)); 3383 __ LoadFromOffset( 3384 kLoadWordPair, destination.AsRegisterPairLow<Register>(), SP, source.GetStackIndex()); 3385 } else { 3386 DCHECK(destination.IsFpuRegisterPair()) << destination; 3387 __ LoadDFromOffset(FromLowSToD(destination.AsFpuRegisterPairLow<SRegister>()), 3388 SP, 3389 source.GetStackIndex()); 3390 } 3391 } else if (source.IsRegisterPair()) { 3392 if (destination.IsRegisterPair()) { 3393 __ Mov(destination.AsRegisterPairLow<Register>(), source.AsRegisterPairLow<Register>()); 3394 __ Mov(destination.AsRegisterPairHigh<Register>(), source.AsRegisterPairHigh<Register>()); 3395 } else { 3396 DCHECK(destination.IsDoubleStackSlot()) << destination; 3397 DCHECK(ExpectedPairLayout(source)); 3398 __ StoreToOffset( 3399 kStoreWordPair, source.AsRegisterPairLow<Register>(), SP, destination.GetStackIndex()); 3400 } 3401 } else if (source.IsFpuRegisterPair()) { 3402 if (destination.IsFpuRegisterPair()) { 3403 __ vmovd(FromLowSToD(destination.AsFpuRegisterPairLow<SRegister>()), 3404 FromLowSToD(source.AsFpuRegisterPairLow<SRegister>())); 3405 } else { 3406 DCHECK(destination.IsDoubleStackSlot()) << destination; 3407 __ StoreDToOffset(FromLowSToD(source.AsFpuRegisterPairLow<SRegister>()), 3408 SP, 3409 destination.GetStackIndex()); 3410 } 3411 } else { 3412 DCHECK(source.IsConstant()) << source; 3413 HConstant* constant = source.GetConstant(); 3414 if (constant->IsIntConstant() || constant->IsNullConstant()) { 3415 int32_t value = CodeGenerator::GetInt32ValueOf(constant); 3416 if (destination.IsRegister()) { 3417 __ LoadImmediate(destination.AsRegister<Register>(), value); 3418 } else { 3419 DCHECK(destination.IsStackSlot()); 3420 __ LoadImmediate(IP, value); 3421 __ StoreToOffset(kStoreWord, IP, SP, destination.GetStackIndex()); 3422 } 3423 } else if (constant->IsLongConstant()) { 3424 int64_t value = constant->AsLongConstant()->GetValue(); 3425 if (destination.IsRegisterPair()) { 3426 __ LoadImmediate(destination.AsRegisterPairLow<Register>(), Low32Bits(value)); 3427 __ LoadImmediate(destination.AsRegisterPairHigh<Register>(), High32Bits(value)); 3428 } else { 3429 DCHECK(destination.IsDoubleStackSlot()) << destination; 3430 __ LoadImmediate(IP, Low32Bits(value)); 3431 __ StoreToOffset(kStoreWord, IP, SP, destination.GetStackIndex()); 3432 __ LoadImmediate(IP, High32Bits(value)); 3433 __ StoreToOffset(kStoreWord, IP, SP, destination.GetHighStackIndex(kArmWordSize)); 3434 } 3435 } else if (constant->IsDoubleConstant()) { 3436 double value = constant->AsDoubleConstant()->GetValue(); 3437 if (destination.IsFpuRegisterPair()) { 3438 __ LoadDImmediate(FromLowSToD(destination.AsFpuRegisterPairLow<SRegister>()), value); 3439 } else { 3440 DCHECK(destination.IsDoubleStackSlot()) << destination; 3441 uint64_t int_value = bit_cast<uint64_t, double>(value); 3442 __ LoadImmediate(IP, Low32Bits(int_value)); 3443 __ StoreToOffset(kStoreWord, IP, SP, destination.GetStackIndex()); 3444 __ LoadImmediate(IP, High32Bits(int_value)); 3445 __ StoreToOffset(kStoreWord, IP, SP, destination.GetHighStackIndex(kArmWordSize)); 3446 } 3447 } else { 3448 DCHECK(constant->IsFloatConstant()) << constant->DebugName(); 3449 float value = constant->AsFloatConstant()->GetValue(); 3450 if (destination.IsFpuRegister()) { 3451 __ LoadSImmediate(destination.AsFpuRegister<SRegister>(), value); 3452 } else { 3453 DCHECK(destination.IsStackSlot()); 3454 __ LoadImmediate(IP, bit_cast<int32_t, float>(value)); 3455 __ StoreToOffset(kStoreWord, IP, SP, destination.GetStackIndex()); 3456 } 3457 } 3458 } 3459} 3460 3461void ParallelMoveResolverARM::Exchange(Register reg, int mem) { 3462 __ Mov(IP, reg); 3463 __ LoadFromOffset(kLoadWord, reg, SP, mem); 3464 __ StoreToOffset(kStoreWord, IP, SP, mem); 3465} 3466 3467void ParallelMoveResolverARM::Exchange(int mem1, int mem2) { 3468 ScratchRegisterScope ensure_scratch(this, IP, R0, codegen_->GetNumberOfCoreRegisters()); 3469 int stack_offset = ensure_scratch.IsSpilled() ? kArmWordSize : 0; 3470 __ LoadFromOffset(kLoadWord, static_cast<Register>(ensure_scratch.GetRegister()), 3471 SP, mem1 + stack_offset); 3472 __ LoadFromOffset(kLoadWord, IP, SP, mem2 + stack_offset); 3473 __ StoreToOffset(kStoreWord, static_cast<Register>(ensure_scratch.GetRegister()), 3474 SP, mem2 + stack_offset); 3475 __ StoreToOffset(kStoreWord, IP, SP, mem1 + stack_offset); 3476} 3477 3478void ParallelMoveResolverARM::EmitSwap(size_t index) { 3479 MoveOperands* move = moves_.Get(index); 3480 Location source = move->GetSource(); 3481 Location destination = move->GetDestination(); 3482 3483 if (source.IsRegister() && destination.IsRegister()) { 3484 DCHECK_NE(source.AsRegister<Register>(), IP); 3485 DCHECK_NE(destination.AsRegister<Register>(), IP); 3486 __ Mov(IP, source.AsRegister<Register>()); 3487 __ Mov(source.AsRegister<Register>(), destination.AsRegister<Register>()); 3488 __ Mov(destination.AsRegister<Register>(), IP); 3489 } else if (source.IsRegister() && destination.IsStackSlot()) { 3490 Exchange(source.AsRegister<Register>(), destination.GetStackIndex()); 3491 } else if (source.IsStackSlot() && destination.IsRegister()) { 3492 Exchange(destination.AsRegister<Register>(), source.GetStackIndex()); 3493 } else if (source.IsStackSlot() && destination.IsStackSlot()) { 3494 Exchange(source.GetStackIndex(), destination.GetStackIndex()); 3495 } else if (source.IsFpuRegister() && destination.IsFpuRegister()) { 3496 __ vmovrs(IP, source.AsFpuRegister<SRegister>()); 3497 __ vmovs(source.AsFpuRegister<SRegister>(), destination.AsFpuRegister<SRegister>()); 3498 __ vmovsr(destination.AsFpuRegister<SRegister>(), IP); 3499 } else if (source.IsRegisterPair() && destination.IsRegisterPair()) { 3500 __ vmovdrr(DTMP, source.AsRegisterPairLow<Register>(), source.AsRegisterPairHigh<Register>()); 3501 __ Mov(source.AsRegisterPairLow<Register>(), destination.AsRegisterPairLow<Register>()); 3502 __ Mov(source.AsRegisterPairHigh<Register>(), destination.AsRegisterPairHigh<Register>()); 3503 __ vmovrrd(destination.AsRegisterPairLow<Register>(), 3504 destination.AsRegisterPairHigh<Register>(), 3505 DTMP); 3506 } else if (source.IsRegisterPair() || destination.IsRegisterPair()) { 3507 Register low_reg = source.IsRegisterPair() 3508 ? source.AsRegisterPairLow<Register>() 3509 : destination.AsRegisterPairLow<Register>(); 3510 int mem = source.IsRegisterPair() 3511 ? destination.GetStackIndex() 3512 : source.GetStackIndex(); 3513 DCHECK(ExpectedPairLayout(source.IsRegisterPair() ? source : destination)); 3514 __ vmovdrr(DTMP, low_reg, static_cast<Register>(low_reg + 1)); 3515 __ LoadFromOffset(kLoadWordPair, low_reg, SP, mem); 3516 __ StoreDToOffset(DTMP, SP, mem); 3517 } else if (source.IsFpuRegisterPair() && destination.IsFpuRegisterPair()) { 3518 DRegister first = FromLowSToD(source.AsFpuRegisterPairLow<SRegister>()); 3519 DRegister second = FromLowSToD(destination.AsFpuRegisterPairLow<SRegister>()); 3520 __ vmovd(DTMP, first); 3521 __ vmovd(first, second); 3522 __ vmovd(second, DTMP); 3523 } else if (source.IsFpuRegisterPair() || destination.IsFpuRegisterPair()) { 3524 DRegister reg = source.IsFpuRegisterPair() 3525 ? FromLowSToD(source.AsFpuRegisterPairLow<SRegister>()) 3526 : FromLowSToD(destination.AsFpuRegisterPairLow<SRegister>()); 3527 int mem = source.IsFpuRegisterPair() 3528 ? destination.GetStackIndex() 3529 : source.GetStackIndex(); 3530 __ vmovd(DTMP, reg); 3531 __ LoadDFromOffset(reg, SP, mem); 3532 __ StoreDToOffset(DTMP, SP, mem); 3533 } else if (source.IsFpuRegister() || destination.IsFpuRegister()) { 3534 SRegister reg = source.IsFpuRegister() ? source.AsFpuRegister<SRegister>() 3535 : destination.AsFpuRegister<SRegister>(); 3536 int mem = source.IsFpuRegister() 3537 ? destination.GetStackIndex() 3538 : source.GetStackIndex(); 3539 3540 __ vmovrs(IP, reg); 3541 __ LoadSFromOffset(reg, SP, mem); 3542 __ StoreToOffset(kStoreWord, IP, SP, mem); 3543 } else if (source.IsDoubleStackSlot() && destination.IsDoubleStackSlot()) { 3544 Exchange(source.GetStackIndex(), destination.GetStackIndex()); 3545 Exchange(source.GetHighStackIndex(kArmWordSize), destination.GetHighStackIndex(kArmWordSize)); 3546 } else { 3547 LOG(FATAL) << "Unimplemented" << source << " <-> " << destination; 3548 } 3549} 3550 3551void ParallelMoveResolverARM::SpillScratch(int reg) { 3552 __ Push(static_cast<Register>(reg)); 3553} 3554 3555void ParallelMoveResolverARM::RestoreScratch(int reg) { 3556 __ Pop(static_cast<Register>(reg)); 3557} 3558 3559void LocationsBuilderARM::VisitLoadClass(HLoadClass* cls) { 3560 LocationSummary::CallKind call_kind = cls->CanCallRuntime() 3561 ? LocationSummary::kCallOnSlowPath 3562 : LocationSummary::kNoCall; 3563 LocationSummary* locations = 3564 new (GetGraph()->GetArena()) LocationSummary(cls, call_kind); 3565 locations->SetOut(Location::RequiresRegister()); 3566} 3567 3568void InstructionCodeGeneratorARM::VisitLoadClass(HLoadClass* cls) { 3569 Register out = cls->GetLocations()->Out().AsRegister<Register>(); 3570 if (cls->IsReferrersClass()) { 3571 DCHECK(!cls->CanCallRuntime()); 3572 DCHECK(!cls->MustGenerateClinitCheck()); 3573 codegen_->LoadCurrentMethod(out); 3574 __ LoadFromOffset(kLoadWord, out, out, mirror::ArtMethod::DeclaringClassOffset().Int32Value()); 3575 } else { 3576 DCHECK(cls->CanCallRuntime()); 3577 codegen_->LoadCurrentMethod(out); 3578 __ LoadFromOffset( 3579 kLoadWord, out, out, mirror::ArtMethod::DexCacheResolvedTypesOffset().Int32Value()); 3580 __ LoadFromOffset(kLoadWord, out, out, CodeGenerator::GetCacheOffset(cls->GetTypeIndex())); 3581 3582 SlowPathCodeARM* slow_path = new (GetGraph()->GetArena()) LoadClassSlowPathARM( 3583 cls, cls, cls->GetDexPc(), cls->MustGenerateClinitCheck()); 3584 codegen_->AddSlowPath(slow_path); 3585 __ cmp(out, ShifterOperand(0)); 3586 __ b(slow_path->GetEntryLabel(), EQ); 3587 if (cls->MustGenerateClinitCheck()) { 3588 GenerateClassInitializationCheck(slow_path, out); 3589 } else { 3590 __ Bind(slow_path->GetExitLabel()); 3591 } 3592 } 3593} 3594 3595void LocationsBuilderARM::VisitClinitCheck(HClinitCheck* check) { 3596 LocationSummary* locations = 3597 new (GetGraph()->GetArena()) LocationSummary(check, LocationSummary::kCallOnSlowPath); 3598 locations->SetInAt(0, Location::RequiresRegister()); 3599 if (check->HasUses()) { 3600 locations->SetOut(Location::SameAsFirstInput()); 3601 } 3602} 3603 3604void InstructionCodeGeneratorARM::VisitClinitCheck(HClinitCheck* check) { 3605 // We assume the class is not null. 3606 SlowPathCodeARM* slow_path = new (GetGraph()->GetArena()) LoadClassSlowPathARM( 3607 check->GetLoadClass(), check, check->GetDexPc(), true); 3608 codegen_->AddSlowPath(slow_path); 3609 GenerateClassInitializationCheck(slow_path, 3610 check->GetLocations()->InAt(0).AsRegister<Register>()); 3611} 3612 3613void InstructionCodeGeneratorARM::GenerateClassInitializationCheck( 3614 SlowPathCodeARM* slow_path, Register class_reg) { 3615 __ LoadFromOffset(kLoadWord, IP, class_reg, mirror::Class::StatusOffset().Int32Value()); 3616 __ cmp(IP, ShifterOperand(mirror::Class::kStatusInitialized)); 3617 __ b(slow_path->GetEntryLabel(), LT); 3618 // Even if the initialized flag is set, we may be in a situation where caches are not synced 3619 // properly. Therefore, we do a memory fence. 3620 __ dmb(ISH); 3621 __ Bind(slow_path->GetExitLabel()); 3622} 3623 3624void LocationsBuilderARM::VisitLoadString(HLoadString* load) { 3625 LocationSummary* locations = 3626 new (GetGraph()->GetArena()) LocationSummary(load, LocationSummary::kCallOnSlowPath); 3627 locations->SetOut(Location::RequiresRegister()); 3628} 3629 3630void InstructionCodeGeneratorARM::VisitLoadString(HLoadString* load) { 3631 SlowPathCodeARM* slow_path = new (GetGraph()->GetArena()) LoadStringSlowPathARM(load); 3632 codegen_->AddSlowPath(slow_path); 3633 3634 Register out = load->GetLocations()->Out().AsRegister<Register>(); 3635 codegen_->LoadCurrentMethod(out); 3636 __ LoadFromOffset(kLoadWord, out, out, mirror::ArtMethod::DeclaringClassOffset().Int32Value()); 3637 __ LoadFromOffset(kLoadWord, out, out, mirror::Class::DexCacheStringsOffset().Int32Value()); 3638 __ LoadFromOffset(kLoadWord, out, out, CodeGenerator::GetCacheOffset(load->GetStringIndex())); 3639 __ cmp(out, ShifterOperand(0)); 3640 __ b(slow_path->GetEntryLabel(), EQ); 3641 __ Bind(slow_path->GetExitLabel()); 3642} 3643 3644void LocationsBuilderARM::VisitLoadException(HLoadException* load) { 3645 LocationSummary* locations = 3646 new (GetGraph()->GetArena()) LocationSummary(load, LocationSummary::kNoCall); 3647 locations->SetOut(Location::RequiresRegister()); 3648} 3649 3650void InstructionCodeGeneratorARM::VisitLoadException(HLoadException* load) { 3651 Register out = load->GetLocations()->Out().AsRegister<Register>(); 3652 int32_t offset = Thread::ExceptionOffset<kArmWordSize>().Int32Value(); 3653 __ LoadFromOffset(kLoadWord, out, TR, offset); 3654 __ LoadImmediate(IP, 0); 3655 __ StoreToOffset(kStoreWord, IP, TR, offset); 3656} 3657 3658void LocationsBuilderARM::VisitThrow(HThrow* instruction) { 3659 LocationSummary* locations = 3660 new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kCall); 3661 InvokeRuntimeCallingConvention calling_convention; 3662 locations->SetInAt(0, Location::RegisterLocation(calling_convention.GetRegisterAt(0))); 3663} 3664 3665void InstructionCodeGeneratorARM::VisitThrow(HThrow* instruction) { 3666 codegen_->InvokeRuntime( 3667 QUICK_ENTRY_POINT(pDeliverException), instruction, instruction->GetDexPc()); 3668} 3669 3670void LocationsBuilderARM::VisitInstanceOf(HInstanceOf* instruction) { 3671 LocationSummary::CallKind call_kind = instruction->IsClassFinal() 3672 ? LocationSummary::kNoCall 3673 : LocationSummary::kCallOnSlowPath; 3674 LocationSummary* locations = new (GetGraph()->GetArena()) LocationSummary(instruction, call_kind); 3675 locations->SetInAt(0, Location::RequiresRegister()); 3676 locations->SetInAt(1, Location::RequiresRegister()); 3677 // The out register is used as a temporary, so it overlaps with the inputs. 3678 locations->SetOut(Location::RequiresRegister(), Location::kOutputOverlap); 3679} 3680 3681void InstructionCodeGeneratorARM::VisitInstanceOf(HInstanceOf* instruction) { 3682 LocationSummary* locations = instruction->GetLocations(); 3683 Register obj = locations->InAt(0).AsRegister<Register>(); 3684 Register cls = locations->InAt(1).AsRegister<Register>(); 3685 Register out = locations->Out().AsRegister<Register>(); 3686 uint32_t class_offset = mirror::Object::ClassOffset().Int32Value(); 3687 Label done, zero; 3688 SlowPathCodeARM* slow_path = nullptr; 3689 3690 // Return 0 if `obj` is null. 3691 // TODO: avoid this check if we know obj is not null. 3692 __ cmp(obj, ShifterOperand(0)); 3693 __ b(&zero, EQ); 3694 // Compare the class of `obj` with `cls`. 3695 __ LoadFromOffset(kLoadWord, out, obj, class_offset); 3696 __ cmp(out, ShifterOperand(cls)); 3697 if (instruction->IsClassFinal()) { 3698 // Classes must be equal for the instanceof to succeed. 3699 __ b(&zero, NE); 3700 __ LoadImmediate(out, 1); 3701 __ b(&done); 3702 } else { 3703 // If the classes are not equal, we go into a slow path. 3704 DCHECK(locations->OnlyCallsOnSlowPath()); 3705 slow_path = new (GetGraph()->GetArena()) TypeCheckSlowPathARM( 3706 instruction, locations->InAt(1), locations->Out(), instruction->GetDexPc()); 3707 codegen_->AddSlowPath(slow_path); 3708 __ b(slow_path->GetEntryLabel(), NE); 3709 __ LoadImmediate(out, 1); 3710 __ b(&done); 3711 } 3712 __ Bind(&zero); 3713 __ LoadImmediate(out, 0); 3714 if (slow_path != nullptr) { 3715 __ Bind(slow_path->GetExitLabel()); 3716 } 3717 __ Bind(&done); 3718} 3719 3720void LocationsBuilderARM::VisitCheckCast(HCheckCast* instruction) { 3721 LocationSummary* locations = new (GetGraph()->GetArena()) LocationSummary( 3722 instruction, LocationSummary::kCallOnSlowPath); 3723 locations->SetInAt(0, Location::RequiresRegister()); 3724 locations->SetInAt(1, Location::RequiresRegister()); 3725 locations->AddTemp(Location::RequiresRegister()); 3726} 3727 3728void InstructionCodeGeneratorARM::VisitCheckCast(HCheckCast* instruction) { 3729 LocationSummary* locations = instruction->GetLocations(); 3730 Register obj = locations->InAt(0).AsRegister<Register>(); 3731 Register cls = locations->InAt(1).AsRegister<Register>(); 3732 Register temp = locations->GetTemp(0).AsRegister<Register>(); 3733 uint32_t class_offset = mirror::Object::ClassOffset().Int32Value(); 3734 3735 SlowPathCodeARM* slow_path = new (GetGraph()->GetArena()) TypeCheckSlowPathARM( 3736 instruction, locations->InAt(1), locations->GetTemp(0), instruction->GetDexPc()); 3737 codegen_->AddSlowPath(slow_path); 3738 3739 // TODO: avoid this check if we know obj is not null. 3740 __ cmp(obj, ShifterOperand(0)); 3741 __ b(slow_path->GetExitLabel(), EQ); 3742 // Compare the class of `obj` with `cls`. 3743 __ LoadFromOffset(kLoadWord, temp, obj, class_offset); 3744 __ cmp(temp, ShifterOperand(cls)); 3745 __ b(slow_path->GetEntryLabel(), NE); 3746 __ Bind(slow_path->GetExitLabel()); 3747} 3748 3749void LocationsBuilderARM::VisitMonitorOperation(HMonitorOperation* instruction) { 3750 LocationSummary* locations = 3751 new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kCall); 3752 InvokeRuntimeCallingConvention calling_convention; 3753 locations->SetInAt(0, Location::RegisterLocation(calling_convention.GetRegisterAt(0))); 3754} 3755 3756void InstructionCodeGeneratorARM::VisitMonitorOperation(HMonitorOperation* instruction) { 3757 codegen_->InvokeRuntime(instruction->IsEnter() 3758 ? QUICK_ENTRY_POINT(pLockObject) : QUICK_ENTRY_POINT(pUnlockObject), 3759 instruction, 3760 instruction->GetDexPc()); 3761} 3762 3763void LocationsBuilderARM::VisitAnd(HAnd* instruction) { HandleBitwiseOperation(instruction); } 3764void LocationsBuilderARM::VisitOr(HOr* instruction) { HandleBitwiseOperation(instruction); } 3765void LocationsBuilderARM::VisitXor(HXor* instruction) { HandleBitwiseOperation(instruction); } 3766 3767void LocationsBuilderARM::HandleBitwiseOperation(HBinaryOperation* instruction) { 3768 LocationSummary* locations = 3769 new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kNoCall); 3770 DCHECK(instruction->GetResultType() == Primitive::kPrimInt 3771 || instruction->GetResultType() == Primitive::kPrimLong); 3772 locations->SetInAt(0, Location::RequiresRegister()); 3773 locations->SetInAt(1, Location::RequiresRegister()); 3774 locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap); 3775} 3776 3777void InstructionCodeGeneratorARM::VisitAnd(HAnd* instruction) { 3778 HandleBitwiseOperation(instruction); 3779} 3780 3781void InstructionCodeGeneratorARM::VisitOr(HOr* instruction) { 3782 HandleBitwiseOperation(instruction); 3783} 3784 3785void InstructionCodeGeneratorARM::VisitXor(HXor* instruction) { 3786 HandleBitwiseOperation(instruction); 3787} 3788 3789void InstructionCodeGeneratorARM::HandleBitwiseOperation(HBinaryOperation* instruction) { 3790 LocationSummary* locations = instruction->GetLocations(); 3791 3792 if (instruction->GetResultType() == Primitive::kPrimInt) { 3793 Register first = locations->InAt(0).AsRegister<Register>(); 3794 Register second = locations->InAt(1).AsRegister<Register>(); 3795 Register out = locations->Out().AsRegister<Register>(); 3796 if (instruction->IsAnd()) { 3797 __ and_(out, first, ShifterOperand(second)); 3798 } else if (instruction->IsOr()) { 3799 __ orr(out, first, ShifterOperand(second)); 3800 } else { 3801 DCHECK(instruction->IsXor()); 3802 __ eor(out, first, ShifterOperand(second)); 3803 } 3804 } else { 3805 DCHECK_EQ(instruction->GetResultType(), Primitive::kPrimLong); 3806 Location first = locations->InAt(0); 3807 Location second = locations->InAt(1); 3808 Location out = locations->Out(); 3809 if (instruction->IsAnd()) { 3810 __ and_(out.AsRegisterPairLow<Register>(), 3811 first.AsRegisterPairLow<Register>(), 3812 ShifterOperand(second.AsRegisterPairLow<Register>())); 3813 __ and_(out.AsRegisterPairHigh<Register>(), 3814 first.AsRegisterPairHigh<Register>(), 3815 ShifterOperand(second.AsRegisterPairHigh<Register>())); 3816 } else if (instruction->IsOr()) { 3817 __ orr(out.AsRegisterPairLow<Register>(), 3818 first.AsRegisterPairLow<Register>(), 3819 ShifterOperand(second.AsRegisterPairLow<Register>())); 3820 __ orr(out.AsRegisterPairHigh<Register>(), 3821 first.AsRegisterPairHigh<Register>(), 3822 ShifterOperand(second.AsRegisterPairHigh<Register>())); 3823 } else { 3824 DCHECK(instruction->IsXor()); 3825 __ eor(out.AsRegisterPairLow<Register>(), 3826 first.AsRegisterPairLow<Register>(), 3827 ShifterOperand(second.AsRegisterPairLow<Register>())); 3828 __ eor(out.AsRegisterPairHigh<Register>(), 3829 first.AsRegisterPairHigh<Register>(), 3830 ShifterOperand(second.AsRegisterPairHigh<Register>())); 3831 } 3832 } 3833} 3834 3835void CodeGeneratorARM::GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke, Register temp) { 3836 DCHECK_EQ(temp, kArtMethodRegister); 3837 3838 // TODO: Implement all kinds of calls: 3839 // 1) boot -> boot 3840 // 2) app -> boot 3841 // 3) app -> app 3842 // 3843 // Currently we implement the app -> app logic, which looks up in the resolve cache. 3844 3845 // temp = method; 3846 LoadCurrentMethod(temp); 3847 if (!invoke->IsRecursive()) { 3848 // temp = temp->dex_cache_resolved_methods_; 3849 __ LoadFromOffset( 3850 kLoadWord, temp, temp, mirror::ArtMethod::DexCacheResolvedMethodsOffset().Int32Value()); 3851 // temp = temp[index_in_cache] 3852 __ LoadFromOffset( 3853 kLoadWord, temp, temp, CodeGenerator::GetCacheOffset(invoke->GetDexMethodIndex())); 3854 // LR = temp[offset_of_quick_compiled_code] 3855 __ LoadFromOffset(kLoadWord, LR, temp, 3856 mirror::ArtMethod::EntryPointFromQuickCompiledCodeOffset( 3857 kArmWordSize).Int32Value()); 3858 // LR() 3859 __ blx(LR); 3860 } else { 3861 __ bl(GetFrameEntryLabel()); 3862 } 3863 3864 RecordPcInfo(invoke, invoke->GetDexPc()); 3865 DCHECK(!IsLeafMethod()); 3866} 3867 3868void LocationsBuilderARM::VisitBoundType(HBoundType* instruction) { 3869 // Nothing to do, this should be removed during prepare for register allocator. 3870 UNUSED(instruction); 3871 LOG(FATAL) << "Unreachable"; 3872} 3873 3874void InstructionCodeGeneratorARM::VisitBoundType(HBoundType* instruction) { 3875 // Nothing to do, this should be removed during prepare for register allocator. 3876 UNUSED(instruction); 3877 LOG(FATAL) << "Unreachable"; 3878} 3879 3880} // namespace arm 3881} // namespace art 3882