code_generator.h revision 3416601a9e9be81bb7494864287fd3602d18ef13 
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
20#include "arch/instruction_set.h"
21#include "arch/instruction_set_features.h"
22#include "base/bit_field.h"
23#include "globals.h"
24#include "locations.h"
25#include "memory_region.h"
26#include "nodes.h"
27#include "stack_map_stream.h"
28
29namespace art {
30
31static size_t constexpr kVRegSize = 4;
32static size_t constexpr kUninitializedFrameSize = 0;
33
34// Binary encoding of 2^32 for type double.
35static int64_t constexpr k2Pow32EncodingForDouble = INT64_C(0x41F0000000000000);
36// Binary encoding of 2^31 for type double.
37static int64_t constexpr k2Pow31EncodingForDouble = INT64_C(0x41E0000000000000);
38
39// Maximum value for a primitive integer.
40static int32_t constexpr kPrimIntMax = 0x7fffffff;
41// Maximum value for a primitive long.
42static int64_t constexpr kPrimLongMax = 0x7fffffffffffffff;
43
44class Assembler;
45class CodeGenerator;
46class DexCompilationUnit;
47class ParallelMoveResolver;
48class SrcMapElem;
49template <class Alloc>
50class SrcMap;
51using DefaultSrcMap = SrcMap<std::allocator<SrcMapElem>>;
52
53class CodeAllocator {
54 public:
55  CodeAllocator() {}
56  virtual ~CodeAllocator() {}
57
58  virtual uint8_t* Allocate(size_t size) = 0;
59
60 private:
61  DISALLOW_COPY_AND_ASSIGN(CodeAllocator);
62};
63
64struct PcInfo {
65  uint32_t dex_pc;
66  uintptr_t native_pc;
67};
68
69class SlowPathCode : public ArenaObject<kArenaAllocSlowPaths> {
70 public:
71  SlowPathCode() {}
72  virtual ~SlowPathCode() {}
73
74  virtual void EmitNativeCode(CodeGenerator* codegen) = 0;
75
76 private:
77  DISALLOW_COPY_AND_ASSIGN(SlowPathCode);
78};
79
80class CodeGenerator : public ArenaObject<kArenaAllocMisc> {
81 public:
82  // Compiles the graph to executable instructions. Returns whether the compilation
83  // succeeded.
84  void CompileBaseline(CodeAllocator* allocator, bool is_leaf = false);
85  void CompileOptimized(CodeAllocator* allocator);
86  static CodeGenerator* Create(ArenaAllocator* allocator,
87                               HGraph* graph,
88                               InstructionSet instruction_set,
89                               const InstructionSetFeatures& isa_features);
90
91  HGraph* GetGraph() const { return graph_; }
92
93  bool GoesToNextBlock(HBasicBlock* current, HBasicBlock* next) const;
94
95  size_t GetStackSlotOfParameter(HParameterValue* parameter) const {
96    // Note that this follows the current calling convention.
97    return GetFrameSize()
98        + kVRegSize  // Art method
99        + parameter->GetIndex() * kVRegSize;
100  }
101
102  virtual void Initialize() = 0;
103  virtual void Finalize(CodeAllocator* allocator);
104  virtual void GenerateFrameEntry() = 0;
105  virtual void GenerateFrameExit() = 0;
106  virtual void Bind(HBasicBlock* block) = 0;
107  virtual void Move(HInstruction* instruction, Location location, HInstruction* move_for) = 0;
108  virtual HGraphVisitor* GetLocationBuilder() = 0;
109  virtual HGraphVisitor* GetInstructionVisitor() = 0;
110  virtual Assembler* GetAssembler() = 0;
111  virtual size_t GetWordSize() const = 0;
112  virtual uintptr_t GetAddressOf(HBasicBlock* block) const = 0;
113  void ComputeFrameSize(size_t number_of_spill_slots,
114                        size_t maximum_number_of_live_registers,
115                        size_t number_of_out_slots);
116  virtual size_t FrameEntrySpillSize() const = 0;
117  int32_t GetStackSlot(HLocal* local) const;
118  Location GetTemporaryLocation(HTemporary* temp) const;
119
120  uint32_t GetFrameSize() const { return frame_size_; }
121  void SetFrameSize(uint32_t size) { frame_size_ = size; }
122  uint32_t GetCoreSpillMask() const { return core_spill_mask_; }
123
124  size_t GetNumberOfCoreRegisters() const { return number_of_core_registers_; }
125  size_t GetNumberOfFloatingPointRegisters() const { return number_of_fpu_registers_; }
126  virtual void SetupBlockedRegisters() const = 0;
127
128  virtual void DumpCoreRegister(std::ostream& stream, int reg) const = 0;
129  virtual void DumpFloatingPointRegister(std::ostream& stream, int reg) const = 0;
130  virtual InstructionSet GetInstructionSet() const = 0;
131  // Saves the register in the stack. Returns the size taken on stack.
132  virtual size_t SaveCoreRegister(size_t stack_index, uint32_t reg_id) = 0;
133  // Restores the register from the stack. Returns the size taken on stack.
134  virtual size_t RestoreCoreRegister(size_t stack_index, uint32_t reg_id) = 0;
135  virtual size_t SaveFloatingPointRegister(size_t stack_index, uint32_t reg_id) {
136    UNUSED(stack_index, reg_id);
137    UNIMPLEMENTED(FATAL);
138    UNREACHABLE();
139  }
140  virtual size_t RestoreFloatingPointRegister(size_t stack_index, uint32_t reg_id) {
141    UNUSED(stack_index, reg_id);
142    UNIMPLEMENTED(FATAL);
143    UNREACHABLE();
144  }
145
146  void RecordPcInfo(HInstruction* instruction, uint32_t dex_pc);
147
148  void AddSlowPath(SlowPathCode* slow_path) {
149    slow_paths_.Add(slow_path);
150  }
151
152  void GenerateSlowPaths();
153
154  void BuildMappingTable(std::vector<uint8_t>* vector, DefaultSrcMap* src_map) const;
155  void BuildVMapTable(std::vector<uint8_t>* vector) const;
156  void BuildNativeGCMap(
157      std::vector<uint8_t>* vector, const DexCompilationUnit& dex_compilation_unit) const;
158  void BuildStackMaps(std::vector<uint8_t>* vector);
159  void SaveLiveRegisters(LocationSummary* locations);
160  void RestoreLiveRegisters(LocationSummary* locations);
161
162  bool IsLeafMethod() const {
163    return is_leaf_;
164  }
165
166  void MarkNotLeaf() {
167    is_leaf_ = false;
168  }
169
170  // Clears the spill slots taken by loop phis in the `LocationSummary` of the
171  // suspend check. This is called when the code generator generates code
172  // for the suspend check at the back edge (instead of where the suspend check
173  // is, which is the loop entry). At this point, the spill slots for the phis
174  // have not been written to.
175  void ClearSpillSlotsFromLoopPhisInStackMap(HSuspendCheck* suspend_check) const;
176
177  bool* GetBlockedCoreRegisters() const { return blocked_core_registers_; }
178  bool* GetBlockedFloatingPointRegisters() const { return blocked_fpu_registers_; }
179
180  // Helper that returns the pointer offset of an index in an object array.
181  // Note: this method assumes we always have the same pointer size, regardless
182  // of the architecture.
183  static size_t GetCacheOffset(uint32_t index);
184
185  void EmitParallelMoves(Location from1, Location to1, Location from2, Location to2);
186
187  static bool StoreNeedsWriteBarrier(Primitive::Type type, HInstruction* value) {
188    if (kIsDebugBuild) {
189      if (type == Primitive::kPrimNot && value->IsIntConstant()) {
190        CHECK_EQ(value->AsIntConstant()->GetValue(), 0);
191      }
192    }
193    return type == Primitive::kPrimNot && !value->IsIntConstant();
194  }
195
196 protected:
197  CodeGenerator(HGraph* graph,
198                size_t number_of_core_registers,
199                size_t number_of_fpu_registers,
200                size_t number_of_register_pairs)
201      : frame_size_(kUninitializedFrameSize),
202        core_spill_mask_(0),
203        first_register_slot_in_slow_path_(0),
204        blocked_core_registers_(graph->GetArena()->AllocArray<bool>(number_of_core_registers)),
205        blocked_fpu_registers_(graph->GetArena()->AllocArray<bool>(number_of_fpu_registers)),
206        blocked_register_pairs_(graph->GetArena()->AllocArray<bool>(number_of_register_pairs)),
207        number_of_core_registers_(number_of_core_registers),
208        number_of_fpu_registers_(number_of_fpu_registers),
209        number_of_register_pairs_(number_of_register_pairs),
210        graph_(graph),
211        pc_infos_(graph->GetArena(), 32),
212        slow_paths_(graph->GetArena(), 8),
213        is_leaf_(true),
214        stack_map_stream_(graph->GetArena()) {}
215  ~CodeGenerator() {}
216
217  // Register allocation logic.
218  void AllocateRegistersLocally(HInstruction* instruction) const;
219
220  // Backend specific implementation for allocating a register.
221  virtual Location AllocateFreeRegister(Primitive::Type type) const = 0;
222
223  static size_t FindFreeEntry(bool* array, size_t length);
224  static size_t FindTwoFreeConsecutiveAlignedEntries(bool* array, size_t length);
225
226  virtual Location GetStackLocation(HLoadLocal* load) const = 0;
227
228  virtual ParallelMoveResolver* GetMoveResolver() = 0;
229
230  // Frame size required for this method.
231  uint32_t frame_size_;
232  uint32_t core_spill_mask_;
233  uint32_t first_register_slot_in_slow_path_;
234
235  // Arrays used when doing register allocation to know which
236  // registers we can allocate. `SetupBlockedRegisters` updates the
237  // arrays.
238  bool* const blocked_core_registers_;
239  bool* const blocked_fpu_registers_;
240  bool* const blocked_register_pairs_;
241  size_t number_of_core_registers_;
242  size_t number_of_fpu_registers_;
243  size_t number_of_register_pairs_;
244
245 private:
246  void InitLocations(HInstruction* instruction);
247  size_t GetStackOffsetOfSavedRegister(size_t index);
248
249  HGraph* const graph_;
250
251  GrowableArray<PcInfo> pc_infos_;
252  GrowableArray<SlowPathCode*> slow_paths_;
253
254  bool is_leaf_;
255
256  StackMapStream stack_map_stream_;
257
258  DISALLOW_COPY_AND_ASSIGN(CodeGenerator);
259};
260
261template <typename C, typename F>
262class CallingConvention {
263 public:
264  CallingConvention(const C* registers,
265                    size_t number_of_registers,
266                    const F* fpu_registers,
267                    size_t number_of_fpu_registers)
268      : registers_(registers),
269        number_of_registers_(number_of_registers),
270        fpu_registers_(fpu_registers),
271        number_of_fpu_registers_(number_of_fpu_registers) {}
272
273  size_t GetNumberOfRegisters() const { return number_of_registers_; }
274  size_t GetNumberOfFpuRegisters() const { return number_of_fpu_registers_; }
275
276  C GetRegisterAt(size_t index) const {
277    DCHECK_LT(index, number_of_registers_);
278    return registers_[index];
279  }
280
281  F GetFpuRegisterAt(size_t index) const {
282    DCHECK_LT(index, number_of_fpu_registers_);
283    return fpu_registers_[index];
284  }
285
286  size_t GetStackOffsetOf(size_t index) const {
287    // We still reserve the space for parameters passed by registers.
288    // Add one for the method pointer.
289    return (index + 1) * kVRegSize;
290  }
291
292 private:
293  const C* registers_;
294  const size_t number_of_registers_;
295  const F* fpu_registers_;
296  const size_t number_of_fpu_registers_;
297
298  DISALLOW_COPY_AND_ASSIGN(CallingConvention);
299};
300
301}  // namespace art
302
303#endif  // ART_COMPILER_OPTIMIZING_CODE_GENERATOR_H_
304