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