code_generator.cc revision c32e770f21540e4e9eda6dc7f770e745d33f1b9f 
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#include "code_generator.h"
18
19#include "code_generator_arm.h"
20#include "code_generator_x86.h"
21#include "dex/verified_method.h"
22#include "driver/dex_compilation_unit.h"
23#include "gc_map_builder.h"
24#include "leb128.h"
25#include "mapping_table.h"
26#include "utils/assembler.h"
27#include "verifier/dex_gc_map.h"
28#include "vmap_table.h"
29
30namespace art {
31
32void CodeGenerator::Compile(CodeAllocator* allocator) {
33  const GrowableArray<HBasicBlock*>* blocks = GetGraph()->GetBlocks();
34  DCHECK(blocks->Get(0) == GetGraph()->GetEntryBlock());
35  DCHECK(GoesToNextBlock(GetGraph()->GetEntryBlock(), blocks->Get(1)));
36  GenerateFrameEntry();
37  for (size_t i = 0; i < blocks->Size(); i++) {
38    CompileBlock(blocks->Get(i));
39  }
40  size_t code_size = GetAssembler()->CodeSize();
41  uint8_t* buffer = allocator->Allocate(code_size);
42  MemoryRegion code(buffer, code_size);
43  GetAssembler()->FinalizeInstructions(code);
44}
45
46void CodeGenerator::CompileBlock(HBasicBlock* block) {
47  Bind(GetLabelOf(block));
48  HGraphVisitor* location_builder = GetLocationBuilder();
49  HGraphVisitor* instruction_visitor = GetInstructionVisitor();
50  for (HInstructionIterator it(*block->GetInstructions()); !it.Done(); it.Advance()) {
51    HInstruction* current = it.Current();
52    current->Accept(location_builder);
53    InitLocations(current);
54    current->Accept(instruction_visitor);
55  }
56}
57
58void CodeGenerator::InitLocations(HInstruction* instruction) {
59  if (instruction->GetLocations() == nullptr) return;
60  for (size_t i = 0; i < instruction->InputCount(); i++) {
61    Location location = instruction->GetLocations()->InAt(i);
62    if (location.IsValid()) {
63      // Move the input to the desired location.
64      Move(instruction->InputAt(i), location, instruction);
65    }
66  }
67}
68
69bool CodeGenerator::GoesToNextBlock(HBasicBlock* current, HBasicBlock* next) const {
70  // We currently iterate over the block in insertion order.
71  return current->GetBlockId() + 1 == next->GetBlockId();
72}
73
74Label* CodeGenerator::GetLabelOf(HBasicBlock* block) const {
75  return block_labels_.GetRawStorage() + block->GetBlockId();
76}
77
78CodeGenerator* CodeGenerator::Create(ArenaAllocator* allocator,
79                                     HGraph* graph,
80                                     InstructionSet instruction_set) {
81  switch (instruction_set) {
82    case kArm:
83    case kThumb2: {
84      return new (allocator) arm::CodeGeneratorARM(graph);
85    }
86    case kMips:
87      return nullptr;
88    case kX86: {
89      return new (allocator) x86::CodeGeneratorX86(graph);
90    }
91    case kX86_64: {
92      return new (allocator) x86::CodeGeneratorX86(graph);
93    }
94    default:
95      return nullptr;
96  }
97}
98
99void CodeGenerator::BuildNativeGCMap(
100    std::vector<uint8_t>* data, const DexCompilationUnit& dex_compilation_unit) const {
101  const std::vector<uint8_t>& gc_map_raw =
102      dex_compilation_unit.GetVerifiedMethod()->GetDexGcMap();
103  verifier::DexPcToReferenceMap dex_gc_map(&(gc_map_raw)[0]);
104
105  uint32_t max_native_offset = 0;
106  for (size_t i = 0; i < pc_infos_.Size(); i++) {
107    uint32_t native_offset = pc_infos_.Get(i).native_pc;
108    if (native_offset > max_native_offset) {
109      max_native_offset = native_offset;
110    }
111  }
112
113  GcMapBuilder builder(data, pc_infos_.Size(), max_native_offset, dex_gc_map.RegWidth());
114  for (size_t i = 0; i < pc_infos_.Size(); i++) {
115    struct PcInfo pc_info = pc_infos_.Get(i);
116    uint32_t native_offset = pc_info.native_pc;
117    uint32_t dex_pc = pc_info.dex_pc;
118    const uint8_t* references = dex_gc_map.FindBitMap(dex_pc, false);
119    CHECK(references != NULL) << "Missing ref for dex pc 0x" << std::hex << dex_pc;
120    builder.AddEntry(native_offset, references);
121  }
122}
123
124void CodeGenerator::BuildMappingTable(std::vector<uint8_t>* data) const {
125  uint32_t pc2dex_data_size = 0u;
126  uint32_t pc2dex_entries = pc_infos_.Size();
127  uint32_t pc2dex_offset = 0u;
128  int32_t pc2dex_dalvik_offset = 0;
129  uint32_t dex2pc_data_size = 0u;
130  uint32_t dex2pc_entries = 0u;
131
132  // We currently only have pc2dex entries.
133  for (size_t i = 0; i < pc2dex_entries; i++) {
134    struct PcInfo pc_info = pc_infos_.Get(i);
135    pc2dex_data_size += UnsignedLeb128Size(pc_info.native_pc - pc2dex_offset);
136    pc2dex_data_size += SignedLeb128Size(pc_info.dex_pc - pc2dex_dalvik_offset);
137    pc2dex_offset = pc_info.native_pc;
138    pc2dex_dalvik_offset = pc_info.dex_pc;
139  }
140
141  uint32_t total_entries = pc2dex_entries + dex2pc_entries;
142  uint32_t hdr_data_size = UnsignedLeb128Size(total_entries) + UnsignedLeb128Size(pc2dex_entries);
143  uint32_t data_size = hdr_data_size + pc2dex_data_size + dex2pc_data_size;
144  data->resize(data_size);
145
146  uint8_t* data_ptr = &(*data)[0];
147  uint8_t* write_pos = data_ptr;
148  write_pos = EncodeUnsignedLeb128(write_pos, total_entries);
149  write_pos = EncodeUnsignedLeb128(write_pos, pc2dex_entries);
150  DCHECK_EQ(static_cast<size_t>(write_pos - data_ptr), hdr_data_size);
151  uint8_t* write_pos2 = write_pos + pc2dex_data_size;
152
153  pc2dex_offset = 0u;
154  pc2dex_dalvik_offset = 0u;
155  for (size_t i = 0; i < pc2dex_entries; i++) {
156    struct PcInfo pc_info = pc_infos_.Get(i);
157    DCHECK(pc2dex_offset <= pc_info.native_pc);
158    write_pos = EncodeUnsignedLeb128(write_pos, pc_info.native_pc - pc2dex_offset);
159    write_pos = EncodeSignedLeb128(write_pos, pc_info.dex_pc - pc2dex_dalvik_offset);
160    pc2dex_offset = pc_info.native_pc;
161    pc2dex_dalvik_offset = pc_info.dex_pc;
162  }
163  DCHECK_EQ(static_cast<size_t>(write_pos - data_ptr), hdr_data_size + pc2dex_data_size);
164  DCHECK_EQ(static_cast<size_t>(write_pos2 - data_ptr), data_size);
165
166  if (kIsDebugBuild) {
167    // Verify the encoded table holds the expected data.
168    MappingTable table(data_ptr);
169    CHECK_EQ(table.TotalSize(), total_entries);
170    CHECK_EQ(table.PcToDexSize(), pc2dex_entries);
171    auto it = table.PcToDexBegin();
172    auto it2 = table.DexToPcBegin();
173    for (size_t i = 0; i < pc2dex_entries; i++) {
174      struct PcInfo pc_info = pc_infos_.Get(i);
175      CHECK_EQ(pc_info.native_pc, it.NativePcOffset());
176      CHECK_EQ(pc_info.dex_pc, it.DexPc());
177      ++it;
178    }
179    CHECK(it == table.PcToDexEnd());
180    CHECK(it2 == table.DexToPcEnd());
181  }
182}
183
184void CodeGenerator::BuildVMapTable(std::vector<uint8_t>* data) const {
185  Leb128EncodingVector vmap_encoder;
186  // We currently don't use callee-saved registers.
187  size_t size = 0 + 1 /* marker */ + 0;
188  vmap_encoder.Reserve(size + 1u);  // All values are likely to be one byte in ULEB128 (<128).
189  vmap_encoder.PushBackUnsigned(size);
190  vmap_encoder.PushBackUnsigned(VmapTable::kAdjustedFpMarker);
191
192  *data = vmap_encoder.GetData();
193}
194
195}  // namespace art
196