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" |
Calin Juravle | 52c4896 | 2014-12-16 17:02:57 +0000 | [diff] [blame] | 21 | #include "dex/compiler_enums.h" |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 22 | #include "nodes.h" |
Nicolas Geoffray | e27f31a | 2014-06-12 17:53:14 +0100 | [diff] [blame] | 23 | #include "parallel_move_resolver.h" |
Nicolas Geoffray | 8d48673 | 2014-07-16 16:23:40 +0100 | [diff] [blame] | 24 | #include "utils/arm/assembler_thumb2.h" |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 25 | |
| 26 | namespace art { |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 27 | namespace arm { |
| 28 | |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 29 | class CodeGeneratorARM; |
Nicolas Geoffray | 424f676 | 2014-11-03 14:51:25 +0000 | [diff] [blame] | 30 | class SlowPathCodeARM; |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 31 | |
Nicolas Geoffray | 86a8d7a | 2014-11-19 08:47:18 +0000 | [diff] [blame] | 32 | // Use a local definition to prevent copying mistakes. |
| 33 | static constexpr size_t kArmWordSize = kArmPointerSize; |
Nicolas Geoffray | 707c809 | 2014-04-04 10:50:14 +0100 | [diff] [blame] | 34 | |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 35 | static constexpr Register kParameterCoreRegisters[] = { R1, R2, R3 }; |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 36 | static constexpr size_t kParameterCoreRegistersLength = arraysize(kParameterCoreRegisters); |
Nicolas Geoffray | 1ba0f59 | 2014-10-27 15:14:55 +0000 | [diff] [blame] | 37 | static constexpr SRegister kParameterFpuRegisters[] = |
| 38 | { S0, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15 }; |
| 39 | static constexpr size_t kParameterFpuRegistersLength = arraysize(kParameterFpuRegisters); |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 40 | |
Nicolas Geoffray | 1ba0f59 | 2014-10-27 15:14:55 +0000 | [diff] [blame] | 41 | class InvokeDexCallingConvention : public CallingConvention<Register, SRegister> { |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 42 | public: |
| 43 | InvokeDexCallingConvention() |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 44 | : CallingConvention(kParameterCoreRegisters, |
| 45 | kParameterCoreRegistersLength, |
| 46 | kParameterFpuRegisters, |
| 47 | kParameterFpuRegistersLength) {} |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 48 | |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 49 | private: |
| 50 | DISALLOW_COPY_AND_ASSIGN(InvokeDexCallingConvention); |
| 51 | }; |
| 52 | |
| 53 | class InvokeDexCallingConventionVisitor { |
| 54 | public: |
Nicolas Geoffray | 1ba0f59 | 2014-10-27 15:14:55 +0000 | [diff] [blame] | 55 | InvokeDexCallingConventionVisitor() |
| 56 | : gp_index_(0), float_index_(0), double_index_(0), stack_index_(0) {} |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 57 | |
| 58 | Location GetNextLocation(Primitive::Type type); |
Nicolas Geoffray | 1ba0f59 | 2014-10-27 15:14:55 +0000 | [diff] [blame] | 59 | Location GetReturnLocation(Primitive::Type type); |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 60 | |
| 61 | private: |
| 62 | InvokeDexCallingConvention calling_convention; |
| 63 | uint32_t gp_index_; |
Nicolas Geoffray | 1ba0f59 | 2014-10-27 15:14:55 +0000 | [diff] [blame] | 64 | uint32_t float_index_; |
| 65 | uint32_t double_index_; |
| 66 | uint32_t stack_index_; |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 67 | |
| 68 | DISALLOW_COPY_AND_ASSIGN(InvokeDexCallingConventionVisitor); |
| 69 | }; |
| 70 | |
Nicolas Geoffray | e27f31a | 2014-06-12 17:53:14 +0100 | [diff] [blame] | 71 | class ParallelMoveResolverARM : public ParallelMoveResolver { |
| 72 | public: |
| 73 | ParallelMoveResolverARM(ArenaAllocator* allocator, CodeGeneratorARM* codegen) |
| 74 | : ParallelMoveResolver(allocator), codegen_(codegen) {} |
| 75 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 76 | 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 Geoffray | e27f31a | 2014-06-12 17:53:14 +0100 | [diff] [blame] | 80 | |
| 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 Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 92 | class LocationsBuilderARM : public HGraphVisitor { |
| 93 | public: |
Roland Levillain | 5799fc0 | 2014-09-25 12:15:20 +0100 | [diff] [blame] | 94 | LocationsBuilderARM(HGraph* graph, CodeGeneratorARM* codegen) |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 95 | : HGraphVisitor(graph), codegen_(codegen) {} |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 96 | |
Nicolas Geoffray | 360231a | 2014-10-08 21:07:48 +0100 | [diff] [blame] | 97 | #define DECLARE_VISIT_INSTRUCTION(name, super) \ |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 98 | void Visit##name(H##name* instr); |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 99 | |
Nicolas Geoffray | 96f89a2 | 2014-07-11 10:57:49 +0100 | [diff] [blame] | 100 | FOR_EACH_CONCRETE_INSTRUCTION(DECLARE_VISIT_INSTRUCTION) |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 101 | |
| 102 | #undef DECLARE_VISIT_INSTRUCTION |
| 103 | |
| 104 | private: |
Nicolas Geoffray | 9574c4b | 2014-11-12 13:19:37 +0000 | [diff] [blame] | 105 | void HandleInvoke(HInvoke* invoke); |
| 106 | void HandleBitwiseOperation(HBinaryOperation* operation); |
Calin Juravle | 9aec02f | 2014-11-18 23:06:35 +0000 | [diff] [blame] | 107 | void HandleShift(HBinaryOperation* operation); |
Calin Juravle | 52c4896 | 2014-12-16 17:02:57 +0000 | [diff] [blame] | 108 | void HandleFieldSet(HInstruction* instruction, const FieldInfo& field_info); |
| 109 | void HandleFieldGet(HInstruction* instruction, const FieldInfo& field_info); |
Nicolas Geoffray | 9574c4b | 2014-11-12 13:19:37 +0000 | [diff] [blame] | 110 | |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 111 | CodeGeneratorARM* const codegen_; |
Nicolas Geoffray | a747a39 | 2014-04-17 14:56:23 +0100 | [diff] [blame] | 112 | InvokeDexCallingConventionVisitor parameter_visitor_; |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 113 | |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 114 | DISALLOW_COPY_AND_ASSIGN(LocationsBuilderARM); |
| 115 | }; |
| 116 | |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 117 | class InstructionCodeGeneratorARM : public HGraphVisitor { |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 118 | public: |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 119 | InstructionCodeGeneratorARM(HGraph* graph, CodeGeneratorARM* codegen); |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 120 | |
Nicolas Geoffray | 360231a | 2014-10-08 21:07:48 +0100 | [diff] [blame] | 121 | #define DECLARE_VISIT_INSTRUCTION(name, super) \ |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 122 | void Visit##name(H##name* instr); |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 123 | |
Nicolas Geoffray | 96f89a2 | 2014-07-11 10:57:49 +0100 | [diff] [blame] | 124 | FOR_EACH_CONCRETE_INSTRUCTION(DECLARE_VISIT_INSTRUCTION) |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 125 | |
| 126 | #undef DECLARE_VISIT_INSTRUCTION |
| 127 | |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 128 | ArmAssembler* GetAssembler() const { return assembler_; } |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 129 | |
| 130 | private: |
Nicolas Geoffray | 3c04974 | 2014-09-24 18:10:46 +0100 | [diff] [blame] | 131 | // 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 Geoffray | 424f676 | 2014-11-03 14:51:25 +0000 | [diff] [blame] | 135 | void GenerateClassInitializationCheck(SlowPathCodeARM* slow_path, Register class_reg); |
Nicolas Geoffray | 9574c4b | 2014-11-12 13:19:37 +0000 | [diff] [blame] | 136 | void HandleBitwiseOperation(HBinaryOperation* operation); |
Calin Juravle | 9aec02f | 2014-11-18 23:06:35 +0000 | [diff] [blame] | 137 | void HandleShift(HBinaryOperation* operation); |
Calin Juravle | 52c4896 | 2014-12-16 17:02:57 +0000 | [diff] [blame] | 138 | 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 Geoffray | 3c04974 | 2014-09-24 18:10:46 +0100 | [diff] [blame] | 147 | |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 148 | ArmAssembler* const assembler_; |
| 149 | CodeGeneratorARM* const codegen_; |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 150 | |
| 151 | DISALLOW_COPY_AND_ASSIGN(InstructionCodeGeneratorARM); |
| 152 | }; |
| 153 | |
| 154 | class CodeGeneratorARM : public CodeGenerator { |
| 155 | public: |
Calin Juravle | 3416601 | 2014-12-19 17:22:29 +0000 | [diff] [blame] | 156 | CodeGeneratorARM(HGraph* graph, const ArmInstructionSetFeatures* isa_features); |
Nicolas Geoffray | 8a16d97 | 2014-09-11 10:30:02 +0100 | [diff] [blame] | 157 | virtual ~CodeGeneratorARM() {} |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 158 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 159 | 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 Geoffray | 840e546 | 2015-01-07 16:01:24 +0000 | [diff] [blame] | 165 | 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 Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 167 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 168 | size_t GetWordSize() const OVERRIDE { |
Nicolas Geoffray | 707c809 | 2014-04-04 10:50:14 +0100 | [diff] [blame] | 169 | return kArmWordSize; |
| 170 | } |
| 171 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 172 | size_t FrameEntrySpillSize() const OVERRIDE; |
Nicolas Geoffray | ab032bc | 2014-07-15 12:55:21 +0100 | [diff] [blame] | 173 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 174 | HGraphVisitor* GetLocationBuilder() OVERRIDE { |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 175 | return &location_builder_; |
| 176 | } |
| 177 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 178 | HGraphVisitor* GetInstructionVisitor() OVERRIDE { |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 179 | return &instruction_visitor_; |
| 180 | } |
| 181 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 182 | ArmAssembler* GetAssembler() OVERRIDE { |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 183 | return &assembler_; |
| 184 | } |
| 185 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 186 | uintptr_t GetAddressOf(HBasicBlock* block) const OVERRIDE { |
| 187 | return GetLabelOf(block)->Position(); |
| 188 | } |
Calin Juravle | 34bacdf | 2014-10-07 20:23:36 +0100 | [diff] [blame] | 189 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 190 | void SetupBlockedRegisters() const OVERRIDE; |
Nicolas Geoffray | a7aca37 | 2014-04-28 17:47:12 +0100 | [diff] [blame] | 191 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 192 | Location AllocateFreeRegister(Primitive::Type type) const OVERRIDE; |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 193 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 194 | 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 Geoffray | a7062e0 | 2014-05-22 12:50:17 +0100 | [diff] [blame] | 198 | |
Calin Juravle | 34bacdf | 2014-10-07 20:23:36 +0100 | [diff] [blame] | 199 | // Blocks all register pairs made out of blocked core registers. |
| 200 | void UpdateBlockedPairRegisters() const; |
| 201 | |
Nicolas Geoffray | f0e3937 | 2014-11-12 17:50:07 +0000 | [diff] [blame] | 202 | ParallelMoveResolverARM* GetMoveResolver() OVERRIDE { |
Nicolas Geoffray | e27f31a | 2014-06-12 17:53:14 +0100 | [diff] [blame] | 203 | return &move_resolver_; |
| 204 | } |
| 205 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 206 | InstructionSet GetInstructionSet() const OVERRIDE { |
Nicolas Geoffray | 8d48673 | 2014-07-16 16:23:40 +0100 | [diff] [blame] | 207 | return InstructionSet::kThumb2; |
Nicolas Geoffray | 412f10c | 2014-06-19 10:00:34 +0100 | [diff] [blame] | 208 | } |
| 209 | |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 210 | // 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 Geoffray | 19a19cf | 2014-10-22 16:07:05 +0100 | [diff] [blame] | 215 | // 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 Geoffray | 3c7bb98 | 2014-07-23 16:04:16 +0100 | [diff] [blame] | 221 | // Emit a write barrier. |
| 222 | void MarkGCCard(Register temp, Register card, Register object, Register value); |
| 223 | |
Nicolas Geoffray | 92a73ae | 2014-10-16 11:12:52 +0100 | [diff] [blame] | 224 | Label* GetLabelOf(HBasicBlock* block) const { |
| 225 | return block_labels_.GetRawStorage() + block->GetBlockId(); |
| 226 | } |
| 227 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 228 | void Initialize() OVERRIDE { |
Nicolas Geoffray | 92a73ae | 2014-10-16 11:12:52 +0100 | [diff] [blame] | 229 | block_labels_.SetSize(GetGraph()->GetBlocks().Size()); |
| 230 | } |
| 231 | |
Calin Juravle | 3416601 | 2014-12-19 17:22:29 +0000 | [diff] [blame] | 232 | const ArmInstructionSetFeatures* GetInstructionSetFeatures() const { |
| 233 | return isa_features_; |
| 234 | } |
| 235 | |
Nicolas Geoffray | 840e546 | 2015-01-07 16:01:24 +0000 | [diff] [blame] | 236 | bool NeedsTwoRegisters(Primitive::Type type) const OVERRIDE { |
| 237 | return type == Primitive::kPrimDouble || type == Primitive::kPrimLong; |
| 238 | } |
| 239 | |
Nicolas Geoffray | 3c7bb98 | 2014-07-23 16:04:16 +0100 | [diff] [blame] | 240 | private: |
Nicolas Geoffray | 92a73ae | 2014-10-16 11:12:52 +0100 | [diff] [blame] | 241 | // Labels for each block that will be compiled. |
| 242 | GrowableArray<Label> block_labels_; |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 243 | LocationsBuilderARM location_builder_; |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 244 | InstructionCodeGeneratorARM instruction_visitor_; |
Nicolas Geoffray | e27f31a | 2014-06-12 17:53:14 +0100 | [diff] [blame] | 245 | ParallelMoveResolverARM move_resolver_; |
Nicolas Geoffray | 8d48673 | 2014-07-16 16:23:40 +0100 | [diff] [blame] | 246 | Thumb2Assembler assembler_; |
Calin Juravle | 3416601 | 2014-12-19 17:22:29 +0000 | [diff] [blame] | 247 | const ArmInstructionSetFeatures* isa_features_; |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 248 | |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 249 | DISALLOW_COPY_AND_ASSIGN(CodeGeneratorARM); |
| 250 | }; |
| 251 | |
| 252 | } // namespace arm |
| 253 | } // namespace art |
| 254 | |
| 255 | #endif // ART_COMPILER_OPTIMIZING_CODE_GENERATOR_ARM_H_ |