Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2015 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_MIPS_H_ |
| 18 | #define ART_COMPILER_OPTIMIZING_CODE_GENERATOR_MIPS_H_ |
| 19 | |
| 20 | #include "code_generator.h" |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 21 | #include "driver/compiler_options.h" |
| 22 | #include "nodes.h" |
| 23 | #include "parallel_move_resolver.h" |
Alexey Frunze | 06a46c4 | 2016-07-19 15:00:40 -0700 | [diff] [blame] | 24 | #include "string_reference.h" |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 25 | #include "utils/mips/assembler_mips.h" |
Alexey Frunze | 06a46c4 | 2016-07-19 15:00:40 -0700 | [diff] [blame] | 26 | #include "utils/type_reference.h" |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 27 | |
| 28 | namespace art { |
| 29 | namespace mips { |
| 30 | |
| 31 | // InvokeDexCallingConvention registers |
| 32 | |
| 33 | static constexpr Register kParameterCoreRegisters[] = |
| 34 | { A1, A2, A3 }; |
| 35 | static constexpr size_t kParameterCoreRegistersLength = arraysize(kParameterCoreRegisters); |
| 36 | |
| 37 | static constexpr FRegister kParameterFpuRegisters[] = |
| 38 | { F12, F14 }; |
| 39 | static constexpr size_t kParameterFpuRegistersLength = arraysize(kParameterFpuRegisters); |
| 40 | |
| 41 | |
| 42 | // InvokeRuntimeCallingConvention registers |
| 43 | |
| 44 | static constexpr Register kRuntimeParameterCoreRegisters[] = |
| 45 | { A0, A1, A2, A3 }; |
| 46 | static constexpr size_t kRuntimeParameterCoreRegistersLength = |
| 47 | arraysize(kRuntimeParameterCoreRegisters); |
| 48 | |
| 49 | static constexpr FRegister kRuntimeParameterFpuRegisters[] = |
| 50 | { F12, F14}; |
| 51 | static constexpr size_t kRuntimeParameterFpuRegistersLength = |
| 52 | arraysize(kRuntimeParameterFpuRegisters); |
| 53 | |
| 54 | |
| 55 | static constexpr Register kCoreCalleeSaves[] = |
| 56 | { S0, S1, S2, S3, S4, S5, S6, S7, FP, RA }; |
| 57 | static constexpr FRegister kFpuCalleeSaves[] = |
| 58 | { F20, F22, F24, F26, F28, F30 }; |
| 59 | |
| 60 | |
| 61 | class CodeGeneratorMIPS; |
| 62 | |
| 63 | class InvokeDexCallingConvention : public CallingConvention<Register, FRegister> { |
| 64 | public: |
| 65 | InvokeDexCallingConvention() |
| 66 | : CallingConvention(kParameterCoreRegisters, |
| 67 | kParameterCoreRegistersLength, |
| 68 | kParameterFpuRegisters, |
| 69 | kParameterFpuRegistersLength, |
| 70 | kMipsPointerSize) {} |
| 71 | |
| 72 | private: |
| 73 | DISALLOW_COPY_AND_ASSIGN(InvokeDexCallingConvention); |
| 74 | }; |
| 75 | |
| 76 | class InvokeDexCallingConventionVisitorMIPS : public InvokeDexCallingConventionVisitor { |
| 77 | public: |
| 78 | InvokeDexCallingConventionVisitorMIPS() {} |
| 79 | virtual ~InvokeDexCallingConventionVisitorMIPS() {} |
| 80 | |
| 81 | Location GetNextLocation(Primitive::Type type) OVERRIDE; |
| 82 | Location GetReturnLocation(Primitive::Type type) const OVERRIDE; |
| 83 | Location GetMethodLocation() const OVERRIDE; |
| 84 | |
| 85 | private: |
| 86 | InvokeDexCallingConvention calling_convention; |
| 87 | |
| 88 | DISALLOW_COPY_AND_ASSIGN(InvokeDexCallingConventionVisitorMIPS); |
| 89 | }; |
| 90 | |
| 91 | class InvokeRuntimeCallingConvention : public CallingConvention<Register, FRegister> { |
| 92 | public: |
| 93 | InvokeRuntimeCallingConvention() |
| 94 | : CallingConvention(kRuntimeParameterCoreRegisters, |
| 95 | kRuntimeParameterCoreRegistersLength, |
| 96 | kRuntimeParameterFpuRegisters, |
| 97 | kRuntimeParameterFpuRegistersLength, |
| 98 | kMipsPointerSize) {} |
| 99 | |
| 100 | Location GetReturnLocation(Primitive::Type return_type); |
| 101 | |
| 102 | private: |
| 103 | DISALLOW_COPY_AND_ASSIGN(InvokeRuntimeCallingConvention); |
| 104 | }; |
| 105 | |
| 106 | class FieldAccessCallingConventionMIPS : public FieldAccessCallingConvention { |
| 107 | public: |
| 108 | FieldAccessCallingConventionMIPS() {} |
| 109 | |
| 110 | Location GetObjectLocation() const OVERRIDE { |
| 111 | return Location::RegisterLocation(A1); |
| 112 | } |
| 113 | Location GetFieldIndexLocation() const OVERRIDE { |
| 114 | return Location::RegisterLocation(A0); |
| 115 | } |
| 116 | Location GetReturnLocation(Primitive::Type type) const OVERRIDE { |
| 117 | return Primitive::Is64BitType(type) |
| 118 | ? Location::RegisterPairLocation(V0, V1) |
| 119 | : Location::RegisterLocation(V0); |
| 120 | } |
| 121 | Location GetSetValueLocation(Primitive::Type type, bool is_instance) const OVERRIDE { |
| 122 | return Primitive::Is64BitType(type) |
| 123 | ? Location::RegisterPairLocation(A2, A3) |
| 124 | : (is_instance ? Location::RegisterLocation(A2) : Location::RegisterLocation(A1)); |
| 125 | } |
| 126 | Location GetFpuLocation(Primitive::Type type ATTRIBUTE_UNUSED) const OVERRIDE { |
| 127 | return Location::FpuRegisterLocation(F0); |
| 128 | } |
| 129 | |
| 130 | private: |
| 131 | DISALLOW_COPY_AND_ASSIGN(FieldAccessCallingConventionMIPS); |
| 132 | }; |
| 133 | |
| 134 | class ParallelMoveResolverMIPS : public ParallelMoveResolverWithSwap { |
| 135 | public: |
| 136 | ParallelMoveResolverMIPS(ArenaAllocator* allocator, CodeGeneratorMIPS* codegen) |
| 137 | : ParallelMoveResolverWithSwap(allocator), codegen_(codegen) {} |
| 138 | |
| 139 | void EmitMove(size_t index) OVERRIDE; |
| 140 | void EmitSwap(size_t index) OVERRIDE; |
| 141 | void SpillScratch(int reg) OVERRIDE; |
| 142 | void RestoreScratch(int reg) OVERRIDE; |
| 143 | |
| 144 | void Exchange(int index1, int index2, bool double_slot); |
| 145 | |
| 146 | MipsAssembler* GetAssembler() const; |
| 147 | |
| 148 | private: |
| 149 | CodeGeneratorMIPS* const codegen_; |
| 150 | |
| 151 | DISALLOW_COPY_AND_ASSIGN(ParallelMoveResolverMIPS); |
| 152 | }; |
| 153 | |
| 154 | class SlowPathCodeMIPS : public SlowPathCode { |
| 155 | public: |
David Srbecky | 9cd6d37 | 2016-02-09 15:24:47 +0000 | [diff] [blame] | 156 | explicit SlowPathCodeMIPS(HInstruction* instruction) |
| 157 | : SlowPathCode(instruction), entry_label_(), exit_label_() {} |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 158 | |
| 159 | MipsLabel* GetEntryLabel() { return &entry_label_; } |
| 160 | MipsLabel* GetExitLabel() { return &exit_label_; } |
| 161 | |
| 162 | private: |
| 163 | MipsLabel entry_label_; |
| 164 | MipsLabel exit_label_; |
| 165 | |
| 166 | DISALLOW_COPY_AND_ASSIGN(SlowPathCodeMIPS); |
| 167 | }; |
| 168 | |
| 169 | class LocationsBuilderMIPS : public HGraphVisitor { |
| 170 | public: |
| 171 | LocationsBuilderMIPS(HGraph* graph, CodeGeneratorMIPS* codegen) |
| 172 | : HGraphVisitor(graph), codegen_(codegen) {} |
| 173 | |
| 174 | #define DECLARE_VISIT_INSTRUCTION(name, super) \ |
| 175 | void Visit##name(H##name* instr) OVERRIDE; |
| 176 | |
| 177 | FOR_EACH_CONCRETE_INSTRUCTION_COMMON(DECLARE_VISIT_INSTRUCTION) |
| 178 | FOR_EACH_CONCRETE_INSTRUCTION_MIPS(DECLARE_VISIT_INSTRUCTION) |
| 179 | |
| 180 | #undef DECLARE_VISIT_INSTRUCTION |
| 181 | |
| 182 | void VisitInstruction(HInstruction* instruction) OVERRIDE { |
| 183 | LOG(FATAL) << "Unreachable instruction " << instruction->DebugName() |
| 184 | << " (id " << instruction->GetId() << ")"; |
| 185 | } |
| 186 | |
| 187 | private: |
| 188 | void HandleInvoke(HInvoke* invoke); |
| 189 | void HandleBinaryOp(HBinaryOperation* operation); |
Vladimir Marko | 5f7b58e | 2015-11-23 19:49:34 +0000 | [diff] [blame] | 190 | void HandleCondition(HCondition* instruction); |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 191 | void HandleShift(HBinaryOperation* operation); |
| 192 | void HandleFieldSet(HInstruction* instruction, const FieldInfo& field_info); |
| 193 | void HandleFieldGet(HInstruction* instruction, const FieldInfo& field_info); |
| 194 | |
| 195 | InvokeDexCallingConventionVisitorMIPS parameter_visitor_; |
| 196 | |
| 197 | CodeGeneratorMIPS* const codegen_; |
| 198 | |
| 199 | DISALLOW_COPY_AND_ASSIGN(LocationsBuilderMIPS); |
| 200 | }; |
| 201 | |
Aart Bik | 42249c3 | 2016-01-07 15:33:50 -0800 | [diff] [blame] | 202 | class InstructionCodeGeneratorMIPS : public InstructionCodeGenerator { |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 203 | public: |
| 204 | InstructionCodeGeneratorMIPS(HGraph* graph, CodeGeneratorMIPS* codegen); |
| 205 | |
| 206 | #define DECLARE_VISIT_INSTRUCTION(name, super) \ |
| 207 | void Visit##name(H##name* instr) OVERRIDE; |
| 208 | |
| 209 | FOR_EACH_CONCRETE_INSTRUCTION_COMMON(DECLARE_VISIT_INSTRUCTION) |
| 210 | FOR_EACH_CONCRETE_INSTRUCTION_MIPS(DECLARE_VISIT_INSTRUCTION) |
| 211 | |
| 212 | #undef DECLARE_VISIT_INSTRUCTION |
| 213 | |
| 214 | void VisitInstruction(HInstruction* instruction) OVERRIDE { |
| 215 | LOG(FATAL) << "Unreachable instruction " << instruction->DebugName() |
| 216 | << " (id " << instruction->GetId() << ")"; |
| 217 | } |
| 218 | |
| 219 | MipsAssembler* GetAssembler() const { return assembler_; } |
| 220 | |
| 221 | private: |
| 222 | void GenerateClassInitializationCheck(SlowPathCodeMIPS* slow_path, Register class_reg); |
| 223 | void GenerateMemoryBarrier(MemBarrierKind kind); |
| 224 | void GenerateSuspendCheck(HSuspendCheck* check, HBasicBlock* successor); |
| 225 | void HandleBinaryOp(HBinaryOperation* operation); |
Vladimir Marko | 5f7b58e | 2015-11-23 19:49:34 +0000 | [diff] [blame] | 226 | void HandleCondition(HCondition* instruction); |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 227 | void HandleShift(HBinaryOperation* operation); |
| 228 | void HandleFieldSet(HInstruction* instruction, const FieldInfo& field_info, uint32_t dex_pc); |
| 229 | void HandleFieldGet(HInstruction* instruction, const FieldInfo& field_info, uint32_t dex_pc); |
Alexey Frunze | 06a46c4 | 2016-07-19 15:00:40 -0700 | [diff] [blame] | 230 | // Generate a GC root reference load: |
| 231 | // |
| 232 | // root <- *(obj + offset) |
| 233 | // |
| 234 | // while honoring read barriers (if any). |
| 235 | void GenerateGcRootFieldLoad(HInstruction* instruction, |
| 236 | Location root, |
| 237 | Register obj, |
| 238 | uint32_t offset); |
Alexey Frunze | cd7b0ee | 2015-12-03 16:46:38 -0800 | [diff] [blame] | 239 | void GenerateIntCompare(IfCondition cond, LocationSummary* locations); |
| 240 | void GenerateIntCompareAndBranch(IfCondition cond, |
| 241 | LocationSummary* locations, |
| 242 | MipsLabel* label); |
| 243 | void GenerateLongCompareAndBranch(IfCondition cond, |
| 244 | LocationSummary* locations, |
| 245 | MipsLabel* label); |
| 246 | void GenerateFpCompareAndBranch(IfCondition cond, |
| 247 | bool gt_bias, |
| 248 | Primitive::Type type, |
| 249 | LocationSummary* locations, |
| 250 | MipsLabel* label); |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 251 | void GenerateTestAndBranch(HInstruction* instruction, |
David Brazdil | 0debae7 | 2015-11-12 18:37:00 +0000 | [diff] [blame] | 252 | size_t condition_input_index, |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 253 | MipsLabel* true_target, |
David Brazdil | 0debae7 | 2015-11-12 18:37:00 +0000 | [diff] [blame] | 254 | MipsLabel* false_target); |
Alexey Frunze | 7e99e05 | 2015-11-24 19:28:01 -0800 | [diff] [blame] | 255 | void DivRemOneOrMinusOne(HBinaryOperation* instruction); |
| 256 | void DivRemByPowerOfTwo(HBinaryOperation* instruction); |
| 257 | void GenerateDivRemWithAnyConstant(HBinaryOperation* instruction); |
| 258 | void GenerateDivRemIntegral(HBinaryOperation* instruction); |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 259 | void HandleGoto(HInstruction* got, HBasicBlock* successor); |
Alexey Frunze | 2923db7 | 2016-08-20 01:55:47 -0700 | [diff] [blame] | 260 | auto GetImplicitNullChecker(HInstruction* instruction); |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 261 | |
| 262 | MipsAssembler* const assembler_; |
| 263 | CodeGeneratorMIPS* const codegen_; |
| 264 | |
| 265 | DISALLOW_COPY_AND_ASSIGN(InstructionCodeGeneratorMIPS); |
| 266 | }; |
| 267 | |
| 268 | class CodeGeneratorMIPS : public CodeGenerator { |
| 269 | public: |
| 270 | CodeGeneratorMIPS(HGraph* graph, |
| 271 | const MipsInstructionSetFeatures& isa_features, |
| 272 | const CompilerOptions& compiler_options, |
| 273 | OptimizingCompilerStats* stats = nullptr); |
| 274 | virtual ~CodeGeneratorMIPS() {} |
| 275 | |
Alexey Frunze | 73296a7 | 2016-06-03 22:51:46 -0700 | [diff] [blame] | 276 | void ComputeSpillMask() OVERRIDE; |
Alexey Frunze | 58320ce | 2016-08-30 21:40:46 -0700 | [diff] [blame] | 277 | bool HasAllocatedCalleeSaveRegisters() const OVERRIDE; |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 278 | void GenerateFrameEntry() OVERRIDE; |
| 279 | void GenerateFrameExit() OVERRIDE; |
| 280 | |
| 281 | void Bind(HBasicBlock* block) OVERRIDE; |
| 282 | |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 283 | void Move32(Location destination, Location source); |
| 284 | void Move64(Location destination, Location source); |
| 285 | void MoveConstant(Location location, HConstant* c); |
| 286 | |
| 287 | size_t GetWordSize() const OVERRIDE { return kMipsWordSize; } |
| 288 | |
| 289 | size_t GetFloatingPointSpillSlotSize() const OVERRIDE { return kMipsDoublewordSize; } |
| 290 | |
Alexandre Rames | c01a664 | 2016-04-15 11:54:06 +0100 | [diff] [blame] | 291 | uintptr_t GetAddressOf(HBasicBlock* block) OVERRIDE { |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 292 | return assembler_.GetLabelLocation(GetLabelOf(block)); |
| 293 | } |
| 294 | |
| 295 | HGraphVisitor* GetLocationBuilder() OVERRIDE { return &location_builder_; } |
| 296 | HGraphVisitor* GetInstructionVisitor() OVERRIDE { return &instruction_visitor_; } |
| 297 | MipsAssembler* GetAssembler() OVERRIDE { return &assembler_; } |
| 298 | const MipsAssembler& GetAssembler() const OVERRIDE { return assembler_; } |
| 299 | |
Alexey Frunze | e3fb245 | 2016-05-10 16:08:05 -0700 | [diff] [blame] | 300 | // Emit linker patches. |
| 301 | void EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches) OVERRIDE; |
| 302 | |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 303 | void MarkGCCard(Register object, Register value); |
| 304 | |
| 305 | // Register allocation. |
| 306 | |
David Brazdil | 58282f4 | 2016-01-14 12:45:10 +0000 | [diff] [blame] | 307 | void SetupBlockedRegisters() const OVERRIDE; |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 308 | |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 309 | size_t SaveCoreRegister(size_t stack_index, uint32_t reg_id); |
| 310 | size_t RestoreCoreRegister(size_t stack_index, uint32_t reg_id); |
| 311 | size_t SaveFloatingPointRegister(size_t stack_index, uint32_t reg_id); |
| 312 | size_t RestoreFloatingPointRegister(size_t stack_index, uint32_t reg_id); |
Alexey Frunze | 06a46c4 | 2016-07-19 15:00:40 -0700 | [diff] [blame] | 313 | void ClobberRA() { |
| 314 | clobbered_ra_ = true; |
| 315 | } |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 316 | |
| 317 | void DumpCoreRegister(std::ostream& stream, int reg) const OVERRIDE; |
| 318 | void DumpFloatingPointRegister(std::ostream& stream, int reg) const OVERRIDE; |
| 319 | |
| 320 | // Blocks all register pairs made out of blocked core registers. |
| 321 | void UpdateBlockedPairRegisters() const; |
| 322 | |
| 323 | InstructionSet GetInstructionSet() const OVERRIDE { return InstructionSet::kMips; } |
| 324 | |
| 325 | const MipsInstructionSetFeatures& GetInstructionSetFeatures() const { |
| 326 | return isa_features_; |
| 327 | } |
| 328 | |
| 329 | MipsLabel* GetLabelOf(HBasicBlock* block) const { |
| 330 | return CommonGetLabelOf<MipsLabel>(block_labels_, block); |
| 331 | } |
| 332 | |
| 333 | void Initialize() OVERRIDE { |
| 334 | block_labels_ = CommonInitializeLabels<MipsLabel>(); |
| 335 | } |
| 336 | |
| 337 | void Finalize(CodeAllocator* allocator) OVERRIDE; |
| 338 | |
| 339 | // Code generation helpers. |
| 340 | |
| 341 | void MoveLocation(Location dst, Location src, Primitive::Type dst_type) OVERRIDE; |
| 342 | |
| 343 | void MoveConstant(Location destination, int32_t value); |
| 344 | |
| 345 | void AddLocationAsTemp(Location location, LocationSummary* locations) OVERRIDE; |
| 346 | |
| 347 | // Generate code to invoke a runtime entry point. |
| 348 | void InvokeRuntime(QuickEntrypointEnum entrypoint, |
| 349 | HInstruction* instruction, |
| 350 | uint32_t dex_pc, |
Serban Constantinescu | fca1666 | 2016-07-14 09:21:59 +0100 | [diff] [blame] | 351 | SlowPathCode* slow_path = nullptr) OVERRIDE; |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 352 | |
| 353 | ParallelMoveResolver* GetMoveResolver() OVERRIDE { return &move_resolver_; } |
| 354 | |
| 355 | bool NeedsTwoRegisters(Primitive::Type type) const { |
| 356 | return type == Primitive::kPrimLong; |
| 357 | } |
| 358 | |
Vladimir Marko | cac5a7e | 2016-02-22 10:39:50 +0000 | [diff] [blame] | 359 | // Check if the desired_string_load_kind is supported. If it is, return it, |
| 360 | // otherwise return a fall-back kind that should be used instead. |
| 361 | HLoadString::LoadKind GetSupportedLoadStringKind( |
| 362 | HLoadString::LoadKind desired_string_load_kind) OVERRIDE; |
| 363 | |
Vladimir Marko | dbb7f5b | 2016-03-30 13:23:58 +0100 | [diff] [blame] | 364 | // Check if the desired_class_load_kind is supported. If it is, return it, |
| 365 | // otherwise return a fall-back kind that should be used instead. |
| 366 | HLoadClass::LoadKind GetSupportedLoadClassKind( |
| 367 | HLoadClass::LoadKind desired_class_load_kind) OVERRIDE; |
| 368 | |
Vladimir Marko | dc151b2 | 2015-10-15 18:02:30 +0100 | [diff] [blame] | 369 | // Check if the desired_dispatch_info is supported. If it is, return it, |
| 370 | // otherwise return a fall-back info that should be used instead. |
| 371 | HInvokeStaticOrDirect::DispatchInfo GetSupportedInvokeStaticOrDirectDispatch( |
| 372 | const HInvokeStaticOrDirect::DispatchInfo& desired_dispatch_info, |
| 373 | MethodReference target_method) OVERRIDE; |
| 374 | |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 375 | void GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke, Location temp); |
Chris Larsen | 3acee73 | 2015-11-18 13:31:08 -0800 | [diff] [blame] | 376 | void GenerateVirtualCall(HInvokeVirtual* invoke, Location temp) OVERRIDE; |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 377 | |
| 378 | void MoveFromReturnRegister(Location trg ATTRIBUTE_UNUSED, |
| 379 | Primitive::Type type ATTRIBUTE_UNUSED) OVERRIDE { |
| 380 | UNIMPLEMENTED(FATAL) << "Not implemented on MIPS"; |
| 381 | } |
| 382 | |
David Srbecky | c7098ff | 2016-02-09 14:30:11 +0000 | [diff] [blame] | 383 | void GenerateNop(); |
Calin Juravle | 2ae4818 | 2016-03-16 14:05:09 +0000 | [diff] [blame] | 384 | void GenerateImplicitNullCheck(HNullCheck* instruction); |
| 385 | void GenerateExplicitNullCheck(HNullCheck* instruction); |
David Srbecky | c7098ff | 2016-02-09 14:30:11 +0000 | [diff] [blame] | 386 | |
Alexey Frunze | e3fb245 | 2016-05-10 16:08:05 -0700 | [diff] [blame] | 387 | // The PcRelativePatchInfo is used for PC-relative addressing of dex cache arrays |
| 388 | // and boot image strings. The only difference is the interpretation of the offset_or_index. |
| 389 | struct PcRelativePatchInfo { |
| 390 | PcRelativePatchInfo(const DexFile& dex_file, uint32_t off_or_idx) |
| 391 | : target_dex_file(dex_file), offset_or_index(off_or_idx) { } |
| 392 | PcRelativePatchInfo(PcRelativePatchInfo&& other) = default; |
| 393 | |
| 394 | const DexFile& target_dex_file; |
Alexey Frunze | 06a46c4 | 2016-07-19 15:00:40 -0700 | [diff] [blame] | 395 | // Either the dex cache array element offset or the string/type index. |
Alexey Frunze | e3fb245 | 2016-05-10 16:08:05 -0700 | [diff] [blame] | 396 | uint32_t offset_or_index; |
| 397 | // Label for the instruction loading the most significant half of the offset that's added to PC |
| 398 | // to form the base address (the least significant half is loaded with the instruction that |
| 399 | // follows). |
| 400 | MipsLabel high_label; |
| 401 | // Label for the instruction corresponding to PC+0. |
| 402 | MipsLabel pc_rel_label; |
| 403 | }; |
| 404 | |
Alexey Frunze | 06a46c4 | 2016-07-19 15:00:40 -0700 | [diff] [blame] | 405 | PcRelativePatchInfo* NewPcRelativeStringPatch(const DexFile& dex_file, uint32_t string_index); |
| 406 | PcRelativePatchInfo* NewPcRelativeTypePatch(const DexFile& dex_file, uint32_t type_index); |
Alexey Frunze | e3fb245 | 2016-05-10 16:08:05 -0700 | [diff] [blame] | 407 | PcRelativePatchInfo* NewPcRelativeDexCacheArrayPatch(const DexFile& dex_file, |
| 408 | uint32_t element_offset); |
Alexey Frunze | 06a46c4 | 2016-07-19 15:00:40 -0700 | [diff] [blame] | 409 | Literal* DeduplicateBootImageStringLiteral(const DexFile& dex_file, uint32_t string_index); |
| 410 | Literal* DeduplicateBootImageTypeLiteral(const DexFile& dex_file, uint32_t type_index); |
| 411 | Literal* DeduplicateBootImageAddressLiteral(uint32_t address); |
Alexey Frunze | e3fb245 | 2016-05-10 16:08:05 -0700 | [diff] [blame] | 412 | |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 413 | private: |
Alexey Frunze | e3fb245 | 2016-05-10 16:08:05 -0700 | [diff] [blame] | 414 | Register GetInvokeStaticOrDirectExtraParameter(HInvokeStaticOrDirect* invoke, Register temp); |
| 415 | |
Alexey Frunze | 06a46c4 | 2016-07-19 15:00:40 -0700 | [diff] [blame] | 416 | using Uint32ToLiteralMap = ArenaSafeMap<uint32_t, Literal*>; |
Alexey Frunze | e3fb245 | 2016-05-10 16:08:05 -0700 | [diff] [blame] | 417 | using MethodToLiteralMap = ArenaSafeMap<MethodReference, Literal*, MethodReferenceComparator>; |
Alexey Frunze | 06a46c4 | 2016-07-19 15:00:40 -0700 | [diff] [blame] | 418 | using BootStringToLiteralMap = ArenaSafeMap<StringReference, |
| 419 | Literal*, |
| 420 | StringReferenceValueComparator>; |
| 421 | using BootTypeToLiteralMap = ArenaSafeMap<TypeReference, |
| 422 | Literal*, |
| 423 | TypeReferenceValueComparator>; |
Alexey Frunze | e3fb245 | 2016-05-10 16:08:05 -0700 | [diff] [blame] | 424 | |
Alexey Frunze | 06a46c4 | 2016-07-19 15:00:40 -0700 | [diff] [blame] | 425 | Literal* DeduplicateUint32Literal(uint32_t value, Uint32ToLiteralMap* map); |
Alexey Frunze | e3fb245 | 2016-05-10 16:08:05 -0700 | [diff] [blame] | 426 | Literal* DeduplicateMethodLiteral(MethodReference target_method, MethodToLiteralMap* map); |
| 427 | Literal* DeduplicateMethodAddressLiteral(MethodReference target_method); |
| 428 | Literal* DeduplicateMethodCodeLiteral(MethodReference target_method); |
| 429 | PcRelativePatchInfo* NewPcRelativePatch(const DexFile& dex_file, |
| 430 | uint32_t offset_or_index, |
| 431 | ArenaDeque<PcRelativePatchInfo>* patches); |
| 432 | |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 433 | // Labels for each block that will be compiled. |
| 434 | MipsLabel* block_labels_; |
| 435 | MipsLabel frame_entry_label_; |
| 436 | LocationsBuilderMIPS location_builder_; |
| 437 | InstructionCodeGeneratorMIPS instruction_visitor_; |
| 438 | ParallelMoveResolverMIPS move_resolver_; |
| 439 | MipsAssembler assembler_; |
| 440 | const MipsInstructionSetFeatures& isa_features_; |
| 441 | |
Alexey Frunze | 06a46c4 | 2016-07-19 15:00:40 -0700 | [diff] [blame] | 442 | // Deduplication map for 32-bit literals, used for non-patchable boot image addresses. |
| 443 | Uint32ToLiteralMap uint32_literals_; |
Alexey Frunze | e3fb245 | 2016-05-10 16:08:05 -0700 | [diff] [blame] | 444 | // Method patch info, map MethodReference to a literal for method address and method code. |
| 445 | MethodToLiteralMap method_patches_; |
| 446 | MethodToLiteralMap call_patches_; |
| 447 | // PC-relative patch info for each HMipsDexCacheArraysBase. |
| 448 | ArenaDeque<PcRelativePatchInfo> pc_relative_dex_cache_patches_; |
Alexey Frunze | 06a46c4 | 2016-07-19 15:00:40 -0700 | [diff] [blame] | 449 | // Deduplication map for boot string literals for kBootImageLinkTimeAddress. |
| 450 | BootStringToLiteralMap boot_image_string_patches_; |
| 451 | // PC-relative String patch info. |
| 452 | ArenaDeque<PcRelativePatchInfo> pc_relative_string_patches_; |
| 453 | // Deduplication map for boot type literals for kBootImageLinkTimeAddress. |
| 454 | BootTypeToLiteralMap boot_image_type_patches_; |
| 455 | // PC-relative type patch info. |
| 456 | ArenaDeque<PcRelativePatchInfo> pc_relative_type_patches_; |
| 457 | // Deduplication map for patchable boot image addresses. |
| 458 | Uint32ToLiteralMap boot_image_address_patches_; |
| 459 | |
| 460 | // PC-relative loads on R2 clobber RA, which may need to be preserved explicitly in leaf methods. |
| 461 | // This is a flag set by pc_relative_fixups_mips and dex_cache_array_fixups_mips optimizations. |
| 462 | bool clobbered_ra_; |
Alexey Frunze | e3fb245 | 2016-05-10 16:08:05 -0700 | [diff] [blame] | 463 | |
Goran Jakovljevic | f652cec | 2015-08-25 16:11:42 +0200 | [diff] [blame] | 464 | DISALLOW_COPY_AND_ASSIGN(CodeGeneratorMIPS); |
| 465 | }; |
| 466 | |
| 467 | } // namespace mips |
| 468 | } // namespace art |
| 469 | |
| 470 | #endif // ART_COMPILER_OPTIMIZING_CODE_GENERATOR_MIPS_H_ |