code_generator.h revision 56b9ee6fe1d6880c5fca0e7feb28b25a1ded2e2f 
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#include "utils/assembler.h"
28
29namespace art {
30
31static size_t constexpr kVRegSize = 4;
32static size_t constexpr kUninitializedFrameSize = 0;
33
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 {
55 public:
56  SlowPathCode() : entry_label_(), exit_label_() {}
57  virtual ~SlowPathCode() {}
58
59  Label* GetEntryLabel() { return &entry_label_; }
60  Label* GetExitLabel() { return &exit_label_; }
61
62  virtual void EmitNativeCode(CodeGenerator* codegen) = 0;
63
64 private:
65  Label entry_label_;
66  Label exit_label_;
67
68  DISALLOW_COPY_AND_ASSIGN(SlowPathCode);
69};
70
71class CodeGenerator : public ArenaObject {
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  Label* GetLabelOf(HBasicBlock* block) const;
84  bool GoesToNextBlock(HBasicBlock* current, HBasicBlock* next) const;
85
86  size_t GetStackSlotOfParameter(HParameterValue* parameter) const {
87    // Note that this follows the current calling convention.
88    return GetFrameSize()
89        + kVRegSize  // Art method
90        + parameter->GetIndex() * kVRegSize;
91  }
92
93  virtual void GenerateFrameEntry() = 0;
94  virtual void GenerateFrameExit() = 0;
95  virtual void Bind(Label* label) = 0;
96  virtual void Move(HInstruction* instruction, Location location, HInstruction* move_for) = 0;
97  virtual HGraphVisitor* GetLocationBuilder() = 0;
98  virtual HGraphVisitor* GetInstructionVisitor() = 0;
99  virtual Assembler* GetAssembler() = 0;
100  virtual size_t GetWordSize() const = 0;
101  void ComputeFrameSize(size_t number_of_spill_slots,
102                        size_t maximum_number_of_live_registers,
103                        size_t number_of_out_slots);
104  virtual size_t FrameEntrySpillSize() const = 0;
105  int32_t GetStackSlot(HLocal* local) const;
106  Location GetTemporaryLocation(HTemporary* temp) const;
107
108  uint32_t GetFrameSize() const { return frame_size_; }
109  void SetFrameSize(uint32_t size) { frame_size_ = size; }
110  uint32_t GetCoreSpillMask() const { return core_spill_mask_; }
111
112  virtual size_t GetNumberOfCoreRegisters() const = 0;
113  virtual size_t GetNumberOfFloatingPointRegisters() const = 0;
114  virtual size_t GetNumberOfRegisters() const = 0;
115  virtual void SetupBlockedRegisters(bool* blocked_registers) const = 0;
116  virtual void DumpCoreRegister(std::ostream& stream, int reg) const = 0;
117  virtual void DumpFloatingPointRegister(std::ostream& stream, int reg) const = 0;
118  virtual InstructionSet GetInstructionSet() const = 0;
119  virtual void SaveCoreRegister(Location stack_location, uint32_t reg_id) = 0;
120  virtual void RestoreCoreRegister(Location stack_location, uint32_t reg_id) = 0;
121
122  void RecordPcInfo(HInstruction* instruction, uint32_t dex_pc);
123
124  void AddSlowPath(SlowPathCode* slow_path) {
125    slow_paths_.Add(slow_path);
126  }
127
128  void GenerateSlowPaths();
129
130  void BuildMappingTable(std::vector<uint8_t>* vector, SrcMap* src_map) const;
131  void BuildVMapTable(std::vector<uint8_t>* vector) const;
132  void BuildNativeGCMap(
133      std::vector<uint8_t>* vector, const DexCompilationUnit& dex_compilation_unit) const;
134  void BuildStackMaps(std::vector<uint8_t>* vector);
135  void SaveLiveRegisters(LocationSummary* locations);
136  void RestoreLiveRegisters(LocationSummary* locations);
137
138  bool IsLeafMethod() const {
139    return is_leaf_;
140  }
141
142  void MarkNotLeaf() {
143    is_leaf_ = false;
144  }
145
146  // Clears the spill slots taken by loop phis in the `LocationSummary` of the
147  // suspend check. This is called when the code generator generates code
148  // for the suspend check at the back edge (instead of where the suspend check
149  // is, which is the loop entry). At this point, the spill slots for the phis
150  // have not been written to.
151  void ClearSpillSlotsFromLoopPhisInStackMap(HSuspendCheck* suspend_check) const;
152
153 protected:
154  CodeGenerator(HGraph* graph, size_t number_of_registers)
155      : frame_size_(kUninitializedFrameSize),
156        core_spill_mask_(0),
157        first_register_slot_in_slow_path_(0),
158        graph_(graph),
159        block_labels_(graph->GetArena(), 0),
160        pc_infos_(graph->GetArena(), 32),
161        slow_paths_(graph->GetArena(), 8),
162        blocked_registers_(graph->GetArena()->AllocArray<bool>(number_of_registers)),
163        is_leaf_(true),
164        stack_map_stream_(graph->GetArena()) {}
165  ~CodeGenerator() {}
166
167  // Register allocation logic.
168  void AllocateRegistersLocally(HInstruction* instruction) const;
169
170  // Backend specific implementation for allocating a register.
171  virtual Location AllocateFreeRegister(Primitive::Type type,
172                                        bool* blocked_registers) const = 0;
173
174  // Raw implementation of allocating a register: loops over blocked_registers to find
175  // the first available register.
176  size_t AllocateFreeRegisterInternal(bool* blocked_registers, size_t number_of_registers) const;
177
178  virtual Location GetStackLocation(HLoadLocal* load) const = 0;
179
180  // Frame size required for this method.
181  uint32_t frame_size_;
182  uint32_t core_spill_mask_;
183  uint32_t first_register_slot_in_slow_path_;
184
185 private:
186  void InitLocations(HInstruction* instruction);
187  size_t GetStackOffsetOfSavedRegister(size_t index);
188
189  HGraph* const graph_;
190
191  // Labels for each block that will be compiled.
192  GrowableArray<Label> block_labels_;
193  GrowableArray<PcInfo> pc_infos_;
194  GrowableArray<SlowPathCode*> slow_paths_;
195
196  // Temporary data structure used when doing register allocation.
197  bool* const blocked_registers_;
198
199  bool is_leaf_;
200
201  StackMapStream stack_map_stream_;
202
203  DISALLOW_COPY_AND_ASSIGN(CodeGenerator);
204};
205
206template <typename C, typename F>
207class CallingConvention {
208 public:
209  CallingConvention(const C* registers,
210                    size_t number_of_registers,
211                    const F* fpu_registers,
212                    size_t number_of_fpu_registers)
213      : registers_(registers),
214        number_of_registers_(number_of_registers),
215        fpu_registers_(fpu_registers),
216        number_of_fpu_registers_(number_of_fpu_registers) {}
217
218  size_t GetNumberOfRegisters() const { return number_of_registers_; }
219  size_t GetNumberOfFpuRegisters() const { return number_of_fpu_registers_; }
220
221  C GetRegisterAt(size_t index) const {
222    DCHECK_LT(index, number_of_registers_);
223    return registers_[index];
224  }
225
226  F GetFpuRegisterAt(size_t index) const {
227    DCHECK_LT(index, number_of_fpu_registers_);
228    return fpu_registers_[index];
229  }
230
231  size_t GetStackOffsetOf(size_t index) const {
232    // We still reserve the space for parameters passed by registers.
233    // Add one for the method pointer.
234    return (index + 1) * kVRegSize;
235  }
236
237 private:
238  const C* registers_;
239  const size_t number_of_registers_;
240  const F* fpu_registers_;
241  const size_t number_of_fpu_registers_;
242
243  DISALLOW_COPY_AND_ASSIGN(CallingConvention);
244};
245
246}  // namespace art
247
248#endif  // ART_COMPILER_OPTIMIZING_CODE_GENERATOR_H_
249