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_H_ |
| 18 | #define ART_COMPILER_OPTIMIZING_CODE_GENERATOR_H_ |
| 19 | |
Ian Rogers | d582fa4 | 2014-11-05 23:46:43 -0800 | [diff] [blame] | 20 | #include "arch/instruction_set.h" |
Calin Juravle | 3416601 | 2014-12-19 17:22:29 +0000 | [diff] [blame] | 21 | #include "arch/instruction_set_features.h" |
Vladimir Marko | f9f6441 | 2015-09-02 14:05:49 +0100 | [diff] [blame] | 22 | #include "base/arena_containers.h" |
| 23 | #include "base/arena_object.h" |
Nicolas Geoffray | 01bc96d | 2014-04-11 17:43:50 +0100 | [diff] [blame] | 24 | #include "base/bit_field.h" |
Calin Juravle | cd6dffe | 2015-01-08 17:35:35 +0000 | [diff] [blame] | 25 | #include "driver/compiler_options.h" |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 26 | #include "globals.h" |
Alexandre Rames | eb7b739 | 2015-06-19 14:47:01 +0100 | [diff] [blame] | 27 | #include "graph_visualizer.h" |
Nicolas Geoffray | 4e3d23a | 2014-05-22 18:32:45 +0100 | [diff] [blame] | 28 | #include "locations.h" |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 29 | #include "memory_region.h" |
| 30 | #include "nodes.h" |
Serban Constantinescu | ecc4366 | 2015-08-13 13:33:12 +0100 | [diff] [blame] | 31 | #include "optimizing_compiler_stats.h" |
Nicolas Geoffray | 3946844 | 2014-09-02 15:17:15 +0100 | [diff] [blame] | 32 | #include "stack_map_stream.h" |
Andreas Gampe | 85b62f2 | 2015-09-09 13:15:38 -0700 | [diff] [blame^] | 33 | #include "utils/label.h" |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 34 | |
| 35 | namespace art { |
| 36 | |
Roland Levillain | 6d0e483 | 2014-11-27 18:31:21 +0000 | [diff] [blame] | 37 | // Binary encoding of 2^32 for type double. |
| 38 | static int64_t constexpr k2Pow32EncodingForDouble = INT64_C(0x41F0000000000000); |
| 39 | // Binary encoding of 2^31 for type double. |
| 40 | static int64_t constexpr k2Pow31EncodingForDouble = INT64_C(0x41E0000000000000); |
| 41 | |
Mark Mendell | e82549b | 2015-05-06 10:55:34 -0400 | [diff] [blame] | 42 | // Minimum value for a primitive integer. |
| 43 | static int32_t constexpr kPrimIntMin = 0x80000000; |
| 44 | // Minimum value for a primitive long. |
| 45 | static int64_t constexpr kPrimLongMin = INT64_C(0x8000000000000000); |
| 46 | |
Roland Levillain | 3f8f936 | 2014-12-02 17:45:01 +0000 | [diff] [blame] | 47 | // Maximum value for a primitive integer. |
| 48 | static int32_t constexpr kPrimIntMax = 0x7fffffff; |
Roland Levillain | 624279f | 2014-12-04 11:54:28 +0000 | [diff] [blame] | 49 | // Maximum value for a primitive long. |
Mark Mendell | e82549b | 2015-05-06 10:55:34 -0400 | [diff] [blame] | 50 | static int64_t constexpr kPrimLongMax = INT64_C(0x7fffffffffffffff); |
Roland Levillain | 3f8f936 | 2014-12-02 17:45:01 +0000 | [diff] [blame] | 51 | |
Nicolas Geoffray | 92a73ae | 2014-10-16 11:12:52 +0100 | [diff] [blame] | 52 | class Assembler; |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 53 | class CodeGenerator; |
Nicolas Geoffray | 92cf83e | 2014-03-18 17:59:20 +0000 | [diff] [blame] | 54 | class DexCompilationUnit; |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 55 | class LinkerPatch; |
Nicolas Geoffray | f0e3937 | 2014-11-12 17:50:07 +0000 | [diff] [blame] | 56 | class ParallelMoveResolver; |
Andreas Gampe | e21dc3d | 2014-12-08 16:59:43 -0800 | [diff] [blame] | 57 | class SrcMapElem; |
| 58 | template <class Alloc> |
Yevgeny Rouban | e3ea838 | 2014-08-08 16:29:38 +0700 | [diff] [blame] | 59 | class SrcMap; |
Andreas Gampe | e21dc3d | 2014-12-08 16:59:43 -0800 | [diff] [blame] | 60 | using DefaultSrcMap = SrcMap<std::allocator<SrcMapElem>>; |
Nicolas Geoffray | 92cf83e | 2014-03-18 17:59:20 +0000 | [diff] [blame] | 61 | |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 62 | class CodeAllocator { |
| 63 | public: |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 64 | CodeAllocator() {} |
| 65 | virtual ~CodeAllocator() {} |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 66 | |
| 67 | virtual uint8_t* Allocate(size_t size) = 0; |
| 68 | |
| 69 | private: |
| 70 | DISALLOW_COPY_AND_ASSIGN(CodeAllocator); |
| 71 | }; |
| 72 | |
Ian Rogers | 6a3c1fc | 2014-10-31 00:33:20 -0700 | [diff] [blame] | 73 | class SlowPathCode : public ArenaObject<kArenaAllocSlowPaths> { |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 74 | public: |
Nicolas Geoffray | eeefa12 | 2015-03-13 18:52:59 +0000 | [diff] [blame] | 75 | SlowPathCode() { |
| 76 | for (size_t i = 0; i < kMaximumNumberOfExpectedRegisters; ++i) { |
| 77 | saved_core_stack_offsets_[i] = kRegisterNotSaved; |
| 78 | saved_fpu_stack_offsets_[i] = kRegisterNotSaved; |
| 79 | } |
| 80 | } |
| 81 | |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 82 | virtual ~SlowPathCode() {} |
| 83 | |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 84 | virtual void EmitNativeCode(CodeGenerator* codegen) = 0; |
| 85 | |
Zheng Xu | da40309 | 2015-04-24 17:35:39 +0800 | [diff] [blame] | 86 | virtual void SaveLiveRegisters(CodeGenerator* codegen, LocationSummary* locations); |
| 87 | virtual void RestoreLiveRegisters(CodeGenerator* codegen, LocationSummary* locations); |
Nicolas Geoffray | a8ac913 | 2015-03-13 16:36:36 +0000 | [diff] [blame] | 88 | |
Nicolas Geoffray | eeefa12 | 2015-03-13 18:52:59 +0000 | [diff] [blame] | 89 | bool IsCoreRegisterSaved(int reg) const { |
| 90 | return saved_core_stack_offsets_[reg] != kRegisterNotSaved; |
| 91 | } |
| 92 | |
| 93 | bool IsFpuRegisterSaved(int reg) const { |
| 94 | return saved_fpu_stack_offsets_[reg] != kRegisterNotSaved; |
| 95 | } |
| 96 | |
| 97 | uint32_t GetStackOffsetOfCoreRegister(int reg) const { |
| 98 | return saved_core_stack_offsets_[reg]; |
| 99 | } |
| 100 | |
| 101 | uint32_t GetStackOffsetOfFpuRegister(int reg) const { |
| 102 | return saved_fpu_stack_offsets_[reg]; |
| 103 | } |
| 104 | |
Alexandre Rames | 8158f28 | 2015-08-07 10:26:17 +0100 | [diff] [blame] | 105 | virtual bool IsFatal() const { return false; } |
| 106 | |
Alexandre Rames | 9931f31 | 2015-06-19 14:47:01 +0100 | [diff] [blame] | 107 | virtual const char* GetDescription() const = 0; |
| 108 | |
Andreas Gampe | 85b62f2 | 2015-09-09 13:15:38 -0700 | [diff] [blame^] | 109 | Label* GetEntryLabel() { return &entry_label_; } |
| 110 | Label* GetExitLabel() { return &exit_label_; } |
| 111 | |
Zheng Xu | da40309 | 2015-04-24 17:35:39 +0800 | [diff] [blame] | 112 | protected: |
Nicolas Geoffray | eeefa12 | 2015-03-13 18:52:59 +0000 | [diff] [blame] | 113 | static constexpr size_t kMaximumNumberOfExpectedRegisters = 32; |
| 114 | static constexpr uint32_t kRegisterNotSaved = -1; |
| 115 | uint32_t saved_core_stack_offsets_[kMaximumNumberOfExpectedRegisters]; |
| 116 | uint32_t saved_fpu_stack_offsets_[kMaximumNumberOfExpectedRegisters]; |
Zheng Xu | da40309 | 2015-04-24 17:35:39 +0800 | [diff] [blame] | 117 | |
| 118 | private: |
Andreas Gampe | 85b62f2 | 2015-09-09 13:15:38 -0700 | [diff] [blame^] | 119 | Label entry_label_; |
| 120 | Label exit_label_; |
| 121 | |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 122 | DISALLOW_COPY_AND_ASSIGN(SlowPathCode); |
| 123 | }; |
| 124 | |
Roland Levillain | 2d27c8e | 2015-04-28 15:48:45 +0100 | [diff] [blame] | 125 | class InvokeDexCallingConventionVisitor { |
| 126 | public: |
| 127 | virtual Location GetNextLocation(Primitive::Type type) = 0; |
Nicolas Geoffray | fd88f16 | 2015-06-03 11:23:52 +0100 | [diff] [blame] | 128 | virtual Location GetReturnLocation(Primitive::Type type) const = 0; |
| 129 | virtual Location GetMethodLocation() const = 0; |
Roland Levillain | 2d27c8e | 2015-04-28 15:48:45 +0100 | [diff] [blame] | 130 | |
| 131 | protected: |
| 132 | InvokeDexCallingConventionVisitor() {} |
| 133 | virtual ~InvokeDexCallingConventionVisitor() {} |
| 134 | |
| 135 | // The current index for core registers. |
| 136 | uint32_t gp_index_ = 0u; |
| 137 | // The current index for floating-point registers. |
| 138 | uint32_t float_index_ = 0u; |
| 139 | // The current stack index. |
| 140 | uint32_t stack_index_ = 0u; |
| 141 | |
| 142 | private: |
| 143 | DISALLOW_COPY_AND_ASSIGN(InvokeDexCallingConventionVisitor); |
| 144 | }; |
| 145 | |
Nicolas Geoffray | 12df9eb | 2015-01-09 14:53:50 +0000 | [diff] [blame] | 146 | class CodeGenerator { |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 147 | public: |
| 148 | // Compiles the graph to executable instructions. Returns whether the compilation |
| 149 | // succeeded. |
Nicolas Geoffray | 73e80c3 | 2014-07-22 17:47:56 +0100 | [diff] [blame] | 150 | void CompileBaseline(CodeAllocator* allocator, bool is_leaf = false); |
Nicolas Geoffray | 86dbb9a | 2014-06-04 11:12:39 +0100 | [diff] [blame] | 151 | void CompileOptimized(CodeAllocator* allocator); |
Nicolas Geoffray | 12df9eb | 2015-01-09 14:53:50 +0000 | [diff] [blame] | 152 | static CodeGenerator* Create(HGraph* graph, |
Calin Juravle | 3416601 | 2014-12-19 17:22:29 +0000 | [diff] [blame] | 153 | InstructionSet instruction_set, |
Calin Juravle | cd6dffe | 2015-01-08 17:35:35 +0000 | [diff] [blame] | 154 | const InstructionSetFeatures& isa_features, |
Serban Constantinescu | ecc4366 | 2015-08-13 13:33:12 +0100 | [diff] [blame] | 155 | const CompilerOptions& compiler_options, |
| 156 | OptimizingCompilerStats* stats = nullptr); |
Nicolas Geoffray | 12df9eb | 2015-01-09 14:53:50 +0000 | [diff] [blame] | 157 | virtual ~CodeGenerator() {} |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 158 | |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 159 | HGraph* GetGraph() const { return graph_; } |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 160 | |
Nicolas Geoffray | dc23d83 | 2015-02-16 11:15:43 +0000 | [diff] [blame] | 161 | HBasicBlock* GetNextBlockToEmit() const; |
| 162 | HBasicBlock* FirstNonEmptyBlock(HBasicBlock* block) const; |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 163 | bool GoesToNextBlock(HBasicBlock* current, HBasicBlock* next) const; |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 164 | |
Nicolas Geoffray | 86dbb9a | 2014-06-04 11:12:39 +0100 | [diff] [blame] | 165 | size_t GetStackSlotOfParameter(HParameterValue* parameter) const { |
| 166 | // Note that this follows the current calling convention. |
| 167 | return GetFrameSize() |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 168 | + InstructionSetPointerSize(GetInstructionSet()) // Art method |
Nicolas Geoffray | e27f31a | 2014-06-12 17:53:14 +0100 | [diff] [blame] | 169 | + parameter->GetIndex() * kVRegSize; |
Nicolas Geoffray | 86dbb9a | 2014-06-04 11:12:39 +0100 | [diff] [blame] | 170 | } |
| 171 | |
Nicolas Geoffray | 92a73ae | 2014-10-16 11:12:52 +0100 | [diff] [blame] | 172 | virtual void Initialize() = 0; |
Serban Constantinescu | 32f5b4d | 2014-11-25 20:05:46 +0000 | [diff] [blame] | 173 | virtual void Finalize(CodeAllocator* allocator); |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 174 | virtual void EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches); |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 175 | virtual void GenerateFrameEntry() = 0; |
| 176 | virtual void GenerateFrameExit() = 0; |
Nicolas Geoffray | 92a73ae | 2014-10-16 11:12:52 +0100 | [diff] [blame] | 177 | virtual void Bind(HBasicBlock* block) = 0; |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 178 | virtual void Move(HInstruction* instruction, Location location, HInstruction* move_for) = 0; |
Calin Juravle | 175dc73 | 2015-08-25 15:42:32 +0100 | [diff] [blame] | 179 | virtual void MoveConstant(Location destination, int32_t value) = 0; |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 180 | virtual Assembler* GetAssembler() = 0; |
Alexandre Rames | eb7b739 | 2015-06-19 14:47:01 +0100 | [diff] [blame] | 181 | virtual const Assembler& GetAssembler() const = 0; |
Nicolas Geoffray | 707c809 | 2014-04-04 10:50:14 +0100 | [diff] [blame] | 182 | virtual size_t GetWordSize() const = 0; |
Mark Mendell | f85a9ca | 2015-01-13 09:20:58 -0500 | [diff] [blame] | 183 | virtual size_t GetFloatingPointSpillSlotSize() const = 0; |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 184 | virtual uintptr_t GetAddressOf(HBasicBlock* block) const = 0; |
Nicolas Geoffray | 4c204ba | 2015-02-03 15:12:35 +0000 | [diff] [blame] | 185 | void InitializeCodeGeneration(size_t number_of_spill_slots, |
| 186 | size_t maximum_number_of_live_core_registers, |
| 187 | size_t maximum_number_of_live_fp_registers, |
| 188 | size_t number_of_out_slots, |
Vladimir Marko | fa6b93c | 2015-09-15 10:15:55 +0100 | [diff] [blame] | 189 | const ArenaVector<HBasicBlock*>& block_order); |
Nicolas Geoffray | ab032bc | 2014-07-15 12:55:21 +0100 | [diff] [blame] | 190 | int32_t GetStackSlot(HLocal* local) const; |
| 191 | Location GetTemporaryLocation(HTemporary* temp) const; |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 192 | |
| 193 | uint32_t GetFrameSize() const { return frame_size_; } |
| 194 | void SetFrameSize(uint32_t size) { frame_size_ = size; } |
Nicolas Geoffray | 8ccc3f5 | 2014-03-19 10:34:11 +0000 | [diff] [blame] | 195 | uint32_t GetCoreSpillMask() const { return core_spill_mask_; } |
Nicolas Geoffray | d97dc40 | 2015-01-22 13:50:01 +0000 | [diff] [blame] | 196 | uint32_t GetFpuSpillMask() const { return fpu_spill_mask_; } |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 197 | |
Nicolas Geoffray | 71175b7 | 2014-10-09 22:13:55 +0100 | [diff] [blame] | 198 | size_t GetNumberOfCoreRegisters() const { return number_of_core_registers_; } |
| 199 | size_t GetNumberOfFloatingPointRegisters() const { return number_of_fpu_registers_; } |
Nicolas Geoffray | 9889396 | 2015-01-21 12:32:32 +0000 | [diff] [blame] | 200 | virtual void SetupBlockedRegisters(bool is_baseline) const = 0; |
Nicolas Geoffray | 71175b7 | 2014-10-09 22:13:55 +0100 | [diff] [blame] | 201 | |
Nicolas Geoffray | 4dee636 | 2015-01-23 18:23:14 +0000 | [diff] [blame] | 202 | virtual void ComputeSpillMask() { |
| 203 | core_spill_mask_ = allocated_registers_.GetCoreRegisters() & core_callee_save_mask_; |
| 204 | DCHECK_NE(core_spill_mask_, 0u) << "At least the return address register must be saved"; |
| 205 | fpu_spill_mask_ = allocated_registers_.GetFloatingPointRegisters() & fpu_callee_save_mask_; |
| 206 | } |
| 207 | |
| 208 | static uint32_t ComputeRegisterMask(const int* registers, size_t length) { |
| 209 | uint32_t mask = 0; |
| 210 | for (size_t i = 0, e = length; i < e; ++i) { |
| 211 | mask |= (1 << registers[i]); |
| 212 | } |
| 213 | return mask; |
| 214 | } |
| 215 | |
Nicolas Geoffray | a7062e0 | 2014-05-22 12:50:17 +0100 | [diff] [blame] | 216 | virtual void DumpCoreRegister(std::ostream& stream, int reg) const = 0; |
| 217 | virtual void DumpFloatingPointRegister(std::ostream& stream, int reg) const = 0; |
Nicolas Geoffray | 412f10c | 2014-06-19 10:00:34 +0100 | [diff] [blame] | 218 | virtual InstructionSet GetInstructionSet() const = 0; |
Calin Juravle | cd6dffe | 2015-01-08 17:35:35 +0000 | [diff] [blame] | 219 | |
| 220 | const CompilerOptions& GetCompilerOptions() const { return compiler_options_; } |
| 221 | |
Serban Constantinescu | ecc4366 | 2015-08-13 13:33:12 +0100 | [diff] [blame] | 222 | void MaybeRecordStat(MethodCompilationStat compilation_stat, size_t count = 1) const; |
| 223 | |
Nicolas Geoffray | 102cbed | 2014-10-15 18:31:05 +0100 | [diff] [blame] | 224 | // Saves the register in the stack. Returns the size taken on stack. |
| 225 | virtual size_t SaveCoreRegister(size_t stack_index, uint32_t reg_id) = 0; |
| 226 | // Restores the register from the stack. Returns the size taken on stack. |
| 227 | virtual size_t RestoreCoreRegister(size_t stack_index, uint32_t reg_id) = 0; |
Nicolas Geoffray | 234d69d | 2015-03-09 10:28:50 +0000 | [diff] [blame] | 228 | |
| 229 | virtual size_t SaveFloatingPointRegister(size_t stack_index, uint32_t reg_id) = 0; |
| 230 | virtual size_t RestoreFloatingPointRegister(size_t stack_index, uint32_t reg_id) = 0; |
| 231 | |
Nicolas Geoffray | 840e546 | 2015-01-07 16:01:24 +0000 | [diff] [blame] | 232 | virtual bool NeedsTwoRegisters(Primitive::Type type) const = 0; |
Nicolas Geoffray | 234d69d | 2015-03-09 10:28:50 +0000 | [diff] [blame] | 233 | // Returns whether we should split long moves in parallel moves. |
| 234 | virtual bool ShouldSplitLongMoves() const { return false; } |
Nicolas Geoffray | a7062e0 | 2014-05-22 12:50:17 +0100 | [diff] [blame] | 235 | |
Nicolas Geoffray | 9889396 | 2015-01-21 12:32:32 +0000 | [diff] [blame] | 236 | bool IsCoreCalleeSaveRegister(int reg) const { |
| 237 | return (core_callee_save_mask_ & (1 << reg)) != 0; |
| 238 | } |
| 239 | |
| 240 | bool IsFloatingPointCalleeSaveRegister(int reg) const { |
| 241 | return (fpu_callee_save_mask_ & (1 << reg)) != 0; |
| 242 | } |
| 243 | |
Yevgeny Rouban | 2a7c1ef | 2015-07-22 18:36:24 +0600 | [diff] [blame] | 244 | // Record native to dex mapping for a suspend point. Required by runtime. |
Nicolas Geoffray | eeefa12 | 2015-03-13 18:52:59 +0000 | [diff] [blame] | 245 | void RecordPcInfo(HInstruction* instruction, uint32_t dex_pc, SlowPathCode* slow_path = nullptr); |
Yevgeny Rouban | 2a7c1ef | 2015-07-22 18:36:24 +0600 | [diff] [blame] | 246 | // Record additional native to dex mappings for native debugging/profiling tools. |
| 247 | void RecordNativeDebugInfo(uint32_t dex_pc, uintptr_t native_pc_begin, uintptr_t native_pc_end); |
| 248 | |
Calin Juravle | 77520bc | 2015-01-12 18:45:46 +0000 | [diff] [blame] | 249 | bool CanMoveNullCheckToUser(HNullCheck* null_check); |
| 250 | void MaybeRecordImplicitNullCheck(HInstruction* instruction); |
Nicolas Geoffray | 8ccc3f5 | 2014-03-19 10:34:11 +0000 | [diff] [blame] | 251 | |
David Brazdil | 77a48ae | 2015-09-15 12:34:04 +0000 | [diff] [blame] | 252 | // Records a stack map which the runtime might use to set catch phi values |
| 253 | // during exception delivery. |
| 254 | // TODO: Replace with a catch-entering instruction that records the environment. |
| 255 | void RecordCatchBlockInfo(); |
| 256 | |
| 257 | // Returns true if implicit null checks are allowed in the compiler options |
| 258 | // and if the null check is not inside a try block. We currently cannot do |
| 259 | // implicit null checks in that case because we need the NullCheckSlowPath to |
| 260 | // save live registers, which may be needed by the runtime to set catch phis. |
| 261 | bool IsImplicitNullCheckAllowed(HNullCheck* null_check) const; |
| 262 | |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 263 | void AddSlowPath(SlowPathCode* slow_path) { |
| 264 | slow_paths_.Add(slow_path); |
| 265 | } |
| 266 | |
Yevgeny Rouban | 2a7c1ef | 2015-07-22 18:36:24 +0600 | [diff] [blame] | 267 | void SetSrcMap(DefaultSrcMap* src_map) { src_map_ = src_map; } |
| 268 | |
Vladimir Marko | f9f6441 | 2015-09-02 14:05:49 +0100 | [diff] [blame] | 269 | void BuildMappingTable(ArenaVector<uint8_t>* vector) const; |
| 270 | void BuildVMapTable(ArenaVector<uint8_t>* vector) const; |
Nicolas Geoffray | 92cf83e | 2014-03-18 17:59:20 +0000 | [diff] [blame] | 271 | void BuildNativeGCMap( |
Vladimir Marko | f9f6441 | 2015-09-02 14:05:49 +0100 | [diff] [blame] | 272 | ArenaVector<uint8_t>* vector, const DexCompilationUnit& dex_compilation_unit) const; |
| 273 | void BuildStackMaps(ArenaVector<uint8_t>* vector); |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 274 | |
Roland Levillain | 3e3d733 | 2015-04-28 11:00:54 +0100 | [diff] [blame] | 275 | bool IsBaseline() const { |
| 276 | return is_baseline_; |
| 277 | } |
| 278 | |
Nicolas Geoffray | f12feb8 | 2014-07-17 18:32:41 +0100 | [diff] [blame] | 279 | bool IsLeafMethod() const { |
| 280 | return is_leaf_; |
| 281 | } |
| 282 | |
| 283 | void MarkNotLeaf() { |
| 284 | is_leaf_ = false; |
Nicolas Geoffray | c0572a4 | 2015-02-06 14:35:25 +0000 | [diff] [blame] | 285 | requires_current_method_ = true; |
| 286 | } |
| 287 | |
| 288 | void SetRequiresCurrentMethod() { |
| 289 | requires_current_method_ = true; |
| 290 | } |
| 291 | |
| 292 | bool RequiresCurrentMethod() const { |
| 293 | return requires_current_method_; |
Nicolas Geoffray | f12feb8 | 2014-07-17 18:32:41 +0100 | [diff] [blame] | 294 | } |
| 295 | |
Nicolas Geoffray | 3c04974 | 2014-09-24 18:10:46 +0100 | [diff] [blame] | 296 | // Clears the spill slots taken by loop phis in the `LocationSummary` of the |
| 297 | // suspend check. This is called when the code generator generates code |
| 298 | // for the suspend check at the back edge (instead of where the suspend check |
| 299 | // is, which is the loop entry). At this point, the spill slots for the phis |
| 300 | // have not been written to. |
| 301 | void ClearSpillSlotsFromLoopPhisInStackMap(HSuspendCheck* suspend_check) const; |
| 302 | |
Nicolas Geoffray | 71175b7 | 2014-10-09 22:13:55 +0100 | [diff] [blame] | 303 | bool* GetBlockedCoreRegisters() const { return blocked_core_registers_; } |
Nicolas Geoffray | 102cbed | 2014-10-15 18:31:05 +0100 | [diff] [blame] | 304 | bool* GetBlockedFloatingPointRegisters() const { return blocked_fpu_registers_; } |
Nicolas Geoffray | 71175b7 | 2014-10-09 22:13:55 +0100 | [diff] [blame] | 305 | |
Nicolas Geoffray | 19a19cf | 2014-10-22 16:07:05 +0100 | [diff] [blame] | 306 | // Helper that returns the pointer offset of an index in an object array. |
| 307 | // Note: this method assumes we always have the same pointer size, regardless |
| 308 | // of the architecture. |
| 309 | static size_t GetCacheOffset(uint32_t index); |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 310 | // Pointer variant for ArtMethod and ArtField arrays. |
| 311 | size_t GetCachePointerOffset(uint32_t index); |
Nicolas Geoffray | 19a19cf | 2014-10-22 16:07:05 +0100 | [diff] [blame] | 312 | |
Nicolas Geoffray | 9021825 | 2015-04-15 11:56:51 +0100 | [diff] [blame] | 313 | void EmitParallelMoves(Location from1, |
| 314 | Location to1, |
| 315 | Primitive::Type type1, |
| 316 | Location from2, |
| 317 | Location to2, |
| 318 | Primitive::Type type2); |
Nicolas Geoffray | f0e3937 | 2014-11-12 17:50:07 +0000 | [diff] [blame] | 319 | |
Nicolas Geoffray | af07bc1 | 2014-11-12 18:08:09 +0000 | [diff] [blame] | 320 | static bool StoreNeedsWriteBarrier(Primitive::Type type, HInstruction* value) { |
David Brazdil | 522e224 | 2015-03-17 18:48:28 +0000 | [diff] [blame] | 321 | // Check that null value is not represented as an integer constant. |
| 322 | DCHECK(type != Primitive::kPrimNot || !value->IsIntConstant()); |
| 323 | return type == Primitive::kPrimNot && !value->IsNullConstant(); |
Nicolas Geoffray | af07bc1 | 2014-11-12 18:08:09 +0000 | [diff] [blame] | 324 | } |
| 325 | |
Alexandre Rames | 78e3ef6 | 2015-08-12 13:43:29 +0100 | [diff] [blame] | 326 | void ValidateInvokeRuntime(HInstruction* instruction, SlowPathCode* slow_path); |
| 327 | |
Nicolas Geoffray | 9889396 | 2015-01-21 12:32:32 +0000 | [diff] [blame] | 328 | void AddAllocatedRegister(Location location) { |
| 329 | allocated_registers_.Add(location); |
| 330 | } |
| 331 | |
Nicolas Geoffray | 45b83af | 2015-07-06 15:12:53 +0000 | [diff] [blame] | 332 | bool HasAllocatedRegister(bool is_core, int reg) const { |
| 333 | return is_core |
| 334 | ? allocated_registers_.ContainsCoreRegister(reg) |
| 335 | : allocated_registers_.ContainsFloatingPointRegister(reg); |
| 336 | } |
| 337 | |
Nicolas Geoffray | c0572a4 | 2015-02-06 14:35:25 +0000 | [diff] [blame] | 338 | void AllocateLocations(HInstruction* instruction); |
| 339 | |
Roland Levillain | aa9b7c4 | 2015-02-17 15:40:09 +0000 | [diff] [blame] | 340 | // Tells whether the stack frame of the compiled method is |
| 341 | // considered "empty", that is either actually having a size of zero, |
| 342 | // or just containing the saved return address register. |
| 343 | bool HasEmptyFrame() const { |
| 344 | return GetFrameSize() == (CallPushesPC() ? GetWordSize() : 0); |
| 345 | } |
| 346 | |
Nicolas Geoffray | d6138ef | 2015-02-18 14:48:53 +0000 | [diff] [blame] | 347 | static int32_t GetInt32ValueOf(HConstant* constant) { |
| 348 | if (constant->IsIntConstant()) { |
| 349 | return constant->AsIntConstant()->GetValue(); |
| 350 | } else if (constant->IsNullConstant()) { |
| 351 | return 0; |
| 352 | } else { |
| 353 | DCHECK(constant->IsFloatConstant()); |
Roland Levillain | da4d79b | 2015-03-24 14:36:11 +0000 | [diff] [blame] | 354 | return bit_cast<int32_t, float>(constant->AsFloatConstant()->GetValue()); |
Nicolas Geoffray | d6138ef | 2015-02-18 14:48:53 +0000 | [diff] [blame] | 355 | } |
| 356 | } |
| 357 | |
| 358 | static int64_t GetInt64ValueOf(HConstant* constant) { |
| 359 | if (constant->IsIntConstant()) { |
| 360 | return constant->AsIntConstant()->GetValue(); |
| 361 | } else if (constant->IsNullConstant()) { |
| 362 | return 0; |
| 363 | } else if (constant->IsFloatConstant()) { |
Roland Levillain | da4d79b | 2015-03-24 14:36:11 +0000 | [diff] [blame] | 364 | return bit_cast<int32_t, float>(constant->AsFloatConstant()->GetValue()); |
Nicolas Geoffray | d6138ef | 2015-02-18 14:48:53 +0000 | [diff] [blame] | 365 | } else if (constant->IsLongConstant()) { |
| 366 | return constant->AsLongConstant()->GetValue(); |
| 367 | } else { |
| 368 | DCHECK(constant->IsDoubleConstant()); |
Roland Levillain | da4d79b | 2015-03-24 14:36:11 +0000 | [diff] [blame] | 369 | return bit_cast<int64_t, double>(constant->AsDoubleConstant()->GetValue()); |
Nicolas Geoffray | d6138ef | 2015-02-18 14:48:53 +0000 | [diff] [blame] | 370 | } |
| 371 | } |
| 372 | |
Nicolas Geoffray | a8ac913 | 2015-03-13 16:36:36 +0000 | [diff] [blame] | 373 | size_t GetFirstRegisterSlotInSlowPath() const { |
| 374 | return first_register_slot_in_slow_path_; |
| 375 | } |
| 376 | |
| 377 | uint32_t FrameEntrySpillSize() const { |
| 378 | return GetFpuSpillSize() + GetCoreSpillSize(); |
| 379 | } |
| 380 | |
Roland Levillain | ec525fc | 2015-04-28 15:50:20 +0100 | [diff] [blame] | 381 | virtual ParallelMoveResolver* GetMoveResolver() = 0; |
Nicolas Geoffray | a8ac913 | 2015-03-13 16:36:36 +0000 | [diff] [blame] | 382 | |
Nicolas Geoffray | fd88f16 | 2015-06-03 11:23:52 +0100 | [diff] [blame] | 383 | static void CreateCommonInvokeLocationSummary( |
| 384 | HInvoke* invoke, InvokeDexCallingConventionVisitor* visitor); |
| 385 | |
Calin Juravle | 175dc73 | 2015-08-25 15:42:32 +0100 | [diff] [blame] | 386 | void GenerateInvokeUnresolvedRuntimeCall(HInvokeUnresolved* invoke); |
| 387 | |
Alexandre Rames | eb7b739 | 2015-06-19 14:47:01 +0100 | [diff] [blame] | 388 | void SetDisassemblyInformation(DisassemblyInformation* info) { disasm_info_ = info; } |
| 389 | DisassemblyInformation* GetDisassemblyInformation() const { return disasm_info_; } |
| 390 | |
Calin Juravle | 175dc73 | 2015-08-25 15:42:32 +0100 | [diff] [blame] | 391 | virtual void InvokeRuntime(QuickEntrypointEnum entrypoint, |
| 392 | HInstruction* instruction, |
| 393 | uint32_t dex_pc, |
| 394 | SlowPathCode* slow_path) = 0; |
| 395 | |
Andreas Gampe | 85b62f2 | 2015-09-09 13:15:38 -0700 | [diff] [blame^] | 396 | // Generate a call to a static or direct method. |
| 397 | virtual void GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke, Location temp) = 0; |
| 398 | // Generate a call to a virtual method. |
| 399 | virtual void GenerateVirtualCall(HInvokeVirtual* invoke, Location temp) = 0; |
| 400 | |
| 401 | // Copy the result of a call into the given target. |
| 402 | virtual void MoveFromReturnRegister(Location trg, Primitive::Type type) = 0; |
| 403 | |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 404 | protected: |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 405 | // Method patch info used for recording locations of required linker patches and |
| 406 | // target methods. The target method can be used for various purposes, whether for |
| 407 | // patching the address of the method or the code pointer or a PC-relative call. |
| 408 | template <typename LabelType> |
| 409 | struct MethodPatchInfo { |
| 410 | explicit MethodPatchInfo(MethodReference m) : target_method(m), label() { } |
| 411 | |
| 412 | MethodReference target_method; |
| 413 | LabelType label; |
| 414 | }; |
| 415 | |
Nicolas Geoffray | 71175b7 | 2014-10-09 22:13:55 +0100 | [diff] [blame] | 416 | CodeGenerator(HGraph* graph, |
| 417 | size_t number_of_core_registers, |
| 418 | size_t number_of_fpu_registers, |
Calin Juravle | cd6dffe | 2015-01-08 17:35:35 +0000 | [diff] [blame] | 419 | size_t number_of_register_pairs, |
Nicolas Geoffray | 9889396 | 2015-01-21 12:32:32 +0000 | [diff] [blame] | 420 | uint32_t core_callee_save_mask, |
| 421 | uint32_t fpu_callee_save_mask, |
Serban Constantinescu | ecc4366 | 2015-08-13 13:33:12 +0100 | [diff] [blame] | 422 | const CompilerOptions& compiler_options, |
| 423 | OptimizingCompilerStats* stats) |
Nicolas Geoffray | c0572a4 | 2015-02-06 14:35:25 +0000 | [diff] [blame] | 424 | : frame_size_(0), |
Nicolas Geoffray | 4361bef | 2014-08-20 04:59:12 +0100 | [diff] [blame] | 425 | core_spill_mask_(0), |
Nicolas Geoffray | d97dc40 | 2015-01-22 13:50:01 +0000 | [diff] [blame] | 426 | fpu_spill_mask_(0), |
Nicolas Geoffray | 3bca0df | 2014-09-19 11:01:00 +0100 | [diff] [blame] | 427 | first_register_slot_in_slow_path_(0), |
Nicolas Geoffray | 71175b7 | 2014-10-09 22:13:55 +0100 | [diff] [blame] | 428 | blocked_core_registers_(graph->GetArena()->AllocArray<bool>(number_of_core_registers)), |
| 429 | blocked_fpu_registers_(graph->GetArena()->AllocArray<bool>(number_of_fpu_registers)), |
| 430 | blocked_register_pairs_(graph->GetArena()->AllocArray<bool>(number_of_register_pairs)), |
| 431 | number_of_core_registers_(number_of_core_registers), |
| 432 | number_of_fpu_registers_(number_of_fpu_registers), |
| 433 | number_of_register_pairs_(number_of_register_pairs), |
Nicolas Geoffray | 9889396 | 2015-01-21 12:32:32 +0000 | [diff] [blame] | 434 | core_callee_save_mask_(core_callee_save_mask), |
| 435 | fpu_callee_save_mask_(fpu_callee_save_mask), |
Vladimir Marko | cf93a5c | 2015-06-16 11:33:24 +0000 | [diff] [blame] | 436 | stack_map_stream_(graph->GetArena()), |
| 437 | block_order_(nullptr), |
Roland Levillain | 3e3d733 | 2015-04-28 11:00:54 +0100 | [diff] [blame] | 438 | is_baseline_(false), |
Alexandre Rames | eb7b739 | 2015-06-19 14:47:01 +0100 | [diff] [blame] | 439 | disasm_info_(nullptr), |
Serban Constantinescu | ecc4366 | 2015-08-13 13:33:12 +0100 | [diff] [blame] | 440 | stats_(stats), |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 441 | graph_(graph), |
Calin Juravle | cd6dffe | 2015-01-08 17:35:35 +0000 | [diff] [blame] | 442 | compiler_options_(compiler_options), |
Yevgeny Rouban | 2a7c1ef | 2015-07-22 18:36:24 +0600 | [diff] [blame] | 443 | src_map_(nullptr), |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 444 | slow_paths_(graph->GetArena(), 8), |
Nicolas Geoffray | 4c204ba | 2015-02-03 15:12:35 +0000 | [diff] [blame] | 445 | current_block_index_(0), |
Nicolas Geoffray | 3946844 | 2014-09-02 15:17:15 +0100 | [diff] [blame] | 446 | is_leaf_(true), |
Vladimir Marko | cf93a5c | 2015-06-16 11:33:24 +0000 | [diff] [blame] | 447 | requires_current_method_(false) {} |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 448 | |
Nicolas Geoffray | a7aca37 | 2014-04-28 17:47:12 +0100 | [diff] [blame] | 449 | // Register allocation logic. |
| 450 | void AllocateRegistersLocally(HInstruction* instruction) const; |
| 451 | |
| 452 | // Backend specific implementation for allocating a register. |
Nicolas Geoffray | 71175b7 | 2014-10-09 22:13:55 +0100 | [diff] [blame] | 453 | virtual Location AllocateFreeRegister(Primitive::Type type) const = 0; |
Nicolas Geoffray | a7aca37 | 2014-04-28 17:47:12 +0100 | [diff] [blame] | 454 | |
Nicolas Geoffray | 71175b7 | 2014-10-09 22:13:55 +0100 | [diff] [blame] | 455 | static size_t FindFreeEntry(bool* array, size_t length); |
Nicolas Geoffray | 3c03503 | 2014-10-28 10:46:40 +0000 | [diff] [blame] | 456 | static size_t FindTwoFreeConsecutiveAlignedEntries(bool* array, size_t length); |
Nicolas Geoffray | a7aca37 | 2014-04-28 17:47:12 +0100 | [diff] [blame] | 457 | |
Nicolas Geoffray | a7aca37 | 2014-04-28 17:47:12 +0100 | [diff] [blame] | 458 | virtual Location GetStackLocation(HLoadLocal* load) const = 0; |
| 459 | |
Nicolas Geoffray | c0572a4 | 2015-02-06 14:35:25 +0000 | [diff] [blame] | 460 | virtual HGraphVisitor* GetLocationBuilder() = 0; |
| 461 | virtual HGraphVisitor* GetInstructionVisitor() = 0; |
Nicolas Geoffray | f0e3937 | 2014-11-12 17:50:07 +0000 | [diff] [blame] | 462 | |
Nicolas Geoffray | d97dc40 | 2015-01-22 13:50:01 +0000 | [diff] [blame] | 463 | // Returns the location of the first spilled entry for floating point registers, |
| 464 | // relative to the stack pointer. |
| 465 | uint32_t GetFpuSpillStart() const { |
Nicolas Geoffray | d97dc40 | 2015-01-22 13:50:01 +0000 | [diff] [blame] | 466 | return GetFrameSize() - FrameEntrySpillSize(); |
| 467 | } |
| 468 | |
| 469 | uint32_t GetFpuSpillSize() const { |
| 470 | return POPCOUNT(fpu_spill_mask_) * GetFloatingPointSpillSlotSize(); |
| 471 | } |
| 472 | |
| 473 | uint32_t GetCoreSpillSize() const { |
| 474 | return POPCOUNT(core_spill_mask_) * GetWordSize(); |
| 475 | } |
| 476 | |
Nicolas Geoffray | c0572a4 | 2015-02-06 14:35:25 +0000 | [diff] [blame] | 477 | bool HasAllocatedCalleeSaveRegisters() const { |
| 478 | // We check the core registers against 1 because it always comprises the return PC. |
| 479 | return (POPCOUNT(allocated_registers_.GetCoreRegisters() & core_callee_save_mask_) != 1) |
| 480 | || (POPCOUNT(allocated_registers_.GetFloatingPointRegisters() & fpu_callee_save_mask_) != 0); |
| 481 | } |
| 482 | |
| 483 | bool CallPushesPC() const { |
| 484 | InstructionSet instruction_set = GetInstructionSet(); |
| 485 | return instruction_set == kX86 || instruction_set == kX86_64; |
| 486 | } |
| 487 | |
Nicolas Geoffray | dc23d83 | 2015-02-16 11:15:43 +0000 | [diff] [blame] | 488 | // Arm64 has its own type for a label, so we need to templatize this method |
| 489 | // to share the logic. |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 490 | template <typename LabelType> |
| 491 | LabelType* CommonGetLabelOf(LabelType* raw_pointer_to_labels_array, HBasicBlock* block) const { |
Nicolas Geoffray | dc23d83 | 2015-02-16 11:15:43 +0000 | [diff] [blame] | 492 | block = FirstNonEmptyBlock(block); |
| 493 | return raw_pointer_to_labels_array + block->GetBlockId(); |
| 494 | } |
| 495 | |
Nicolas Geoffray | 8ccc3f5 | 2014-03-19 10:34:11 +0000 | [diff] [blame] | 496 | // Frame size required for this method. |
| 497 | uint32_t frame_size_; |
| 498 | uint32_t core_spill_mask_; |
Nicolas Geoffray | d97dc40 | 2015-01-22 13:50:01 +0000 | [diff] [blame] | 499 | uint32_t fpu_spill_mask_; |
Nicolas Geoffray | 3bca0df | 2014-09-19 11:01:00 +0100 | [diff] [blame] | 500 | uint32_t first_register_slot_in_slow_path_; |
Nicolas Geoffray | 8ccc3f5 | 2014-03-19 10:34:11 +0000 | [diff] [blame] | 501 | |
Nicolas Geoffray | 9889396 | 2015-01-21 12:32:32 +0000 | [diff] [blame] | 502 | // Registers that were allocated during linear scan. |
| 503 | RegisterSet allocated_registers_; |
| 504 | |
Nicolas Geoffray | 71175b7 | 2014-10-09 22:13:55 +0100 | [diff] [blame] | 505 | // Arrays used when doing register allocation to know which |
| 506 | // registers we can allocate. `SetupBlockedRegisters` updates the |
| 507 | // arrays. |
| 508 | bool* const blocked_core_registers_; |
| 509 | bool* const blocked_fpu_registers_; |
| 510 | bool* const blocked_register_pairs_; |
| 511 | size_t number_of_core_registers_; |
| 512 | size_t number_of_fpu_registers_; |
| 513 | size_t number_of_register_pairs_; |
Nicolas Geoffray | 9889396 | 2015-01-21 12:32:32 +0000 | [diff] [blame] | 514 | const uint32_t core_callee_save_mask_; |
| 515 | const uint32_t fpu_callee_save_mask_; |
Nicolas Geoffray | 71175b7 | 2014-10-09 22:13:55 +0100 | [diff] [blame] | 516 | |
Vladimir Marko | cf93a5c | 2015-06-16 11:33:24 +0000 | [diff] [blame] | 517 | StackMapStream stack_map_stream_; |
| 518 | |
| 519 | // The order to use for code generation. |
Vladimir Marko | fa6b93c | 2015-09-15 10:15:55 +0100 | [diff] [blame] | 520 | const ArenaVector<HBasicBlock*>* block_order_; |
Vladimir Marko | cf93a5c | 2015-06-16 11:33:24 +0000 | [diff] [blame] | 521 | |
Roland Levillain | 3e3d733 | 2015-04-28 11:00:54 +0100 | [diff] [blame] | 522 | // Whether we are using baseline. |
| 523 | bool is_baseline_; |
| 524 | |
Alexandre Rames | eb7b739 | 2015-06-19 14:47:01 +0100 | [diff] [blame] | 525 | DisassemblyInformation* disasm_info_; |
| 526 | |
Nicolas Geoffray | bab4ed7 | 2014-03-11 17:53:17 +0000 | [diff] [blame] | 527 | private: |
Nicolas Geoffray | c0572a4 | 2015-02-06 14:35:25 +0000 | [diff] [blame] | 528 | void InitLocationsBaseline(HInstruction* instruction); |
Nicolas Geoffray | 3bca0df | 2014-09-19 11:01:00 +0100 | [diff] [blame] | 529 | size_t GetStackOffsetOfSavedRegister(size_t index); |
Alexandre Rames | eb7b739 | 2015-06-19 14:47:01 +0100 | [diff] [blame] | 530 | void GenerateSlowPaths(); |
Nicolas Geoffray | 4c204ba | 2015-02-03 15:12:35 +0000 | [diff] [blame] | 531 | void CompileInternal(CodeAllocator* allocator, bool is_baseline); |
Mark Mendell | 5f87418 | 2015-03-04 15:42:45 -0500 | [diff] [blame] | 532 | void BlockIfInRegister(Location location, bool is_out = false) const; |
Nicolas Geoffray | b1d0f3f | 2015-05-14 12:41:51 +0100 | [diff] [blame] | 533 | void EmitEnvironment(HEnvironment* environment, SlowPathCode* slow_path); |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 534 | |
Serban Constantinescu | ecc4366 | 2015-08-13 13:33:12 +0100 | [diff] [blame] | 535 | OptimizingCompilerStats* stats_; |
| 536 | |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 537 | HGraph* const graph_; |
Calin Juravle | cd6dffe | 2015-01-08 17:35:35 +0000 | [diff] [blame] | 538 | const CompilerOptions& compiler_options_; |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 539 | |
Yevgeny Rouban | 2a7c1ef | 2015-07-22 18:36:24 +0600 | [diff] [blame] | 540 | // Native to dex_pc map used for native debugging/profiling tools. |
| 541 | DefaultSrcMap* src_map_; |
Nicolas Geoffray | e503832 | 2014-07-04 09:41:32 +0100 | [diff] [blame] | 542 | GrowableArray<SlowPathCode*> slow_paths_; |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 543 | |
Nicolas Geoffray | 4c204ba | 2015-02-03 15:12:35 +0000 | [diff] [blame] | 544 | // The current block index in `block_order_` of the block |
| 545 | // we are generating code for. |
| 546 | size_t current_block_index_; |
| 547 | |
Nicolas Geoffray | c0572a4 | 2015-02-06 14:35:25 +0000 | [diff] [blame] | 548 | // Whether the method is a leaf method. |
Nicolas Geoffray | f12feb8 | 2014-07-17 18:32:41 +0100 | [diff] [blame] | 549 | bool is_leaf_; |
| 550 | |
Nicolas Geoffray | c0572a4 | 2015-02-06 14:35:25 +0000 | [diff] [blame] | 551 | // Whether an instruction in the graph accesses the current method. |
| 552 | bool requires_current_method_; |
| 553 | |
David Srbecky | c6b4dd8 | 2015-04-07 20:32:43 +0100 | [diff] [blame] | 554 | friend class OptimizingCFITest; |
| 555 | |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 556 | DISALLOW_COPY_AND_ASSIGN(CodeGenerator); |
| 557 | }; |
| 558 | |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 559 | template <typename C, typename F> |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 560 | class CallingConvention { |
| 561 | public: |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 562 | CallingConvention(const C* registers, |
| 563 | size_t number_of_registers, |
| 564 | const F* fpu_registers, |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 565 | size_t number_of_fpu_registers, |
| 566 | size_t pointer_size) |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 567 | : registers_(registers), |
| 568 | number_of_registers_(number_of_registers), |
| 569 | fpu_registers_(fpu_registers), |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 570 | number_of_fpu_registers_(number_of_fpu_registers), |
| 571 | pointer_size_(pointer_size) {} |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 572 | |
| 573 | size_t GetNumberOfRegisters() const { return number_of_registers_; } |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 574 | size_t GetNumberOfFpuRegisters() const { return number_of_fpu_registers_; } |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 575 | |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 576 | C GetRegisterAt(size_t index) const { |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 577 | DCHECK_LT(index, number_of_registers_); |
| 578 | return registers_[index]; |
| 579 | } |
| 580 | |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 581 | F GetFpuRegisterAt(size_t index) const { |
| 582 | DCHECK_LT(index, number_of_fpu_registers_); |
| 583 | return fpu_registers_[index]; |
| 584 | } |
| 585 | |
| 586 | size_t GetStackOffsetOf(size_t index) const { |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 587 | // We still reserve the space for parameters passed by registers. |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 588 | // Add space for the method pointer. |
| 589 | return pointer_size_ + index * kVRegSize; |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 590 | } |
| 591 | |
| 592 | private: |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 593 | const C* registers_; |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 594 | const size_t number_of_registers_; |
Nicolas Geoffray | 7fb49da | 2014-10-06 09:12:41 +0100 | [diff] [blame] | 595 | const F* fpu_registers_; |
| 596 | const size_t number_of_fpu_registers_; |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 597 | const size_t pointer_size_; |
Nicolas Geoffray | 4a34a42 | 2014-04-03 10:38:37 +0100 | [diff] [blame] | 598 | |
| 599 | DISALLOW_COPY_AND_ASSIGN(CallingConvention); |
| 600 | }; |
| 601 | |
Nicolas Geoffray | d4dd255 | 2014-02-28 10:23:58 +0000 | [diff] [blame] | 602 | } // namespace art |
| 603 | |
| 604 | #endif // ART_COMPILER_OPTIMIZING_CODE_GENERATOR_H_ |