Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 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 | #ifndef ART_COMPILER_OPTIMIZING_CODE_GENERATOR_ARM64_H_ |
| 18 | #define ART_COMPILER_OPTIMIZING_CODE_GENERATOR_ARM64_H_ |
| 19 | |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 20 | #include "arch/arm64/quick_method_frame_info_arm64.h" |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 21 | #include "code_generator.h" |
Calin Juravle | e460d1d | 2015-09-29 04:52:17 +0100 | [diff] [blame] | 22 | #include "common_arm64.h" |
Andreas Gampe | a5b09a6 | 2016-11-17 15:21:22 -0800 | [diff] [blame] | 23 | #include "dex_file_types.h" |
Calin Juravle | cd6dffe | 2015-01-08 17:35:35 +0000 | [diff] [blame] | 24 | #include "driver/compiler_options.h" |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 25 | #include "nodes.h" |
| 26 | #include "parallel_move_resolver.h" |
Mathieu Chartier | dc00f18 | 2016-07-14 10:10:44 -0700 | [diff] [blame] | 27 | #include "string_reference.h" |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 28 | #include "utils/arm64/assembler_arm64.h" |
Vladimir Marko | dbb7f5b | 2016-03-30 13:23:58 +0100 | [diff] [blame] | 29 | #include "utils/type_reference.h" |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 30 | |
Artem Serov | af4e42a | 2016-08-08 15:11:24 +0100 | [diff] [blame] | 31 | // TODO(VIXL): Make VIXL compile with -Wshadow. |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 32 | #pragma GCC diagnostic push |
| 33 | #pragma GCC diagnostic ignored "-Wshadow" |
Artem Serov | af4e42a | 2016-08-08 15:11:24 +0100 | [diff] [blame] | 34 | #include "aarch64/disasm-aarch64.h" |
| 35 | #include "aarch64/macro-assembler-aarch64.h" |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 36 | #pragma GCC diagnostic pop |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 37 | |
| 38 | namespace art { |
| 39 | namespace arm64 { |
| 40 | |
| 41 | class CodeGeneratorARM64; |
Andreas Gampe | 878d58c | 2015-01-15 23:24:00 -0800 | [diff] [blame] | 42 | |
Nicolas Geoffray | 86a8d7a | 2014-11-19 08:47:18 +0000 | [diff] [blame] | 43 | // Use a local definition to prevent copying mistakes. |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 44 | static constexpr size_t kArm64WordSize = static_cast<size_t>(kArm64PointerSize); |
Nicolas Geoffray | 86a8d7a | 2014-11-19 08:47:18 +0000 | [diff] [blame] | 45 | |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 46 | static const vixl::aarch64::Register kParameterCoreRegisters[] = { |
| 47 | vixl::aarch64::x1, |
| 48 | vixl::aarch64::x2, |
| 49 | vixl::aarch64::x3, |
| 50 | vixl::aarch64::x4, |
| 51 | vixl::aarch64::x5, |
| 52 | vixl::aarch64::x6, |
| 53 | vixl::aarch64::x7 |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 54 | }; |
| 55 | static constexpr size_t kParameterCoreRegistersLength = arraysize(kParameterCoreRegisters); |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 56 | static const vixl::aarch64::FPRegister kParameterFPRegisters[] = { |
| 57 | vixl::aarch64::d0, |
| 58 | vixl::aarch64::d1, |
| 59 | vixl::aarch64::d2, |
| 60 | vixl::aarch64::d3, |
| 61 | vixl::aarch64::d4, |
| 62 | vixl::aarch64::d5, |
| 63 | vixl::aarch64::d6, |
| 64 | vixl::aarch64::d7 |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 65 | }; |
| 66 | static constexpr size_t kParameterFPRegistersLength = arraysize(kParameterFPRegisters); |
| 67 | |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 68 | // Thread Register |
| 69 | const vixl::aarch64::Register tr = vixl::aarch64::x19; |
| 70 | // Method register on invoke. |
| 71 | static const vixl::aarch64::Register kArtMethodRegister = vixl::aarch64::x0; |
| 72 | const vixl::aarch64::CPURegList vixl_reserved_core_registers(vixl::aarch64::ip0, |
| 73 | vixl::aarch64::ip1); |
| 74 | const vixl::aarch64::CPURegList vixl_reserved_fp_registers(vixl::aarch64::d31); |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 75 | |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 76 | const vixl::aarch64::CPURegList runtime_reserved_core_registers(tr, vixl::aarch64::lr); |
Serban Constantinescu | 3d087de | 2015-01-28 11:57:05 +0000 | [diff] [blame] | 77 | |
Serban Constantinescu | 9bd88b0 | 2015-04-22 16:24:46 +0100 | [diff] [blame] | 78 | // Callee-saved registers AAPCS64 (without x19 - Thread Register) |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 79 | const vixl::aarch64::CPURegList callee_saved_core_registers(vixl::aarch64::CPURegister::kRegister, |
| 80 | vixl::aarch64::kXRegSize, |
| 81 | vixl::aarch64::x20.GetCode(), |
| 82 | vixl::aarch64::x30.GetCode()); |
| 83 | const vixl::aarch64::CPURegList callee_saved_fp_registers(vixl::aarch64::CPURegister::kFPRegister, |
| 84 | vixl::aarch64::kDRegSize, |
| 85 | vixl::aarch64::d8.GetCode(), |
| 86 | vixl::aarch64::d15.GetCode()); |
Alexandre Rames | a89086e | 2014-11-07 17:13:25 +0000 | [diff] [blame] | 87 | Location ARM64ReturnLocation(Primitive::Type return_type); |
| 88 | |
Andreas Gampe | 878d58c | 2015-01-15 23:24:00 -0800 | [diff] [blame] | 89 | class SlowPathCodeARM64 : public SlowPathCode { |
| 90 | public: |
David Srbecky | 9cd6d37 | 2016-02-09 15:24:47 +0000 | [diff] [blame] | 91 | explicit SlowPathCodeARM64(HInstruction* instruction) |
| 92 | : SlowPathCode(instruction), entry_label_(), exit_label_() {} |
Andreas Gampe | 878d58c | 2015-01-15 23:24:00 -0800 | [diff] [blame] | 93 | |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 94 | vixl::aarch64::Label* GetEntryLabel() { return &entry_label_; } |
| 95 | vixl::aarch64::Label* GetExitLabel() { return &exit_label_; } |
Andreas Gampe | 878d58c | 2015-01-15 23:24:00 -0800 | [diff] [blame] | 96 | |
Zheng Xu | da40309 | 2015-04-24 17:35:39 +0800 | [diff] [blame] | 97 | void SaveLiveRegisters(CodeGenerator* codegen, LocationSummary* locations) OVERRIDE; |
| 98 | void RestoreLiveRegisters(CodeGenerator* codegen, LocationSummary* locations) OVERRIDE; |
| 99 | |
Andreas Gampe | 878d58c | 2015-01-15 23:24:00 -0800 | [diff] [blame] | 100 | private: |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 101 | vixl::aarch64::Label entry_label_; |
| 102 | vixl::aarch64::Label exit_label_; |
Andreas Gampe | 878d58c | 2015-01-15 23:24:00 -0800 | [diff] [blame] | 103 | |
| 104 | DISALLOW_COPY_AND_ASSIGN(SlowPathCodeARM64); |
| 105 | }; |
| 106 | |
Alexandre Rames | c01a664 | 2016-04-15 11:54:06 +0100 | [diff] [blame] | 107 | class JumpTableARM64 : public DeletableArenaObject<kArenaAllocSwitchTable> { |
Zheng Xu | 3927c8b | 2015-11-18 17:46:25 +0800 | [diff] [blame] | 108 | public: |
| 109 | explicit JumpTableARM64(HPackedSwitch* switch_instr) |
| 110 | : switch_instr_(switch_instr), table_start_() {} |
| 111 | |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 112 | vixl::aarch64::Label* GetTableStartLabel() { return &table_start_; } |
Zheng Xu | 3927c8b | 2015-11-18 17:46:25 +0800 | [diff] [blame] | 113 | |
| 114 | void EmitTable(CodeGeneratorARM64* codegen); |
| 115 | |
| 116 | private: |
| 117 | HPackedSwitch* const switch_instr_; |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 118 | vixl::aarch64::Label table_start_; |
Zheng Xu | 3927c8b | 2015-11-18 17:46:25 +0800 | [diff] [blame] | 119 | |
| 120 | DISALLOW_COPY_AND_ASSIGN(JumpTableARM64); |
| 121 | }; |
| 122 | |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 123 | static const vixl::aarch64::Register kRuntimeParameterCoreRegisters[] = |
| 124 | { vixl::aarch64::x0, |
| 125 | vixl::aarch64::x1, |
| 126 | vixl::aarch64::x2, |
| 127 | vixl::aarch64::x3, |
| 128 | vixl::aarch64::x4, |
| 129 | vixl::aarch64::x5, |
| 130 | vixl::aarch64::x6, |
| 131 | vixl::aarch64::x7 }; |
Nicolas Geoffray | d75948a | 2015-03-27 09:53:16 +0000 | [diff] [blame] | 132 | static constexpr size_t kRuntimeParameterCoreRegistersLength = |
| 133 | arraysize(kRuntimeParameterCoreRegisters); |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 134 | static const vixl::aarch64::FPRegister kRuntimeParameterFpuRegisters[] = |
| 135 | { vixl::aarch64::d0, |
| 136 | vixl::aarch64::d1, |
| 137 | vixl::aarch64::d2, |
| 138 | vixl::aarch64::d3, |
| 139 | vixl::aarch64::d4, |
| 140 | vixl::aarch64::d5, |
| 141 | vixl::aarch64::d6, |
| 142 | vixl::aarch64::d7 }; |
Nicolas Geoffray | d75948a | 2015-03-27 09:53:16 +0000 | [diff] [blame] | 143 | static constexpr size_t kRuntimeParameterFpuRegistersLength = |
| 144 | arraysize(kRuntimeParameterCoreRegisters); |
| 145 | |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 146 | class InvokeRuntimeCallingConvention : public CallingConvention<vixl::aarch64::Register, |
| 147 | vixl::aarch64::FPRegister> { |
Nicolas Geoffray | d75948a | 2015-03-27 09:53:16 +0000 | [diff] [blame] | 148 | public: |
| 149 | static constexpr size_t kParameterCoreRegistersLength = arraysize(kParameterCoreRegisters); |
| 150 | |
| 151 | InvokeRuntimeCallingConvention() |
| 152 | : CallingConvention(kRuntimeParameterCoreRegisters, |
| 153 | kRuntimeParameterCoreRegistersLength, |
| 154 | kRuntimeParameterFpuRegisters, |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 155 | kRuntimeParameterFpuRegistersLength, |
| 156 | kArm64PointerSize) {} |
Nicolas Geoffray | d75948a | 2015-03-27 09:53:16 +0000 | [diff] [blame] | 157 | |
| 158 | Location GetReturnLocation(Primitive::Type return_type); |
| 159 | |
| 160 | private: |
| 161 | DISALLOW_COPY_AND_ASSIGN(InvokeRuntimeCallingConvention); |
| 162 | }; |
| 163 | |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 164 | class InvokeDexCallingConvention : public CallingConvention<vixl::aarch64::Register, |
| 165 | vixl::aarch64::FPRegister> { |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 166 | public: |
| 167 | InvokeDexCallingConvention() |
| 168 | : CallingConvention(kParameterCoreRegisters, |
| 169 | kParameterCoreRegistersLength, |
| 170 | kParameterFPRegisters, |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 171 | kParameterFPRegistersLength, |
| 172 | kArm64PointerSize) {} |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 173 | |
Nicolas Geoffray | fd88f16 | 2015-06-03 11:23:52 +0100 | [diff] [blame] | 174 | Location GetReturnLocation(Primitive::Type return_type) const { |
Alexandre Rames | a89086e | 2014-11-07 17:13:25 +0000 | [diff] [blame] | 175 | return ARM64ReturnLocation(return_type); |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 176 | } |
| 177 | |
| 178 | |
| 179 | private: |
| 180 | DISALLOW_COPY_AND_ASSIGN(InvokeDexCallingConvention); |
| 181 | }; |
| 182 | |
Roland Levillain | 2d27c8e | 2015-04-28 15:48:45 +0100 | [diff] [blame] | 183 | class InvokeDexCallingConventionVisitorARM64 : public InvokeDexCallingConventionVisitor { |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 184 | public: |
Roland Levillain | 2d27c8e | 2015-04-28 15:48:45 +0100 | [diff] [blame] | 185 | InvokeDexCallingConventionVisitorARM64() {} |
| 186 | virtual ~InvokeDexCallingConventionVisitorARM64() {} |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 187 | |
Roland Levillain | 2d27c8e | 2015-04-28 15:48:45 +0100 | [diff] [blame] | 188 | Location GetNextLocation(Primitive::Type type) OVERRIDE; |
Nicolas Geoffray | fd88f16 | 2015-06-03 11:23:52 +0100 | [diff] [blame] | 189 | Location GetReturnLocation(Primitive::Type return_type) const OVERRIDE { |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 190 | return calling_convention.GetReturnLocation(return_type); |
| 191 | } |
Nicolas Geoffray | fd88f16 | 2015-06-03 11:23:52 +0100 | [diff] [blame] | 192 | Location GetMethodLocation() const OVERRIDE; |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 193 | |
| 194 | private: |
| 195 | InvokeDexCallingConvention calling_convention; |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 196 | |
Roland Levillain | 2d27c8e | 2015-04-28 15:48:45 +0100 | [diff] [blame] | 197 | DISALLOW_COPY_AND_ASSIGN(InvokeDexCallingConventionVisitorARM64); |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 198 | }; |
| 199 | |
Calin Juravle | e460d1d | 2015-09-29 04:52:17 +0100 | [diff] [blame] | 200 | class FieldAccessCallingConventionARM64 : public FieldAccessCallingConvention { |
| 201 | public: |
| 202 | FieldAccessCallingConventionARM64() {} |
| 203 | |
| 204 | Location GetObjectLocation() const OVERRIDE { |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 205 | return helpers::LocationFrom(vixl::aarch64::x1); |
Calin Juravle | e460d1d | 2015-09-29 04:52:17 +0100 | [diff] [blame] | 206 | } |
| 207 | Location GetFieldIndexLocation() const OVERRIDE { |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 208 | return helpers::LocationFrom(vixl::aarch64::x0); |
Calin Juravle | e460d1d | 2015-09-29 04:52:17 +0100 | [diff] [blame] | 209 | } |
| 210 | Location GetReturnLocation(Primitive::Type type ATTRIBUTE_UNUSED) const OVERRIDE { |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 211 | return helpers::LocationFrom(vixl::aarch64::x0); |
Calin Juravle | e460d1d | 2015-09-29 04:52:17 +0100 | [diff] [blame] | 212 | } |
| 213 | Location GetSetValueLocation(Primitive::Type type, bool is_instance) const OVERRIDE { |
| 214 | return Primitive::Is64BitType(type) |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 215 | ? helpers::LocationFrom(vixl::aarch64::x2) |
Calin Juravle | e460d1d | 2015-09-29 04:52:17 +0100 | [diff] [blame] | 216 | : (is_instance |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 217 | ? helpers::LocationFrom(vixl::aarch64::x2) |
| 218 | : helpers::LocationFrom(vixl::aarch64::x1)); |
Calin Juravle | e460d1d | 2015-09-29 04:52:17 +0100 | [diff] [blame] | 219 | } |
| 220 | Location GetFpuLocation(Primitive::Type type ATTRIBUTE_UNUSED) const OVERRIDE { |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 221 | return helpers::LocationFrom(vixl::aarch64::d0); |
Calin Juravle | e460d1d | 2015-09-29 04:52:17 +0100 | [diff] [blame] | 222 | } |
| 223 | |
| 224 | private: |
| 225 | DISALLOW_COPY_AND_ASSIGN(FieldAccessCallingConventionARM64); |
| 226 | }; |
| 227 | |
Aart Bik | 42249c3 | 2016-01-07 15:33:50 -0800 | [diff] [blame] | 228 | class InstructionCodeGeneratorARM64 : public InstructionCodeGenerator { |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 229 | public: |
| 230 | InstructionCodeGeneratorARM64(HGraph* graph, CodeGeneratorARM64* codegen); |
| 231 | |
| 232 | #define DECLARE_VISIT_INSTRUCTION(name, super) \ |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 233 | void Visit##name(H##name* instr) OVERRIDE; |
Alexandre Rames | ef20f71 | 2015-06-09 10:29:30 +0100 | [diff] [blame] | 234 | |
| 235 | FOR_EACH_CONCRETE_INSTRUCTION_COMMON(DECLARE_VISIT_INSTRUCTION) |
| 236 | FOR_EACH_CONCRETE_INSTRUCTION_ARM64(DECLARE_VISIT_INSTRUCTION) |
Artem Udovichenko | 4a0dad6 | 2016-01-26 12:28:31 +0300 | [diff] [blame] | 237 | FOR_EACH_CONCRETE_INSTRUCTION_SHARED(DECLARE_VISIT_INSTRUCTION) |
Alexandre Rames | ef20f71 | 2015-06-09 10:29:30 +0100 | [diff] [blame] | 238 | |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 239 | #undef DECLARE_VISIT_INSTRUCTION |
| 240 | |
Alexandre Rames | ef20f71 | 2015-06-09 10:29:30 +0100 | [diff] [blame] | 241 | void VisitInstruction(HInstruction* instruction) OVERRIDE { |
| 242 | LOG(FATAL) << "Unreachable instruction " << instruction->DebugName() |
| 243 | << " (id " << instruction->GetId() << ")"; |
| 244 | } |
| 245 | |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 246 | Arm64Assembler* GetAssembler() const { return assembler_; } |
Alexandre Rames | 087930f | 2016-08-02 13:45:28 +0100 | [diff] [blame] | 247 | vixl::aarch64::MacroAssembler* GetVIXLAssembler() { return GetAssembler()->GetVIXLAssembler(); } |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 248 | |
| 249 | private: |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 250 | void GenerateClassInitializationCheck(SlowPathCodeARM64* slow_path, |
| 251 | vixl::aarch64::Register class_reg); |
Serban Constantinescu | 02164b3 | 2014-11-13 14:05:07 +0000 | [diff] [blame] | 252 | void GenerateSuspendCheck(HSuspendCheck* instruction, HBasicBlock* successor); |
Alexandre Rames | 67555f7 | 2014-11-18 10:55:16 +0000 | [diff] [blame] | 253 | void HandleBinaryOp(HBinaryOperation* instr); |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 254 | |
Nicolas Geoffray | 07276db | 2015-05-18 14:22:09 +0100 | [diff] [blame] | 255 | void HandleFieldSet(HInstruction* instruction, |
| 256 | const FieldInfo& field_info, |
| 257 | bool value_can_be_null); |
Alexandre Rames | 09a9996 | 2015-04-15 11:47:56 +0100 | [diff] [blame] | 258 | void HandleFieldGet(HInstruction* instruction, const FieldInfo& field_info); |
Vladimir Marko | 5f7b58e | 2015-11-23 19:49:34 +0000 | [diff] [blame] | 259 | void HandleCondition(HCondition* instruction); |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 260 | |
| 261 | // Generate a heap reference load using one register `out`: |
| 262 | // |
| 263 | // out <- *(out + offset) |
| 264 | // |
| 265 | // while honoring heap poisoning and/or read barriers (if any). |
| 266 | // |
| 267 | // Location `maybe_temp` is used when generating a read barrier and |
| 268 | // shall be a register in that case; it may be an invalid location |
| 269 | // otherwise. |
| 270 | void GenerateReferenceLoadOneRegister(HInstruction* instruction, |
| 271 | Location out, |
| 272 | uint32_t offset, |
Mathieu Chartier | aa474eb | 2016-11-09 15:18:27 -0800 | [diff] [blame] | 273 | Location maybe_temp, |
Mathieu Chartier | 3af00dc | 2016-11-10 11:25:57 -0800 | [diff] [blame] | 274 | ReadBarrierOption read_barrier_option); |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 275 | // Generate a heap reference load using two different registers |
| 276 | // `out` and `obj`: |
| 277 | // |
| 278 | // out <- *(obj + offset) |
| 279 | // |
| 280 | // while honoring heap poisoning and/or read barriers (if any). |
| 281 | // |
| 282 | // Location `maybe_temp` is used when generating a Baker's (fast |
| 283 | // path) read barrier and shall be a register in that case; it may |
| 284 | // be an invalid location otherwise. |
| 285 | void GenerateReferenceLoadTwoRegisters(HInstruction* instruction, |
| 286 | Location out, |
| 287 | Location obj, |
| 288 | uint32_t offset, |
Mathieu Chartier | 5c44c1b | 2016-11-04 18:13:04 -0700 | [diff] [blame] | 289 | Location maybe_temp, |
Mathieu Chartier | 3af00dc | 2016-11-10 11:25:57 -0800 | [diff] [blame] | 290 | ReadBarrierOption read_barrier_option); |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 291 | // Generate a GC root reference load: |
| 292 | // |
| 293 | // root <- *(obj + offset) |
| 294 | // |
Mathieu Chartier | 3af00dc | 2016-11-10 11:25:57 -0800 | [diff] [blame] | 295 | // while honoring read barriers based on read_barrier_option. |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 296 | void GenerateGcRootFieldLoad(HInstruction* instruction, |
| 297 | Location root, |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 298 | vixl::aarch64::Register obj, |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 299 | uint32_t offset, |
Roland Levillain | 00468f3 | 2016-10-27 18:02:48 +0100 | [diff] [blame] | 300 | vixl::aarch64::Label* fixup_label, |
Mathieu Chartier | 3af00dc | 2016-11-10 11:25:57 -0800 | [diff] [blame] | 301 | ReadBarrierOption read_barrier_option); |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 302 | |
Roland Levillain | 1a65388 | 2016-03-18 18:05:57 +0000 | [diff] [blame] | 303 | // Generate a floating-point comparison. |
| 304 | void GenerateFcmp(HInstruction* instruction); |
| 305 | |
Serban Constantinescu | 02164b3 | 2014-11-13 14:05:07 +0000 | [diff] [blame] | 306 | void HandleShift(HBinaryOperation* instr); |
Mingyao Yang | d43b3ac | 2015-04-01 14:03:04 -0700 | [diff] [blame] | 307 | void GenerateTestAndBranch(HInstruction* instruction, |
David Brazdil | 0debae7 | 2015-11-12 18:37:00 +0000 | [diff] [blame] | 308 | size_t condition_input_index, |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 309 | vixl::aarch64::Label* true_target, |
| 310 | vixl::aarch64::Label* false_target); |
Zheng Xu | c666710 | 2015-05-15 16:08:45 +0800 | [diff] [blame] | 311 | void DivRemOneOrMinusOne(HBinaryOperation* instruction); |
| 312 | void DivRemByPowerOfTwo(HBinaryOperation* instruction); |
| 313 | void GenerateDivRemWithAnyConstant(HBinaryOperation* instruction); |
| 314 | void GenerateDivRemIntegral(HBinaryOperation* instruction); |
David Brazdil | fc6a86a | 2015-06-26 10:33:45 +0000 | [diff] [blame] | 315 | void HandleGoto(HInstruction* got, HBasicBlock* successor); |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 316 | |
| 317 | Arm64Assembler* const assembler_; |
| 318 | CodeGeneratorARM64* const codegen_; |
| 319 | |
| 320 | DISALLOW_COPY_AND_ASSIGN(InstructionCodeGeneratorARM64); |
| 321 | }; |
| 322 | |
| 323 | class LocationsBuilderARM64 : public HGraphVisitor { |
| 324 | public: |
Roland Levillain | 3887c46 | 2015-08-12 18:15:42 +0100 | [diff] [blame] | 325 | LocationsBuilderARM64(HGraph* graph, CodeGeneratorARM64* codegen) |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 326 | : HGraphVisitor(graph), codegen_(codegen) {} |
| 327 | |
| 328 | #define DECLARE_VISIT_INSTRUCTION(name, super) \ |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 329 | void Visit##name(H##name* instr) OVERRIDE; |
Alexandre Rames | ef20f71 | 2015-06-09 10:29:30 +0100 | [diff] [blame] | 330 | |
| 331 | FOR_EACH_CONCRETE_INSTRUCTION_COMMON(DECLARE_VISIT_INSTRUCTION) |
| 332 | FOR_EACH_CONCRETE_INSTRUCTION_ARM64(DECLARE_VISIT_INSTRUCTION) |
Artem Udovichenko | 4a0dad6 | 2016-01-26 12:28:31 +0300 | [diff] [blame] | 333 | FOR_EACH_CONCRETE_INSTRUCTION_SHARED(DECLARE_VISIT_INSTRUCTION) |
Alexandre Rames | ef20f71 | 2015-06-09 10:29:30 +0100 | [diff] [blame] | 334 | |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 335 | #undef DECLARE_VISIT_INSTRUCTION |
| 336 | |
Alexandre Rames | ef20f71 | 2015-06-09 10:29:30 +0100 | [diff] [blame] | 337 | void VisitInstruction(HInstruction* instruction) OVERRIDE { |
| 338 | LOG(FATAL) << "Unreachable instruction " << instruction->DebugName() |
| 339 | << " (id " << instruction->GetId() << ")"; |
| 340 | } |
| 341 | |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 342 | private: |
Alexandre Rames | 67555f7 | 2014-11-18 10:55:16 +0000 | [diff] [blame] | 343 | void HandleBinaryOp(HBinaryOperation* instr); |
Alexandre Rames | 09a9996 | 2015-04-15 11:47:56 +0100 | [diff] [blame] | 344 | void HandleFieldSet(HInstruction* instruction); |
| 345 | void HandleFieldGet(HInstruction* instruction); |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 346 | void HandleInvoke(HInvoke* instr); |
Vladimir Marko | 5f7b58e | 2015-11-23 19:49:34 +0000 | [diff] [blame] | 347 | void HandleCondition(HCondition* instruction); |
Alexandre Rames | 09a9996 | 2015-04-15 11:47:56 +0100 | [diff] [blame] | 348 | void HandleShift(HBinaryOperation* instr); |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 349 | |
| 350 | CodeGeneratorARM64* const codegen_; |
Roland Levillain | 2d27c8e | 2015-04-28 15:48:45 +0100 | [diff] [blame] | 351 | InvokeDexCallingConventionVisitorARM64 parameter_visitor_; |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 352 | |
| 353 | DISALLOW_COPY_AND_ASSIGN(LocationsBuilderARM64); |
| 354 | }; |
| 355 | |
Zheng Xu | ad4450e | 2015-04-17 18:48:56 +0800 | [diff] [blame] | 356 | class ParallelMoveResolverARM64 : public ParallelMoveResolverNoSwap { |
Alexandre Rames | 3e69f16 | 2014-12-10 10:36:50 +0000 | [diff] [blame] | 357 | public: |
| 358 | ParallelMoveResolverARM64(ArenaAllocator* allocator, CodeGeneratorARM64* codegen) |
Zheng Xu | ad4450e | 2015-04-17 18:48:56 +0800 | [diff] [blame] | 359 | : ParallelMoveResolverNoSwap(allocator), codegen_(codegen), vixl_temps_() {} |
Alexandre Rames | 3e69f16 | 2014-12-10 10:36:50 +0000 | [diff] [blame] | 360 | |
Zheng Xu | ad4450e | 2015-04-17 18:48:56 +0800 | [diff] [blame] | 361 | protected: |
| 362 | void PrepareForEmitNativeCode() OVERRIDE; |
| 363 | void FinishEmitNativeCode() OVERRIDE; |
| 364 | Location AllocateScratchLocationFor(Location::Kind kind) OVERRIDE; |
| 365 | void FreeScratchLocation(Location loc) OVERRIDE; |
Alexandre Rames | 3e69f16 | 2014-12-10 10:36:50 +0000 | [diff] [blame] | 366 | void EmitMove(size_t index) OVERRIDE; |
Alexandre Rames | 3e69f16 | 2014-12-10 10:36:50 +0000 | [diff] [blame] | 367 | |
| 368 | private: |
| 369 | Arm64Assembler* GetAssembler() const; |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 370 | vixl::aarch64::MacroAssembler* GetVIXLAssembler() const { |
Alexandre Rames | 087930f | 2016-08-02 13:45:28 +0100 | [diff] [blame] | 371 | return GetAssembler()->GetVIXLAssembler(); |
Alexandre Rames | 3e69f16 | 2014-12-10 10:36:50 +0000 | [diff] [blame] | 372 | } |
| 373 | |
| 374 | CodeGeneratorARM64* const codegen_; |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 375 | vixl::aarch64::UseScratchRegisterScope vixl_temps_; |
Alexandre Rames | 3e69f16 | 2014-12-10 10:36:50 +0000 | [diff] [blame] | 376 | |
| 377 | DISALLOW_COPY_AND_ASSIGN(ParallelMoveResolverARM64); |
| 378 | }; |
| 379 | |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 380 | class CodeGeneratorARM64 : public CodeGenerator { |
| 381 | public: |
Serban Constantinescu | 579885a | 2015-02-22 20:51:33 +0000 | [diff] [blame] | 382 | CodeGeneratorARM64(HGraph* graph, |
| 383 | const Arm64InstructionSetFeatures& isa_features, |
Serban Constantinescu | ecc4366 | 2015-08-13 13:33:12 +0100 | [diff] [blame] | 384 | const CompilerOptions& compiler_options, |
| 385 | OptimizingCompilerStats* stats = nullptr); |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 386 | virtual ~CodeGeneratorARM64() {} |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 387 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 388 | void GenerateFrameEntry() OVERRIDE; |
| 389 | void GenerateFrameExit() OVERRIDE; |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 390 | |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 391 | vixl::aarch64::CPURegList GetFramePreservedCoreRegisters() const; |
| 392 | vixl::aarch64::CPURegList GetFramePreservedFPRegisters() const; |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 393 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 394 | void Bind(HBasicBlock* block) OVERRIDE; |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 395 | |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 396 | vixl::aarch64::Label* GetLabelOf(HBasicBlock* block) { |
Alexandre Rames | c01a664 | 2016-04-15 11:54:06 +0100 | [diff] [blame] | 397 | block = FirstNonEmptyBlock(block); |
| 398 | return &(block_labels_[block->GetBlockId()]); |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 399 | } |
| 400 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 401 | size_t GetWordSize() const OVERRIDE { |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 402 | return kArm64WordSize; |
| 403 | } |
| 404 | |
Mark Mendell | f85a9ca | 2015-01-13 09:20:58 -0500 | [diff] [blame] | 405 | size_t GetFloatingPointSpillSlotSize() const OVERRIDE { |
| 406 | // Allocated in D registers, which are word sized. |
| 407 | return kArm64WordSize; |
| 408 | } |
| 409 | |
Alexandre Rames | c01a664 | 2016-04-15 11:54:06 +0100 | [diff] [blame] | 410 | uintptr_t GetAddressOf(HBasicBlock* block) OVERRIDE { |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 411 | vixl::aarch64::Label* block_entry_label = GetLabelOf(block); |
Alexandre Rames | 67555f7 | 2014-11-18 10:55:16 +0000 | [diff] [blame] | 412 | DCHECK(block_entry_label->IsBound()); |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 413 | return block_entry_label->GetLocation(); |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 414 | } |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 415 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 416 | HGraphVisitor* GetLocationBuilder() OVERRIDE { return &location_builder_; } |
| 417 | HGraphVisitor* GetInstructionVisitor() OVERRIDE { return &instruction_visitor_; } |
| 418 | Arm64Assembler* GetAssembler() OVERRIDE { return &assembler_; } |
Alexandre Rames | eb7b739 | 2015-06-19 14:47:01 +0100 | [diff] [blame] | 419 | const Arm64Assembler& GetAssembler() const OVERRIDE { return assembler_; } |
Alexandre Rames | 087930f | 2016-08-02 13:45:28 +0100 | [diff] [blame] | 420 | vixl::aarch64::MacroAssembler* GetVIXLAssembler() { return GetAssembler()->GetVIXLAssembler(); } |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 421 | |
| 422 | // Emit a write barrier. |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 423 | void MarkGCCard(vixl::aarch64::Register object, |
| 424 | vixl::aarch64::Register value, |
| 425 | bool value_can_be_null); |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 426 | |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 427 | void GenerateMemoryBarrier(MemBarrierKind kind); |
| 428 | |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 429 | // Register allocation. |
| 430 | |
David Brazdil | 58282f4 | 2016-01-14 12:45:10 +0000 | [diff] [blame] | 431 | void SetupBlockedRegisters() const OVERRIDE; |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 432 | |
Zheng Xu | da40309 | 2015-04-24 17:35:39 +0800 | [diff] [blame] | 433 | size_t SaveCoreRegister(size_t stack_index, uint32_t reg_id) OVERRIDE; |
| 434 | size_t RestoreCoreRegister(size_t stack_index, uint32_t reg_id) OVERRIDE; |
| 435 | size_t SaveFloatingPointRegister(size_t stack_index, uint32_t reg_id) OVERRIDE; |
| 436 | size_t RestoreFloatingPointRegister(size_t stack_index, uint32_t reg_id) OVERRIDE; |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 437 | |
| 438 | // The number of registers that can be allocated. The register allocator may |
| 439 | // decide to reserve and not use a few of them. |
| 440 | // We do not consider registers sp, xzr, wzr. They are either not allocatable |
| 441 | // (xzr, wzr), or make for poor allocatable registers (sp alignment |
| 442 | // requirements, etc.). This also facilitates our task as all other registers |
| 443 | // can easily be mapped via to or from their type and index or code. |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 444 | static const int kNumberOfAllocatableRegisters = vixl::aarch64::kNumberOfRegisters - 1; |
| 445 | static const int kNumberOfAllocatableFPRegisters = vixl::aarch64::kNumberOfFPRegisters; |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 446 | static constexpr int kNumberOfAllocatableRegisterPairs = 0; |
| 447 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 448 | void DumpCoreRegister(std::ostream& stream, int reg) const OVERRIDE; |
| 449 | void DumpFloatingPointRegister(std::ostream& stream, int reg) const OVERRIDE; |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 450 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 451 | InstructionSet GetInstructionSet() const OVERRIDE { |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 452 | return InstructionSet::kArm64; |
| 453 | } |
| 454 | |
Serban Constantinescu | 579885a | 2015-02-22 20:51:33 +0000 | [diff] [blame] | 455 | const Arm64InstructionSetFeatures& GetInstructionSetFeatures() const { |
| 456 | return isa_features_; |
| 457 | } |
| 458 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 459 | void Initialize() OVERRIDE { |
Alexandre Rames | c01a664 | 2016-04-15 11:54:06 +0100 | [diff] [blame] | 460 | block_labels_.resize(GetGraph()->GetBlocks().size()); |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 461 | } |
| 462 | |
Alexandre Rames | 68bd9b9 | 2016-07-15 17:41:13 +0100 | [diff] [blame] | 463 | // We want to use the STP and LDP instructions to spill and restore registers for slow paths. |
| 464 | // These instructions can only encode offsets that are multiples of the register size accessed. |
Roland Levillain | 71280fc | 2016-07-18 16:03:05 +0100 | [diff] [blame] | 465 | uint32_t GetPreferredSlotsAlignment() const OVERRIDE { return vixl::aarch64::kXRegSizeInBytes; } |
Alexandre Rames | 68bd9b9 | 2016-07-15 17:41:13 +0100 | [diff] [blame] | 466 | |
Alexandre Rames | c01a664 | 2016-04-15 11:54:06 +0100 | [diff] [blame] | 467 | JumpTableARM64* CreateJumpTable(HPackedSwitch* switch_instr) { |
| 468 | jump_tables_.emplace_back(new (GetGraph()->GetArena()) JumpTableARM64(switch_instr)); |
| 469 | return jump_tables_.back().get(); |
Zheng Xu | 3927c8b | 2015-11-18 17:46:25 +0800 | [diff] [blame] | 470 | } |
| 471 | |
Serban Constantinescu | 32f5b4d | 2014-11-25 20:05:46 +0000 | [diff] [blame] | 472 | void Finalize(CodeAllocator* allocator) OVERRIDE; |
| 473 | |
Alexandre Rames | fc19de8 | 2014-11-07 17:13:31 +0000 | [diff] [blame] | 474 | // Code generation helpers. |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 475 | void MoveConstant(vixl::aarch64::CPURegister destination, HConstant* constant); |
Calin Juravle | 175dc73 | 2015-08-25 15:42:32 +0100 | [diff] [blame] | 476 | void MoveConstant(Location destination, int32_t value) OVERRIDE; |
Calin Juravle | e460d1d | 2015-09-29 04:52:17 +0100 | [diff] [blame] | 477 | void MoveLocation(Location dst, Location src, Primitive::Type dst_type) OVERRIDE; |
| 478 | void AddLocationAsTemp(Location location, LocationSummary* locations) OVERRIDE; |
| 479 | |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 480 | void Load(Primitive::Type type, |
| 481 | vixl::aarch64::CPURegister dst, |
| 482 | const vixl::aarch64::MemOperand& src); |
| 483 | void Store(Primitive::Type type, |
| 484 | vixl::aarch64::CPURegister src, |
| 485 | const vixl::aarch64::MemOperand& dst); |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 486 | void LoadAcquire(HInstruction* instruction, |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 487 | vixl::aarch64::CPURegister dst, |
| 488 | const vixl::aarch64::MemOperand& src, |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 489 | bool needs_null_check); |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 490 | void StoreRelease(Primitive::Type type, |
| 491 | vixl::aarch64::CPURegister src, |
| 492 | const vixl::aarch64::MemOperand& dst); |
Alexandre Rames | 67555f7 | 2014-11-18 10:55:16 +0000 | [diff] [blame] | 493 | |
| 494 | // Generate code to invoke a runtime entry point. |
Calin Juravle | 175dc73 | 2015-08-25 15:42:32 +0100 | [diff] [blame] | 495 | void InvokeRuntime(QuickEntrypointEnum entrypoint, |
| 496 | HInstruction* instruction, |
| 497 | uint32_t dex_pc, |
Serban Constantinescu | 22f81d3 | 2016-02-18 16:06:31 +0000 | [diff] [blame] | 498 | SlowPathCode* slow_path = nullptr) OVERRIDE; |
Alexandre Rames | fc19de8 | 2014-11-07 17:13:31 +0000 | [diff] [blame] | 499 | |
Roland Levillain | dec8f63 | 2016-07-22 17:10:06 +0100 | [diff] [blame] | 500 | // Generate code to invoke a runtime entry point, but do not record |
| 501 | // PC-related information in a stack map. |
| 502 | void InvokeRuntimeWithoutRecordingPcInfo(int32_t entry_point_offset, |
| 503 | HInstruction* instruction, |
| 504 | SlowPathCode* slow_path); |
| 505 | |
Serban Constantinescu | 22f81d3 | 2016-02-18 16:06:31 +0000 | [diff] [blame] | 506 | void GenerateInvokeRuntime(int32_t entry_point_offset); |
| 507 | |
Alexandre Rames | e6dbf48 | 2015-10-19 10:10:41 +0100 | [diff] [blame] | 508 | ParallelMoveResolverARM64* GetMoveResolver() OVERRIDE { return &move_resolver_; } |
Nicolas Geoffray | f0e3937 | 2014-11-12 17:50:07 +0000 | [diff] [blame] | 509 | |
Nicolas Geoffray | 840e546 | 2015-01-07 16:01:24 +0000 | [diff] [blame] | 510 | bool NeedsTwoRegisters(Primitive::Type type ATTRIBUTE_UNUSED) const OVERRIDE { |
| 511 | return false; |
| 512 | } |
| 513 | |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 514 | // Check if the desired_string_load_kind is supported. If it is, return it, |
| 515 | // otherwise return a fall-back kind that should be used instead. |
| 516 | HLoadString::LoadKind GetSupportedLoadStringKind( |
| 517 | HLoadString::LoadKind desired_string_load_kind) OVERRIDE; |
| 518 | |
Vladimir Marko | dbb7f5b | 2016-03-30 13:23:58 +0100 | [diff] [blame] | 519 | // Check if the desired_class_load_kind is supported. If it is, return it, |
| 520 | // otherwise return a fall-back kind that should be used instead. |
| 521 | HLoadClass::LoadKind GetSupportedLoadClassKind( |
| 522 | HLoadClass::LoadKind desired_class_load_kind) OVERRIDE; |
| 523 | |
Vladimir Marko | dc151b2 | 2015-10-15 18:02:30 +0100 | [diff] [blame] | 524 | // Check if the desired_dispatch_info is supported. If it is, return it, |
| 525 | // otherwise return a fall-back info that should be used instead. |
| 526 | HInvokeStaticOrDirect::DispatchInfo GetSupportedInvokeStaticOrDirectDispatch( |
| 527 | const HInvokeStaticOrDirect::DispatchInfo& desired_dispatch_info, |
Nicolas Geoffray | 5e4e11e | 2016-09-22 13:17:41 +0100 | [diff] [blame] | 528 | HInvokeStaticOrDirect* invoke) OVERRIDE; |
Vladimir Marko | dc151b2 | 2015-10-15 18:02:30 +0100 | [diff] [blame] | 529 | |
TatWai Chong | d8c052a | 2016-11-02 16:12:48 +0800 | [diff] [blame^] | 530 | Location GenerateCalleeMethodStaticOrDirectCall(HInvokeStaticOrDirect* invoke, Location temp); |
Andreas Gampe | 85b62f2 | 2015-09-09 13:15:38 -0700 | [diff] [blame] | 531 | void GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke, Location temp) OVERRIDE; |
| 532 | void GenerateVirtualCall(HInvokeVirtual* invoke, Location temp) OVERRIDE; |
| 533 | |
| 534 | void MoveFromReturnRegister(Location trg ATTRIBUTE_UNUSED, |
| 535 | Primitive::Type type ATTRIBUTE_UNUSED) OVERRIDE { |
| 536 | UNIMPLEMENTED(FATAL); |
| 537 | } |
Andreas Gampe | 878d58c | 2015-01-15 23:24:00 -0800 | [diff] [blame] | 538 | |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 539 | // Add a new PC-relative string patch for an instruction and return the label |
| 540 | // to be bound before the instruction. The instruction will be either the |
| 541 | // ADRP (pass `adrp_label = null`) or the ADD (pass `adrp_label` pointing |
| 542 | // to the associated ADRP patch label). |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 543 | vixl::aarch64::Label* NewPcRelativeStringPatch(const DexFile& dex_file, |
| 544 | uint32_t string_index, |
| 545 | vixl::aarch64::Label* adrp_label = nullptr); |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 546 | |
Vladimir Marko | dbb7f5b | 2016-03-30 13:23:58 +0100 | [diff] [blame] | 547 | // Add a new PC-relative type patch for an instruction and return the label |
| 548 | // to be bound before the instruction. The instruction will be either the |
| 549 | // ADRP (pass `adrp_label = null`) or the ADD (pass `adrp_label` pointing |
| 550 | // to the associated ADRP patch label). |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 551 | vixl::aarch64::Label* NewPcRelativeTypePatch(const DexFile& dex_file, |
Andreas Gampe | a5b09a6 | 2016-11-17 15:21:22 -0800 | [diff] [blame] | 552 | dex::TypeIndex type_index, |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 553 | vixl::aarch64::Label* adrp_label = nullptr); |
Vladimir Marko | dbb7f5b | 2016-03-30 13:23:58 +0100 | [diff] [blame] | 554 | |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 555 | // Add a new PC-relative dex cache array patch for an instruction and return |
| 556 | // the label to be bound before the instruction. The instruction will be |
| 557 | // either the ADRP (pass `adrp_label = null`) or the LDR (pass `adrp_label` |
| 558 | // pointing to the associated ADRP patch label). |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 559 | vixl::aarch64::Label* NewPcRelativeDexCacheArrayPatch( |
| 560 | const DexFile& dex_file, |
| 561 | uint32_t element_offset, |
| 562 | vixl::aarch64::Label* adrp_label = nullptr); |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 563 | |
Andreas Gampe | 8a0128a | 2016-11-28 07:38:35 -0800 | [diff] [blame] | 564 | vixl::aarch64::Literal<uint32_t>* DeduplicateBootImageStringLiteral( |
| 565 | const DexFile& dex_file, |
| 566 | dex::StringIndex string_index); |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 567 | vixl::aarch64::Literal<uint32_t>* DeduplicateBootImageTypeLiteral(const DexFile& dex_file, |
Andreas Gampe | a5b09a6 | 2016-11-17 15:21:22 -0800 | [diff] [blame] | 568 | dex::TypeIndex type_index); |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 569 | vixl::aarch64::Literal<uint32_t>* DeduplicateBootImageAddressLiteral(uint64_t address); |
Nicolas Geoffray | 132d836 | 2016-11-16 09:19:42 +0000 | [diff] [blame] | 570 | vixl::aarch64::Literal<uint32_t>* DeduplicateJitStringLiteral(const DexFile& dex_file, |
Andreas Gampe | 8a0128a | 2016-11-28 07:38:35 -0800 | [diff] [blame] | 571 | dex::StringIndex string_index); |
Nicolas Geoffray | 22384ae | 2016-12-12 22:33:36 +0000 | [diff] [blame] | 572 | vixl::aarch64::Literal<uint32_t>* DeduplicateJitClassLiteral(const DexFile& dex_file, |
| 573 | dex::TypeIndex string_index, |
| 574 | uint64_t address); |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 575 | |
Vladimir Marko | aad75c6 | 2016-10-03 08:46:48 +0000 | [diff] [blame] | 576 | void EmitAdrpPlaceholder(vixl::aarch64::Label* fixup_label, vixl::aarch64::Register reg); |
| 577 | void EmitAddPlaceholder(vixl::aarch64::Label* fixup_label, |
| 578 | vixl::aarch64::Register out, |
| 579 | vixl::aarch64::Register base); |
| 580 | void EmitLdrOffsetPlaceholder(vixl::aarch64::Label* fixup_label, |
| 581 | vixl::aarch64::Register out, |
| 582 | vixl::aarch64::Register base); |
| 583 | |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 584 | void EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches) OVERRIDE; |
| 585 | |
Nicolas Geoffray | 132d836 | 2016-11-16 09:19:42 +0000 | [diff] [blame] | 586 | void EmitJitRootPatches(uint8_t* code, const uint8_t* roots_data) OVERRIDE; |
| 587 | |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 588 | // Fast path implementation of ReadBarrier::Barrier for a heap |
| 589 | // reference field load when Baker's read barriers are used. |
| 590 | void GenerateFieldLoadWithBakerReadBarrier(HInstruction* instruction, |
| 591 | Location ref, |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 592 | vixl::aarch64::Register obj, |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 593 | uint32_t offset, |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 594 | vixl::aarch64::Register temp, |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 595 | bool needs_null_check, |
| 596 | bool use_load_acquire); |
| 597 | // Fast path implementation of ReadBarrier::Barrier for a heap |
| 598 | // reference array load when Baker's read barriers are used. |
| 599 | void GenerateArrayLoadWithBakerReadBarrier(HInstruction* instruction, |
| 600 | Location ref, |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 601 | vixl::aarch64::Register obj, |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 602 | uint32_t data_offset, |
| 603 | Location index, |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 604 | vixl::aarch64::Register temp, |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 605 | bool needs_null_check); |
Roland Levillain | bfea335 | 2016-06-23 13:48:47 +0100 | [diff] [blame] | 606 | // Factored implementation used by GenerateFieldLoadWithBakerReadBarrier |
| 607 | // and GenerateArrayLoadWithBakerReadBarrier. |
Roland Levillain | a1aa3b1 | 2016-10-26 13:03:38 +0100 | [diff] [blame] | 608 | // |
| 609 | // Load the object reference located at the address |
| 610 | // `obj + offset + (index << scale_factor)`, held by object `obj`, into |
| 611 | // `ref`, and mark it if needed. |
| 612 | // |
| 613 | // If `always_update_field` is true, the value of the reference is |
| 614 | // atomically updated in the holder (`obj`). |
Roland Levillain | bfea335 | 2016-06-23 13:48:47 +0100 | [diff] [blame] | 615 | void GenerateReferenceLoadWithBakerReadBarrier(HInstruction* instruction, |
| 616 | Location ref, |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 617 | vixl::aarch64::Register obj, |
Roland Levillain | bfea335 | 2016-06-23 13:48:47 +0100 | [diff] [blame] | 618 | uint32_t offset, |
| 619 | Location index, |
| 620 | size_t scale_factor, |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 621 | vixl::aarch64::Register temp, |
Roland Levillain | bfea335 | 2016-06-23 13:48:47 +0100 | [diff] [blame] | 622 | bool needs_null_check, |
Roland Levillain | a1aa3b1 | 2016-10-26 13:03:38 +0100 | [diff] [blame] | 623 | bool use_load_acquire, |
| 624 | bool always_update_field = false); |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 625 | |
| 626 | // Generate a read barrier for a heap reference within `instruction` |
| 627 | // using a slow path. |
Roland Levillain | 22ccc3a | 2015-11-24 13:10:05 +0000 | [diff] [blame] | 628 | // |
| 629 | // A read barrier for an object reference read from the heap is |
| 630 | // implemented as a call to the artReadBarrierSlow runtime entry |
| 631 | // point, which is passed the values in locations `ref`, `obj`, and |
| 632 | // `offset`: |
| 633 | // |
| 634 | // mirror::Object* artReadBarrierSlow(mirror::Object* ref, |
| 635 | // mirror::Object* obj, |
| 636 | // uint32_t offset); |
| 637 | // |
| 638 | // The `out` location contains the value returned by |
| 639 | // artReadBarrierSlow. |
| 640 | // |
| 641 | // When `index` is provided (i.e. for array accesses), the offset |
| 642 | // value passed to artReadBarrierSlow is adjusted to take `index` |
| 643 | // into account. |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 644 | void GenerateReadBarrierSlow(HInstruction* instruction, |
| 645 | Location out, |
| 646 | Location ref, |
| 647 | Location obj, |
| 648 | uint32_t offset, |
| 649 | Location index = Location::NoLocation()); |
Roland Levillain | 22ccc3a | 2015-11-24 13:10:05 +0000 | [diff] [blame] | 650 | |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 651 | // If read barriers are enabled, generate a read barrier for a heap |
| 652 | // reference using a slow path. If heap poisoning is enabled, also |
| 653 | // unpoison the reference in `out`. |
| 654 | void MaybeGenerateReadBarrierSlow(HInstruction* instruction, |
| 655 | Location out, |
| 656 | Location ref, |
| 657 | Location obj, |
| 658 | uint32_t offset, |
| 659 | Location index = Location::NoLocation()); |
Roland Levillain | 22ccc3a | 2015-11-24 13:10:05 +0000 | [diff] [blame] | 660 | |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 661 | // Generate a read barrier for a GC root within `instruction` using |
| 662 | // a slow path. |
Roland Levillain | 22ccc3a | 2015-11-24 13:10:05 +0000 | [diff] [blame] | 663 | // |
| 664 | // A read barrier for an object reference GC root is implemented as |
| 665 | // a call to the artReadBarrierForRootSlow runtime entry point, |
| 666 | // which is passed the value in location `root`: |
| 667 | // |
| 668 | // mirror::Object* artReadBarrierForRootSlow(GcRoot<mirror::Object>* root); |
| 669 | // |
| 670 | // The `out` location contains the value returned by |
| 671 | // artReadBarrierForRootSlow. |
Roland Levillain | 4401586 | 2016-01-22 11:47:17 +0000 | [diff] [blame] | 672 | void GenerateReadBarrierForRootSlow(HInstruction* instruction, Location out, Location root); |
Roland Levillain | 22ccc3a | 2015-11-24 13:10:05 +0000 | [diff] [blame] | 673 | |
Roland Levillain | f41f956 | 2016-09-14 19:26:48 +0100 | [diff] [blame] | 674 | void GenerateNop() OVERRIDE; |
David Srbecky | c7098ff | 2016-02-09 14:30:11 +0000 | [diff] [blame] | 675 | |
Roland Levillain | f41f956 | 2016-09-14 19:26:48 +0100 | [diff] [blame] | 676 | void GenerateImplicitNullCheck(HNullCheck* instruction) OVERRIDE; |
| 677 | void GenerateExplicitNullCheck(HNullCheck* instruction) OVERRIDE; |
Calin Juravle | 2ae4818 | 2016-03-16 14:05:09 +0000 | [diff] [blame] | 678 | |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 679 | private: |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 680 | using Uint64ToLiteralMap = ArenaSafeMap<uint64_t, vixl::aarch64::Literal<uint64_t>*>; |
| 681 | using Uint32ToLiteralMap = ArenaSafeMap<uint32_t, vixl::aarch64::Literal<uint32_t>*>; |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 682 | using MethodToLiteralMap = ArenaSafeMap<MethodReference, |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 683 | vixl::aarch64::Literal<uint64_t>*, |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 684 | MethodReferenceComparator>; |
Nicolas Geoffray | 132d836 | 2016-11-16 09:19:42 +0000 | [diff] [blame] | 685 | using StringToLiteralMap = ArenaSafeMap<StringReference, |
| 686 | vixl::aarch64::Literal<uint32_t>*, |
| 687 | StringReferenceValueComparator>; |
Nicolas Geoffray | 22384ae | 2016-12-12 22:33:36 +0000 | [diff] [blame] | 688 | using TypeToLiteralMap = ArenaSafeMap<TypeReference, |
| 689 | vixl::aarch64::Literal<uint32_t>*, |
| 690 | TypeReferenceValueComparator>; |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 691 | |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 692 | vixl::aarch64::Literal<uint32_t>* DeduplicateUint32Literal(uint32_t value, |
| 693 | Uint32ToLiteralMap* map); |
| 694 | vixl::aarch64::Literal<uint64_t>* DeduplicateUint64Literal(uint64_t value); |
| 695 | vixl::aarch64::Literal<uint64_t>* DeduplicateMethodLiteral(MethodReference target_method, |
| 696 | MethodToLiteralMap* map); |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 697 | |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 698 | // The PcRelativePatchInfo is used for PC-relative addressing of dex cache arrays |
Vladimir Marko | dbb7f5b | 2016-03-30 13:23:58 +0100 | [diff] [blame] | 699 | // and boot image strings/types. The only difference is the interpretation of the |
| 700 | // offset_or_index. |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 701 | struct PcRelativePatchInfo { |
| 702 | PcRelativePatchInfo(const DexFile& dex_file, uint32_t off_or_idx) |
| 703 | : target_dex_file(dex_file), offset_or_index(off_or_idx), label(), pc_insn_label() { } |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 704 | |
| 705 | const DexFile& target_dex_file; |
Vladimir Marko | dbb7f5b | 2016-03-30 13:23:58 +0100 | [diff] [blame] | 706 | // Either the dex cache array element offset or the string/type index. |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 707 | uint32_t offset_or_index; |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 708 | vixl::aarch64::Label label; |
| 709 | vixl::aarch64::Label* pc_insn_label; |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 710 | }; |
| 711 | |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 712 | vixl::aarch64::Label* NewPcRelativePatch(const DexFile& dex_file, |
| 713 | uint32_t offset_or_index, |
| 714 | vixl::aarch64::Label* adrp_label, |
| 715 | ArenaDeque<PcRelativePatchInfo>* patches); |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 716 | |
Zheng Xu | 3927c8b | 2015-11-18 17:46:25 +0800 | [diff] [blame] | 717 | void EmitJumpTables(); |
| 718 | |
Vladimir Marko | aad75c6 | 2016-10-03 08:46:48 +0000 | [diff] [blame] | 719 | template <LinkerPatch (*Factory)(size_t, const DexFile*, uint32_t, uint32_t)> |
| 720 | static void EmitPcRelativeLinkerPatches(const ArenaDeque<PcRelativePatchInfo>& infos, |
| 721 | ArenaVector<LinkerPatch>* linker_patches); |
| 722 | |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 723 | // Labels for each block that will be compiled. |
Scott Wakeling | 97c72b7 | 2016-06-24 16:19:36 +0100 | [diff] [blame] | 724 | // We use a deque so that the `vixl::aarch64::Label` objects do not move in memory. |
| 725 | ArenaDeque<vixl::aarch64::Label> block_labels_; // Indexed by block id. |
| 726 | vixl::aarch64::Label frame_entry_label_; |
Alexandre Rames | c01a664 | 2016-04-15 11:54:06 +0100 | [diff] [blame] | 727 | ArenaVector<std::unique_ptr<JumpTableARM64>> jump_tables_; |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 728 | |
| 729 | LocationsBuilderARM64 location_builder_; |
| 730 | InstructionCodeGeneratorARM64 instruction_visitor_; |
Alexandre Rames | 3e69f16 | 2014-12-10 10:36:50 +0000 | [diff] [blame] | 731 | ParallelMoveResolverARM64 move_resolver_; |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 732 | Arm64Assembler assembler_; |
Serban Constantinescu | 579885a | 2015-02-22 20:51:33 +0000 | [diff] [blame] | 733 | const Arm64InstructionSetFeatures& isa_features_; |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 734 | |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 735 | // Deduplication map for 32-bit literals, used for non-patchable boot image addresses. |
| 736 | Uint32ToLiteralMap uint32_literals_; |
Vladimir Marko | 0f0829b | 2016-12-13 13:50:14 +0000 | [diff] [blame] | 737 | // Deduplication map for 64-bit literals, used for non-patchable method address or method code. |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 738 | Uint64ToLiteralMap uint64_literals_; |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 739 | // PC-relative DexCache access info. |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 740 | ArenaDeque<PcRelativePatchInfo> pc_relative_dex_cache_patches_; |
| 741 | // Deduplication map for boot string literals for kBootImageLinkTimeAddress. |
Nicolas Geoffray | 132d836 | 2016-11-16 09:19:42 +0000 | [diff] [blame] | 742 | StringToLiteralMap boot_image_string_patches_; |
Vladimir Marko | aad75c6 | 2016-10-03 08:46:48 +0000 | [diff] [blame] | 743 | // PC-relative String patch info; type depends on configuration (app .bss or boot image PIC). |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 744 | ArenaDeque<PcRelativePatchInfo> pc_relative_string_patches_; |
Vladimir Marko | dbb7f5b | 2016-03-30 13:23:58 +0100 | [diff] [blame] | 745 | // Deduplication map for boot type literals for kBootImageLinkTimeAddress. |
Nicolas Geoffray | 22384ae | 2016-12-12 22:33:36 +0000 | [diff] [blame] | 746 | TypeToLiteralMap boot_image_type_patches_; |
Vladimir Marko | dbb7f5b | 2016-03-30 13:23:58 +0100 | [diff] [blame] | 747 | // PC-relative type patch info. |
| 748 | ArenaDeque<PcRelativePatchInfo> pc_relative_type_patches_; |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 749 | // Deduplication map for patchable boot image addresses. |
| 750 | Uint32ToLiteralMap boot_image_address_patches_; |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 751 | |
Nicolas Geoffray | 132d836 | 2016-11-16 09:19:42 +0000 | [diff] [blame] | 752 | // Patches for string literals in JIT compiled code. |
| 753 | StringToLiteralMap jit_string_patches_; |
Nicolas Geoffray | 22384ae | 2016-12-12 22:33:36 +0000 | [diff] [blame] | 754 | // Patches for class literals in JIT compiled code. |
| 755 | TypeToLiteralMap jit_class_patches_; |
Nicolas Geoffray | 132d836 | 2016-11-16 09:19:42 +0000 | [diff] [blame] | 756 | |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 757 | DISALLOW_COPY_AND_ASSIGN(CodeGeneratorARM64); |
| 758 | }; |
| 759 | |
Alexandre Rames | 3e69f16 | 2014-12-10 10:36:50 +0000 | [diff] [blame] | 760 | inline Arm64Assembler* ParallelMoveResolverARM64::GetAssembler() const { |
| 761 | return codegen_->GetAssembler(); |
| 762 | } |
| 763 | |
Alexandre Rames | 5319def | 2014-10-23 10:03:10 +0100 | [diff] [blame] | 764 | } // namespace arm64 |
| 765 | } // namespace art |
| 766 | |
| 767 | #endif // ART_COMPILER_OPTIMIZING_CODE_GENERATOR_ARM64_H_ |