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