1// Copyright 2011 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "src/v8.h"
6
7#include "src/safepoint-table.h"
8
9#include "src/deoptimizer.h"
10#include "src/disasm.h"
11#include "src/macro-assembler.h"
12#include "src/ostreams.h"
13#include "src/zone-inl.h"
14
15namespace v8 {
16namespace internal {
17
18
19bool SafepointEntry::HasRegisters() const {
20  DCHECK(is_valid());
21  DCHECK(IsAligned(kNumSafepointRegisters, kBitsPerByte));
22  const int num_reg_bytes = kNumSafepointRegisters >> kBitsPerByteLog2;
23  for (int i = 0; i < num_reg_bytes; i++) {
24    if (bits_[i] != SafepointTable::kNoRegisters) return true;
25  }
26  return false;
27}
28
29
30bool SafepointEntry::HasRegisterAt(int reg_index) const {
31  DCHECK(is_valid());
32  DCHECK(reg_index >= 0 && reg_index < kNumSafepointRegisters);
33  int byte_index = reg_index >> kBitsPerByteLog2;
34  int bit_index = reg_index & (kBitsPerByte - 1);
35  return (bits_[byte_index] & (1 << bit_index)) != 0;
36}
37
38
39SafepointTable::SafepointTable(Code* code) {
40  DCHECK(code->is_crankshafted());
41  code_ = code;
42  Address header = code->instruction_start() + code->safepoint_table_offset();
43  length_ = Memory::uint32_at(header + kLengthOffset);
44  entry_size_ = Memory::uint32_at(header + kEntrySizeOffset);
45  pc_and_deoptimization_indexes_ = header + kHeaderSize;
46  entries_ = pc_and_deoptimization_indexes_ +
47             (length_ * kPcAndDeoptimizationIndexSize);
48  DCHECK(entry_size_ > 0);
49  STATIC_ASSERT(SafepointEntry::DeoptimizationIndexField::kMax ==
50                Safepoint::kNoDeoptimizationIndex);
51}
52
53
54SafepointEntry SafepointTable::FindEntry(Address pc) const {
55  unsigned pc_offset = static_cast<unsigned>(pc - code_->instruction_start());
56  for (unsigned i = 0; i < length(); i++) {
57    // TODO(kasperl): Replace the linear search with binary search.
58    if (GetPcOffset(i) == pc_offset) return GetEntry(i);
59  }
60  return SafepointEntry();
61}
62
63
64void SafepointTable::PrintEntry(unsigned index, OStream& os) const {  // NOLINT
65  disasm::NameConverter converter;
66  SafepointEntry entry = GetEntry(index);
67  uint8_t* bits = entry.bits();
68
69  // Print the stack slot bits.
70  if (entry_size_ > 0) {
71    DCHECK(IsAligned(kNumSafepointRegisters, kBitsPerByte));
72    const int first = kNumSafepointRegisters >> kBitsPerByteLog2;
73    int last = entry_size_ - 1;
74    for (int i = first; i < last; i++) PrintBits(os, bits[i], kBitsPerByte);
75    int last_bits = code_->stack_slots() - ((last - first) * kBitsPerByte);
76    PrintBits(os, bits[last], last_bits);
77
78    // Print the registers (if any).
79    if (!entry.HasRegisters()) return;
80    for (int j = 0; j < kNumSafepointRegisters; j++) {
81      if (entry.HasRegisterAt(j)) {
82        os << " | " << converter.NameOfCPURegister(j);
83      }
84    }
85  }
86}
87
88
89void SafepointTable::PrintBits(OStream& os,  // NOLINT
90                               uint8_t byte, int digits) {
91  DCHECK(digits >= 0 && digits <= kBitsPerByte);
92  for (int i = 0; i < digits; i++) {
93    os << (((byte & (1 << i)) == 0) ? "0" : "1");
94  }
95}
96
97
98void Safepoint::DefinePointerRegister(Register reg, Zone* zone) {
99  registers_->Add(reg.code(), zone);
100}
101
102
103Safepoint SafepointTableBuilder::DefineSafepoint(
104    Assembler* assembler,
105    Safepoint::Kind kind,
106    int arguments,
107    Safepoint::DeoptMode deopt_mode) {
108  DCHECK(arguments >= 0);
109  DeoptimizationInfo info;
110  info.pc = assembler->pc_offset();
111  info.arguments = arguments;
112  info.has_doubles = (kind & Safepoint::kWithDoubles);
113  deoptimization_info_.Add(info, zone_);
114  deopt_index_list_.Add(Safepoint::kNoDeoptimizationIndex, zone_);
115  if (deopt_mode == Safepoint::kNoLazyDeopt) {
116    last_lazy_safepoint_ = deopt_index_list_.length();
117  }
118  indexes_.Add(new(zone_) ZoneList<int>(8, zone_), zone_);
119  registers_.Add((kind & Safepoint::kWithRegisters)
120      ? new(zone_) ZoneList<int>(4, zone_)
121      : NULL,
122      zone_);
123  return Safepoint(indexes_.last(), registers_.last());
124}
125
126
127void SafepointTableBuilder::RecordLazyDeoptimizationIndex(int index) {
128  while (last_lazy_safepoint_ < deopt_index_list_.length()) {
129    deopt_index_list_[last_lazy_safepoint_++] = index;
130  }
131}
132
133unsigned SafepointTableBuilder::GetCodeOffset() const {
134  DCHECK(emitted_);
135  return offset_;
136}
137
138
139void SafepointTableBuilder::Emit(Assembler* assembler, int bits_per_entry) {
140  // Make sure the safepoint table is properly aligned. Pad with nops.
141  assembler->Align(kIntSize);
142  assembler->RecordComment(";;; Safepoint table.");
143  offset_ = assembler->pc_offset();
144
145  // Take the register bits into account.
146  bits_per_entry += kNumSafepointRegisters;
147
148  // Compute the number of bytes per safepoint entry.
149  int bytes_per_entry =
150      RoundUp(bits_per_entry, kBitsPerByte) >> kBitsPerByteLog2;
151
152  // Emit the table header.
153  int length = deoptimization_info_.length();
154  assembler->dd(length);
155  assembler->dd(bytes_per_entry);
156
157  // Emit sorted table of pc offsets together with deoptimization indexes.
158  for (int i = 0; i < length; i++) {
159    assembler->dd(deoptimization_info_[i].pc);
160    assembler->dd(EncodeExceptPC(deoptimization_info_[i],
161                                 deopt_index_list_[i]));
162  }
163
164  // Emit table of bitmaps.
165  ZoneList<uint8_t> bits(bytes_per_entry, zone_);
166  for (int i = 0; i < length; i++) {
167    ZoneList<int>* indexes = indexes_[i];
168    ZoneList<int>* registers = registers_[i];
169    bits.Clear();
170    bits.AddBlock(0, bytes_per_entry, zone_);
171
172    // Run through the registers (if any).
173    DCHECK(IsAligned(kNumSafepointRegisters, kBitsPerByte));
174    if (registers == NULL) {
175      const int num_reg_bytes = kNumSafepointRegisters >> kBitsPerByteLog2;
176      for (int j = 0; j < num_reg_bytes; j++) {
177        bits[j] = SafepointTable::kNoRegisters;
178      }
179    } else {
180      for (int j = 0; j < registers->length(); j++) {
181        int index = registers->at(j);
182        DCHECK(index >= 0 && index < kNumSafepointRegisters);
183        int byte_index = index >> kBitsPerByteLog2;
184        int bit_index = index & (kBitsPerByte - 1);
185        bits[byte_index] |= (1 << bit_index);
186      }
187    }
188
189    // Run through the indexes and build a bitmap.
190    for (int j = 0; j < indexes->length(); j++) {
191      int index = bits_per_entry - 1 - indexes->at(j);
192      int byte_index = index >> kBitsPerByteLog2;
193      int bit_index = index & (kBitsPerByte - 1);
194      bits[byte_index] |= (1U << bit_index);
195    }
196
197    // Emit the bitmap for the current entry.
198    for (int k = 0; k < bytes_per_entry; k++) {
199      assembler->db(bits[k]);
200    }
201  }
202  emitted_ = true;
203}
204
205
206uint32_t SafepointTableBuilder::EncodeExceptPC(const DeoptimizationInfo& info,
207                                               unsigned index) {
208  uint32_t encoding = SafepointEntry::DeoptimizationIndexField::encode(index);
209  encoding |= SafepointEntry::ArgumentsField::encode(info.arguments);
210  encoding |= SafepointEntry::SaveDoublesField::encode(info.has_doubles);
211  return encoding;
212}
213
214
215
216} }  // namespace v8::internal
217