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