Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [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_ARM_H_ |
| 18 | #define ART_COMPILER_OPTIMIZING_CODE_GENERATOR_ARM_H_ |
| 19 | |
| 20 | #include "code_generator.h" |
| 21 | #include "nodes.h" |
Nicolas Geoffray | e27f31a | 2014-06-12 17:53:14 +0100 | [diff] [blame] | 22 | #include "parallel_move_resolver.h" |
Dave Allison | 20dfc79 | 2014-06-16 20:44:29 -0700 | [diff] [blame^] | 23 | #include "utils/arm/assembler_thumb2.h" |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 24 | |
| 25 | namespace art { |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 26 | namespace arm { |
| 27 | |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 28 | class CodeGeneratorARM; |
| 29 | |
Nicolas Geoffray | 707c809 | 2014-04-04 10:50:14 +0100 | [diff] [blame] | 30 | static constexpr size_t kArmWordSize = 4; |
| 31 | |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 32 | static constexpr Register kParameterCoreRegisters[] = { R1, R2, R3 }; |
| 33 | static constexpr RegisterPair kParameterCorePairRegisters[] = { R1_R2, R2_R3 }; |
| 34 | static constexpr size_t kParameterCoreRegistersLength = arraysize(kParameterCoreRegisters); |
| 35 | |
| 36 | class InvokeDexCallingConvention : public CallingConvention<Register> { |
| 37 | public: |
| 38 | InvokeDexCallingConvention() |
| 39 | : CallingConvention(kParameterCoreRegisters, kParameterCoreRegistersLength) {} |
| 40 | |
| 41 | RegisterPair GetRegisterPairAt(size_t argument_index) { |
| 42 | DCHECK_LT(argument_index + 1, GetNumberOfRegisters()); |
| 43 | return kParameterCorePairRegisters[argument_index]; |
| 44 | } |
| 45 | |
| 46 | private: |
| 47 | DISALLOW_COPY_AND_ASSIGN(InvokeDexCallingConvention); |
| 48 | }; |
| 49 | |
| 50 | class InvokeDexCallingConventionVisitor { |
| 51 | public: |
| 52 | InvokeDexCallingConventionVisitor() : gp_index_(0) {} |
| 53 | |
| 54 | Location GetNextLocation(Primitive::Type type); |
| 55 | |
| 56 | private: |
| 57 | InvokeDexCallingConvention calling_convention; |
| 58 | uint32_t gp_index_; |
| 59 | |
| 60 | DISALLOW_COPY_AND_ASSIGN(InvokeDexCallingConventionVisitor); |
| 61 | }; |
| 62 | |
Nicolas Geoffray | e27f31a | 2014-06-12 17:53:14 +0100 | [diff] [blame] | 63 | class ParallelMoveResolverARM : public ParallelMoveResolver { |
| 64 | public: |
| 65 | ParallelMoveResolverARM(ArenaAllocator* allocator, CodeGeneratorARM* codegen) |
| 66 | : ParallelMoveResolver(allocator), codegen_(codegen) {} |
| 67 | |
| 68 | virtual void EmitMove(size_t index) OVERRIDE; |
| 69 | virtual void EmitSwap(size_t index) OVERRIDE; |
| 70 | virtual void SpillScratch(int reg) OVERRIDE; |
| 71 | virtual void RestoreScratch(int reg) OVERRIDE; |
| 72 | |
| 73 | ArmAssembler* GetAssembler() const; |
| 74 | |
| 75 | private: |
| 76 | void Exchange(Register reg, int mem); |
| 77 | void Exchange(int mem1, int mem2); |
| 78 | |
| 79 | CodeGeneratorARM* const codegen_; |
| 80 | |
| 81 | DISALLOW_COPY_AND_ASSIGN(ParallelMoveResolverARM); |
| 82 | }; |
| 83 | |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 84 | class LocationsBuilderARM : public HGraphVisitor { |
| 85 | public: |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 86 | explicit LocationsBuilderARM(HGraph* graph, CodeGeneratorARM* codegen) |
| 87 | : HGraphVisitor(graph), codegen_(codegen) {} |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 88 | |
| 89 | #define DECLARE_VISIT_INSTRUCTION(name) \ |
| 90 | virtual void Visit##name(H##name* instr); |
| 91 | |
| 92 | FOR_EACH_INSTRUCTION(DECLARE_VISIT_INSTRUCTION) |
| 93 | |
| 94 | #undef DECLARE_VISIT_INSTRUCTION |
| 95 | |
| 96 | private: |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 97 | CodeGeneratorARM* const codegen_; |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 98 | InvokeDexCallingConventionVisitor parameter_visitor_; |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 99 | |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 100 | DISALLOW_COPY_AND_ASSIGN(LocationsBuilderARM); |
| 101 | }; |
| 102 | |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 103 | class InstructionCodeGeneratorARM : public HGraphVisitor { |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 104 | public: |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 105 | InstructionCodeGeneratorARM(HGraph* graph, CodeGeneratorARM* codegen); |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 106 | |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 107 | #define DECLARE_VISIT_INSTRUCTION(name) \ |
| 108 | virtual void Visit##name(H##name* instr); |
| 109 | |
| 110 | FOR_EACH_INSTRUCTION(DECLARE_VISIT_INSTRUCTION) |
| 111 | |
| 112 | #undef DECLARE_VISIT_INSTRUCTION |
| 113 | |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 114 | ArmAssembler* GetAssembler() const { return assembler_; } |
Nicolas Geoffray | 8ccc3f5 | 2014-03-19 10:34:11 +0000 | [diff] [blame] | 115 | void LoadCurrentMethod(Register reg); |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 116 | |
| 117 | private: |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 118 | ArmAssembler* const assembler_; |
| 119 | CodeGeneratorARM* const codegen_; |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 120 | |
| 121 | DISALLOW_COPY_AND_ASSIGN(InstructionCodeGeneratorARM); |
| 122 | }; |
| 123 | |
| 124 | class CodeGeneratorARM : public CodeGenerator { |
| 125 | public: |
Nicolas Geoffray | a7aca37 | 2014-04-28 17:47:12 +0100 | [diff] [blame] | 126 | explicit CodeGeneratorARM(HGraph* graph); |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 127 | virtual ~CodeGeneratorARM() { } |
| 128 | |
Nicolas Geoffray | 86dbb9a | 2014-06-04 11:12:39 +0100 | [diff] [blame] | 129 | virtual void ComputeFrameSize(size_t number_of_spill_slots) OVERRIDE; |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 130 | virtual void GenerateFrameEntry() OVERRIDE; |
| 131 | virtual void GenerateFrameExit() OVERRIDE; |
| 132 | virtual void Bind(Label* label) OVERRIDE; |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 133 | virtual void Move(HInstruction* instruction, Location location, HInstruction* move_for) OVERRIDE; |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 134 | |
Nicolas Geoffray | 707c809 | 2014-04-04 10:50:14 +0100 | [diff] [blame] | 135 | virtual size_t GetWordSize() const OVERRIDE { |
| 136 | return kArmWordSize; |
| 137 | } |
| 138 | |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 139 | virtual HGraphVisitor* GetLocationBuilder() OVERRIDE { |
| 140 | return &location_builder_; |
| 141 | } |
| 142 | |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 143 | virtual HGraphVisitor* GetInstructionVisitor() OVERRIDE { |
| 144 | return &instruction_visitor_; |
| 145 | } |
| 146 | |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 147 | virtual ArmAssembler* GetAssembler() OVERRIDE { |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 148 | return &assembler_; |
| 149 | } |
| 150 | |
Nicolas Geoffray | a7aca37 | 2014-04-28 17:47:12 +0100 | [diff] [blame] | 151 | virtual void SetupBlockedRegisters(bool* blocked_registers) const OVERRIDE; |
| 152 | virtual ManagedRegister AllocateFreeRegister( |
| 153 | Primitive::Type type, bool* blocked_registers) const OVERRIDE; |
| 154 | virtual size_t GetNumberOfRegisters() const OVERRIDE; |
| 155 | |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 156 | int32_t GetStackSlot(HLocal* local) const; |
Nicolas Geoffray | a7aca37 | 2014-04-28 17:47:12 +0100 | [diff] [blame] | 157 | virtual Location GetStackLocation(HLoadLocal* load) const OVERRIDE; |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 158 | |
Nicolas Geoffray | a7062e0 | 2014-05-22 12:50:17 +0100 | [diff] [blame] | 159 | virtual size_t GetNumberOfCoreRegisters() const OVERRIDE { |
| 160 | return kNumberOfCoreRegisters; |
| 161 | } |
| 162 | |
| 163 | virtual size_t GetNumberOfFloatingPointRegisters() const OVERRIDE { |
| 164 | return kNumberOfDRegisters; |
| 165 | } |
| 166 | |
| 167 | virtual void DumpCoreRegister(std::ostream& stream, int reg) const OVERRIDE; |
| 168 | virtual void DumpFloatingPointRegister(std::ostream& stream, int reg) const OVERRIDE; |
| 169 | |
Nicolas Geoffray | e27f31a | 2014-06-12 17:53:14 +0100 | [diff] [blame] | 170 | ParallelMoveResolverARM* GetMoveResolver() { |
| 171 | return &move_resolver_; |
| 172 | } |
| 173 | |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 174 | private: |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 175 | // Helper method to move a 32bits value between two locations. |
| 176 | void Move32(Location destination, Location source); |
| 177 | // Helper method to move a 64bits value between two locations. |
| 178 | void Move64(Location destination, Location source); |
| 179 | |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 180 | LocationsBuilderARM location_builder_; |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 181 | InstructionCodeGeneratorARM instruction_visitor_; |
Nicolas Geoffray | e27f31a | 2014-06-12 17:53:14 +0100 | [diff] [blame] | 182 | ParallelMoveResolverARM move_resolver_; |
Dave Allison | 20dfc79 | 2014-06-16 20:44:29 -0700 | [diff] [blame^] | 183 | Thumb2Assembler assembler_; |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 184 | |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 185 | DISALLOW_COPY_AND_ASSIGN(CodeGeneratorARM); |
| 186 | }; |
| 187 | |
| 188 | } // namespace arm |
| 189 | } // namespace art |
| 190 | |
| 191 | #endif // ART_COMPILER_OPTIMIZING_CODE_GENERATOR_ARM_H_ |