code_generator.h revision 86dbb9a12119273039ce272b41c809fa548b37b6 
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 "utils/assembler.h"
27
28namespace art {
29
30static size_t constexpr kVRegSize = 4;
31static size_t constexpr kUninitializedFrameSize = 0;
32
33class DexCompilationUnit;
34
35class CodeAllocator {
36 public:
37  CodeAllocator() { }
38  virtual ~CodeAllocator() { }
39
40  virtual uint8_t* Allocate(size_t size) = 0;
41
42 private:
43  DISALLOW_COPY_AND_ASSIGN(CodeAllocator);
44};
45
46struct PcInfo {
47  uint32_t dex_pc;
48  uintptr_t native_pc;
49};
50
51class CodeGenerator : public ArenaObject {
52 public:
53  // Compiles the graph to executable instructions. Returns whether the compilation
54  // succeeded.
55  void CompileBaseline(CodeAllocator* allocator);
56  void CompileOptimized(CodeAllocator* allocator);
57  static CodeGenerator* Create(ArenaAllocator* allocator,
58                               HGraph* graph,
59                               InstructionSet instruction_set);
60
61  HGraph* GetGraph() const { return graph_; }
62
63  Label* GetLabelOf(HBasicBlock* block) const;
64  bool GoesToNextBlock(HBasicBlock* current, HBasicBlock* next) const;
65
66  size_t GetStackSlotOfParameter(HParameterValue* parameter) const {
67    // Note that this follows the current calling convention.
68    return GetFrameSize()
69        + kVRegSize  // Art method
70        + (parameter->GetIndex() - graph_->GetNumberOfVRegs() + graph_->GetNumberOfInVRegs())
71          * kVRegSize;
72  }
73
74  virtual void GenerateFrameEntry() = 0;
75  virtual void GenerateFrameExit() = 0;
76  virtual void Bind(Label* label) = 0;
77  virtual void Move(HInstruction* instruction, Location location, HInstruction* move_for) = 0;
78  virtual HGraphVisitor* GetLocationBuilder() = 0;
79  virtual HGraphVisitor* GetInstructionVisitor() = 0;
80  virtual Assembler* GetAssembler() = 0;
81  virtual size_t GetWordSize() const = 0;
82  virtual void ComputeFrameSize(size_t number_of_spill_slots) = 0;
83
84  uint32_t GetFrameSize() const { return frame_size_; }
85  void SetFrameSize(uint32_t size) { frame_size_ = size; }
86  uint32_t GetCoreSpillMask() const { return core_spill_mask_; }
87
88  virtual size_t GetNumberOfCoreRegisters() const = 0;
89  virtual size_t GetNumberOfFloatingPointRegisters() const = 0;
90  virtual size_t GetNumberOfRegisters() const = 0;
91  virtual void SetupBlockedRegisters(bool* blocked_registers) const = 0;
92  virtual void DumpCoreRegister(std::ostream& stream, int reg) const = 0;
93  virtual void DumpFloatingPointRegister(std::ostream& stream, int reg) const = 0;
94
95  void RecordPcInfo(uint32_t dex_pc) {
96    struct PcInfo pc_info;
97    pc_info.dex_pc = dex_pc;
98    pc_info.native_pc = GetAssembler()->CodeSize();
99    pc_infos_.Add(pc_info);
100  }
101
102  void BuildMappingTable(std::vector<uint8_t>* vector) const;
103  void BuildVMapTable(std::vector<uint8_t>* vector) const;
104  void BuildNativeGCMap(
105      std::vector<uint8_t>* vector, const DexCompilationUnit& dex_compilation_unit) const;
106
107 protected:
108  CodeGenerator(HGraph* graph, size_t number_of_registers)
109      : frame_size_(kUninitializedFrameSize),
110        graph_(graph),
111        block_labels_(graph->GetArena(), 0),
112        pc_infos_(graph->GetArena(), 32),
113        blocked_registers_(graph->GetArena()->AllocArray<bool>(number_of_registers)) {}
114  ~CodeGenerator() {}
115
116  // Register allocation logic.
117  void AllocateRegistersLocally(HInstruction* instruction) const;
118
119  // Backend specific implementation for allocating a register.
120  virtual ManagedRegister AllocateFreeRegister(Primitive::Type type,
121                                               bool* blocked_registers) const = 0;
122
123  // Raw implementation of allocating a register: loops over blocked_registers to find
124  // the first available register.
125  size_t AllocateFreeRegisterInternal(bool* blocked_registers, size_t number_of_registers) const;
126
127  virtual Location GetStackLocation(HLoadLocal* load) const = 0;
128
129  // Frame size required for this method.
130  uint32_t frame_size_;
131  uint32_t core_spill_mask_;
132
133 private:
134  void InitLocations(HInstruction* instruction);
135
136  HGraph* const graph_;
137
138  // Labels for each block that will be compiled.
139  GrowableArray<Label> block_labels_;
140  GrowableArray<PcInfo> pc_infos_;
141
142  // Temporary data structure used when doing register allocation.
143  bool* const blocked_registers_;
144
145  DISALLOW_COPY_AND_ASSIGN(CodeGenerator);
146};
147
148template <typename T>
149class CallingConvention {
150 public:
151  CallingConvention(const T* registers, int number_of_registers)
152      : registers_(registers), number_of_registers_(number_of_registers) {}
153
154  size_t GetNumberOfRegisters() const { return number_of_registers_; }
155
156  T GetRegisterAt(size_t index) const {
157    DCHECK_LT(index, number_of_registers_);
158    return registers_[index];
159  }
160
161  uint8_t GetStackOffsetOf(size_t index, size_t word_size) const {
162    // We still reserve the space for parameters passed by registers.
163    // Add word_size for the method pointer.
164    return index * kVRegSize + word_size;
165  }
166
167 private:
168  const T* registers_;
169  const size_t number_of_registers_;
170
171  DISALLOW_COPY_AND_ASSIGN(CallingConvention);
172};
173
174}  // namespace art
175
176#endif  // ART_COMPILER_OPTIMIZING_CODE_GENERATOR_H_
177