blob: 8b29b159ab48ef3b6b63d54c18746bd1b1d84869 [file] [log] [blame]
Nicolas Geoffrayd4dd2552014-02-28 10:23:58 +00001/*
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_ARM_H_
18#define ART_COMPILER_OPTIMIZING_CODE_GENERATOR_ARM_H_
19
20#include "code_generator.h"
Calin Juravle52c48962014-12-16 17:02:57 +000021#include "dex/compiler_enums.h"
Nicolas Geoffrayd4dd2552014-02-28 10:23:58 +000022#include "nodes.h"
Nicolas Geoffraye27f31a2014-06-12 17:53:14 +010023#include "parallel_move_resolver.h"
Nicolas Geoffray8d486732014-07-16 16:23:40 +010024#include "utils/arm/assembler_thumb2.h"
Nicolas Geoffrayd4dd2552014-02-28 10:23:58 +000025
26namespace art {
Nicolas Geoffrayd4dd2552014-02-28 10:23:58 +000027namespace arm {
28
Nicolas Geoffray01bc96d2014-04-11 17:43:50 +010029class CodeGeneratorARM;
Nicolas Geoffray424f6762014-11-03 14:51:25 +000030class SlowPathCodeARM;
Nicolas Geoffray01bc96d2014-04-11 17:43:50 +010031
Nicolas Geoffray86a8d7a2014-11-19 08:47:18 +000032// Use a local definition to prevent copying mistakes.
33static constexpr size_t kArmWordSize = kArmPointerSize;
Nicolas Geoffray707c8092014-04-04 10:50:14 +010034
Nicolas Geoffraya747a392014-04-17 14:56:23 +010035static constexpr Register kParameterCoreRegisters[] = { R1, R2, R3 };
Nicolas Geoffraya747a392014-04-17 14:56:23 +010036static constexpr size_t kParameterCoreRegistersLength = arraysize(kParameterCoreRegisters);
Nicolas Geoffray1ba0f592014-10-27 15:14:55 +000037static constexpr SRegister kParameterFpuRegisters[] =
38 { S0, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15 };
39static constexpr size_t kParameterFpuRegistersLength = arraysize(kParameterFpuRegisters);
Nicolas Geoffraya747a392014-04-17 14:56:23 +010040
Nicolas Geoffray1ba0f592014-10-27 15:14:55 +000041class InvokeDexCallingConvention : public CallingConvention<Register, SRegister> {
Nicolas Geoffraya747a392014-04-17 14:56:23 +010042 public:
43 InvokeDexCallingConvention()
Nicolas Geoffray7fb49da2014-10-06 09:12:41 +010044 : CallingConvention(kParameterCoreRegisters,
45 kParameterCoreRegistersLength,
46 kParameterFpuRegisters,
47 kParameterFpuRegistersLength) {}
Nicolas Geoffraya747a392014-04-17 14:56:23 +010048
Nicolas Geoffraya747a392014-04-17 14:56:23 +010049 private:
50 DISALLOW_COPY_AND_ASSIGN(InvokeDexCallingConvention);
51};
52
53class InvokeDexCallingConventionVisitor {
54 public:
Nicolas Geoffray1ba0f592014-10-27 15:14:55 +000055 InvokeDexCallingConventionVisitor()
56 : gp_index_(0), float_index_(0), double_index_(0), stack_index_(0) {}
Nicolas Geoffraya747a392014-04-17 14:56:23 +010057
58 Location GetNextLocation(Primitive::Type type);
Nicolas Geoffray1ba0f592014-10-27 15:14:55 +000059 Location GetReturnLocation(Primitive::Type type);
Nicolas Geoffraya747a392014-04-17 14:56:23 +010060
61 private:
62 InvokeDexCallingConvention calling_convention;
63 uint32_t gp_index_;
Nicolas Geoffray1ba0f592014-10-27 15:14:55 +000064 uint32_t float_index_;
65 uint32_t double_index_;
66 uint32_t stack_index_;
Nicolas Geoffraya747a392014-04-17 14:56:23 +010067
68 DISALLOW_COPY_AND_ASSIGN(InvokeDexCallingConventionVisitor);
69};
70
Nicolas Geoffraye27f31a2014-06-12 17:53:14 +010071class ParallelMoveResolverARM : public ParallelMoveResolver {
72 public:
73 ParallelMoveResolverARM(ArenaAllocator* allocator, CodeGeneratorARM* codegen)
74 : ParallelMoveResolver(allocator), codegen_(codegen) {}
75
Nicolas Geoffrayde58ab22014-11-05 12:46:03 +000076 void EmitMove(size_t index) OVERRIDE;
77 void EmitSwap(size_t index) OVERRIDE;
78 void SpillScratch(int reg) OVERRIDE;
79 void RestoreScratch(int reg) OVERRIDE;
Nicolas Geoffraye27f31a2014-06-12 17:53:14 +010080
81 ArmAssembler* GetAssembler() const;
82
83 private:
84 void Exchange(Register reg, int mem);
85 void Exchange(int mem1, int mem2);
86
87 CodeGeneratorARM* const codegen_;
88
89 DISALLOW_COPY_AND_ASSIGN(ParallelMoveResolverARM);
90};
91
Nicolas Geoffraybab4ed72014-03-11 17:53:17 +000092class LocationsBuilderARM : public HGraphVisitor {
93 public:
Roland Levillain5799fc02014-09-25 12:15:20 +010094 LocationsBuilderARM(HGraph* graph, CodeGeneratorARM* codegen)
Nicolas Geoffray01bc96d2014-04-11 17:43:50 +010095 : HGraphVisitor(graph), codegen_(codegen) {}
Nicolas Geoffraybab4ed72014-03-11 17:53:17 +000096
Nicolas Geoffray360231a2014-10-08 21:07:48 +010097#define DECLARE_VISIT_INSTRUCTION(name, super) \
Nicolas Geoffrayde58ab22014-11-05 12:46:03 +000098 void Visit##name(H##name* instr);
Nicolas Geoffraybab4ed72014-03-11 17:53:17 +000099
Nicolas Geoffray96f89a22014-07-11 10:57:49 +0100100 FOR_EACH_CONCRETE_INSTRUCTION(DECLARE_VISIT_INSTRUCTION)
Nicolas Geoffraybab4ed72014-03-11 17:53:17 +0000101
102#undef DECLARE_VISIT_INSTRUCTION
103
104 private:
Nicolas Geoffray9574c4b2014-11-12 13:19:37 +0000105 void HandleInvoke(HInvoke* invoke);
106 void HandleBitwiseOperation(HBinaryOperation* operation);
Calin Juravle9aec02f2014-11-18 23:06:35 +0000107 void HandleShift(HBinaryOperation* operation);
Calin Juravle52c48962014-12-16 17:02:57 +0000108 void HandleFieldSet(HInstruction* instruction, const FieldInfo& field_info);
109 void HandleFieldGet(HInstruction* instruction, const FieldInfo& field_info);
Nicolas Geoffray9574c4b2014-11-12 13:19:37 +0000110
Nicolas Geoffray01bc96d2014-04-11 17:43:50 +0100111 CodeGeneratorARM* const codegen_;
Nicolas Geoffraya747a392014-04-17 14:56:23 +0100112 InvokeDexCallingConventionVisitor parameter_visitor_;
Nicolas Geoffray01bc96d2014-04-11 17:43:50 +0100113
Nicolas Geoffraybab4ed72014-03-11 17:53:17 +0000114 DISALLOW_COPY_AND_ASSIGN(LocationsBuilderARM);
115};
116
Nicolas Geoffray787c3072014-03-17 10:20:19 +0000117class InstructionCodeGeneratorARM : public HGraphVisitor {
Nicolas Geoffrayd4dd2552014-02-28 10:23:58 +0000118 public:
Nicolas Geoffray4a34a422014-04-03 10:38:37 +0100119 InstructionCodeGeneratorARM(HGraph* graph, CodeGeneratorARM* codegen);
Nicolas Geoffrayd4dd2552014-02-28 10:23:58 +0000120
Nicolas Geoffray360231a2014-10-08 21:07:48 +0100121#define DECLARE_VISIT_INSTRUCTION(name, super) \
Nicolas Geoffrayde58ab22014-11-05 12:46:03 +0000122 void Visit##name(H##name* instr);
Nicolas Geoffrayd4dd2552014-02-28 10:23:58 +0000123
Nicolas Geoffray96f89a22014-07-11 10:57:49 +0100124 FOR_EACH_CONCRETE_INSTRUCTION(DECLARE_VISIT_INSTRUCTION)
Nicolas Geoffrayd4dd2552014-02-28 10:23:58 +0000125
126#undef DECLARE_VISIT_INSTRUCTION
127
Nicolas Geoffray4a34a422014-04-03 10:38:37 +0100128 ArmAssembler* GetAssembler() const { return assembler_; }
Nicolas Geoffray787c3072014-03-17 10:20:19 +0000129
130 private:
Nicolas Geoffray3c049742014-09-24 18:10:46 +0100131 // Generate code for the given suspend check. If not null, `successor`
132 // is the block to branch to if the suspend check is not needed, and after
133 // the suspend call.
134 void GenerateSuspendCheck(HSuspendCheck* check, HBasicBlock* successor);
Nicolas Geoffray424f6762014-11-03 14:51:25 +0000135 void GenerateClassInitializationCheck(SlowPathCodeARM* slow_path, Register class_reg);
Nicolas Geoffray9574c4b2014-11-12 13:19:37 +0000136 void HandleBitwiseOperation(HBinaryOperation* operation);
Calin Juravle9aec02f2014-11-18 23:06:35 +0000137 void HandleShift(HBinaryOperation* operation);
Calin Juravle52c48962014-12-16 17:02:57 +0000138 void GenerateMemoryBarrier(MemBarrierKind kind);
139 void GenerateWideAtomicStore(Register addr, uint32_t offset,
140 Register value_lo, Register value_hi,
141 Register temp1, Register temp2);
142 void GenerateWideAtomicLoad(Register addr, uint32_t offset,
143 Register out_lo, Register out_hi);
144 void HandleFieldSet(HInstruction* instruction, const FieldInfo& field_info);
145 void HandleFieldGet(HInstruction* instruction, const FieldInfo& field_info);
146
Nicolas Geoffray3c049742014-09-24 18:10:46 +0100147
Nicolas Geoffray4a34a422014-04-03 10:38:37 +0100148 ArmAssembler* const assembler_;
149 CodeGeneratorARM* const codegen_;
Nicolas Geoffray787c3072014-03-17 10:20:19 +0000150
151 DISALLOW_COPY_AND_ASSIGN(InstructionCodeGeneratorARM);
152};
153
154class CodeGeneratorARM : public CodeGenerator {
155 public:
Calin Juravle34166012014-12-19 17:22:29 +0000156 CodeGeneratorARM(HGraph* graph, const ArmInstructionSetFeatures* isa_features);
Nicolas Geoffray8a16d972014-09-11 10:30:02 +0100157 virtual ~CodeGeneratorARM() {}
Nicolas Geoffray787c3072014-03-17 10:20:19 +0000158
Nicolas Geoffrayde58ab22014-11-05 12:46:03 +0000159 void GenerateFrameEntry() OVERRIDE;
160 void GenerateFrameExit() OVERRIDE;
161 void Bind(HBasicBlock* block) OVERRIDE;
162 void Move(HInstruction* instruction, Location location, HInstruction* move_for) OVERRIDE;
163 size_t SaveCoreRegister(size_t stack_index, uint32_t reg_id) OVERRIDE;
164 size_t RestoreCoreRegister(size_t stack_index, uint32_t reg_id) OVERRIDE;
Nicolas Geoffray840e5462015-01-07 16:01:24 +0000165 size_t SaveFloatingPointRegister(size_t stack_index, uint32_t reg_id) OVERRIDE;
166 size_t RestoreFloatingPointRegister(size_t stack_index, uint32_t reg_id) OVERRIDE;
Nicolas Geoffraybab4ed72014-03-11 17:53:17 +0000167
Nicolas Geoffrayde58ab22014-11-05 12:46:03 +0000168 size_t GetWordSize() const OVERRIDE {
Nicolas Geoffray707c8092014-04-04 10:50:14 +0100169 return kArmWordSize;
170 }
171
Nicolas Geoffrayde58ab22014-11-05 12:46:03 +0000172 size_t FrameEntrySpillSize() const OVERRIDE;
Nicolas Geoffrayab032bc2014-07-15 12:55:21 +0100173
Nicolas Geoffrayde58ab22014-11-05 12:46:03 +0000174 HGraphVisitor* GetLocationBuilder() OVERRIDE {
Nicolas Geoffraybab4ed72014-03-11 17:53:17 +0000175 return &location_builder_;
176 }
177
Nicolas Geoffrayde58ab22014-11-05 12:46:03 +0000178 HGraphVisitor* GetInstructionVisitor() OVERRIDE {
Nicolas Geoffray787c3072014-03-17 10:20:19 +0000179 return &instruction_visitor_;
180 }
181
Nicolas Geoffrayde58ab22014-11-05 12:46:03 +0000182 ArmAssembler* GetAssembler() OVERRIDE {
Nicolas Geoffray787c3072014-03-17 10:20:19 +0000183 return &assembler_;
184 }
185
Nicolas Geoffrayde58ab22014-11-05 12:46:03 +0000186 uintptr_t GetAddressOf(HBasicBlock* block) const OVERRIDE {
187 return GetLabelOf(block)->Position();
188 }
Calin Juravle34bacdf2014-10-07 20:23:36 +0100189
Nicolas Geoffrayde58ab22014-11-05 12:46:03 +0000190 void SetupBlockedRegisters() const OVERRIDE;
Nicolas Geoffraya7aca372014-04-28 17:47:12 +0100191
Nicolas Geoffrayde58ab22014-11-05 12:46:03 +0000192 Location AllocateFreeRegister(Primitive::Type type) const OVERRIDE;
Nicolas Geoffray4a34a422014-04-03 10:38:37 +0100193
Nicolas Geoffrayde58ab22014-11-05 12:46:03 +0000194 Location GetStackLocation(HLoadLocal* load) const OVERRIDE;
195
196 void DumpCoreRegister(std::ostream& stream, int reg) const OVERRIDE;
197 void DumpFloatingPointRegister(std::ostream& stream, int reg) const OVERRIDE;
Nicolas Geoffraya7062e02014-05-22 12:50:17 +0100198
Calin Juravle34bacdf2014-10-07 20:23:36 +0100199 // Blocks all register pairs made out of blocked core registers.
200 void UpdateBlockedPairRegisters() const;
201
Nicolas Geoffrayf0e39372014-11-12 17:50:07 +0000202 ParallelMoveResolverARM* GetMoveResolver() OVERRIDE {
Nicolas Geoffraye27f31a2014-06-12 17:53:14 +0100203 return &move_resolver_;
204 }
205
Nicolas Geoffrayde58ab22014-11-05 12:46:03 +0000206 InstructionSet GetInstructionSet() const OVERRIDE {
Nicolas Geoffray8d486732014-07-16 16:23:40 +0100207 return InstructionSet::kThumb2;
Nicolas Geoffray412f10c2014-06-19 10:00:34 +0100208 }
209
Nicolas Geoffray01bc96d2014-04-11 17:43:50 +0100210 // Helper method to move a 32bits value between two locations.
211 void Move32(Location destination, Location source);
212 // Helper method to move a 64bits value between two locations.
213 void Move64(Location destination, Location source);
214
Nicolas Geoffray19a19cf2014-10-22 16:07:05 +0100215 // Load current method into `reg`.
216 void LoadCurrentMethod(Register reg);
217
218 // Generate code to invoke a runtime entry point.
219 void InvokeRuntime(int32_t offset, HInstruction* instruction, uint32_t dex_pc);
220
Nicolas Geoffray3c7bb982014-07-23 16:04:16 +0100221 // Emit a write barrier.
222 void MarkGCCard(Register temp, Register card, Register object, Register value);
223
Nicolas Geoffray92a73ae2014-10-16 11:12:52 +0100224 Label* GetLabelOf(HBasicBlock* block) const {
225 return block_labels_.GetRawStorage() + block->GetBlockId();
226 }
227
Nicolas Geoffrayde58ab22014-11-05 12:46:03 +0000228 void Initialize() OVERRIDE {
Nicolas Geoffray92a73ae2014-10-16 11:12:52 +0100229 block_labels_.SetSize(GetGraph()->GetBlocks().Size());
230 }
231
Calin Juravle34166012014-12-19 17:22:29 +0000232 const ArmInstructionSetFeatures* GetInstructionSetFeatures() const {
233 return isa_features_;
234 }
235
Nicolas Geoffray840e5462015-01-07 16:01:24 +0000236 bool NeedsTwoRegisters(Primitive::Type type) const OVERRIDE {
237 return type == Primitive::kPrimDouble || type == Primitive::kPrimLong;
238 }
239
Nicolas Geoffray3c7bb982014-07-23 16:04:16 +0100240 private:
Nicolas Geoffray92a73ae2014-10-16 11:12:52 +0100241 // Labels for each block that will be compiled.
242 GrowableArray<Label> block_labels_;
Nicolas Geoffraybab4ed72014-03-11 17:53:17 +0000243 LocationsBuilderARM location_builder_;
Nicolas Geoffray787c3072014-03-17 10:20:19 +0000244 InstructionCodeGeneratorARM instruction_visitor_;
Nicolas Geoffraye27f31a2014-06-12 17:53:14 +0100245 ParallelMoveResolverARM move_resolver_;
Nicolas Geoffray8d486732014-07-16 16:23:40 +0100246 Thumb2Assembler assembler_;
Calin Juravle34166012014-12-19 17:22:29 +0000247 const ArmInstructionSetFeatures* isa_features_;
Nicolas Geoffray787c3072014-03-17 10:20:19 +0000248
Nicolas Geoffrayd4dd2552014-02-28 10:23:58 +0000249 DISALLOW_COPY_AND_ASSIGN(CodeGeneratorARM);
250};
251
252} // namespace arm
253} // namespace art
254
255#endif // ART_COMPILER_OPTIMIZING_CODE_GENERATOR_ARM_H_