1// Copyright 2011 the V8 project authors. All rights reserved.
2// Redistribution and use in source and binary forms, with or without
3// modification, are permitted provided that the following conditions are
4// met:
5//
6//     * Redistributions of source code must retain the above copyright
7//       notice, this list of conditions and the following disclaimer.
8//     * Redistributions in binary form must reproduce the above
9//       copyright notice, this list of conditions and the following
10//       disclaimer in the documentation and/or other materials provided
11//       with the distribution.
12//     * Neither the name of Google Inc. nor the names of its
13//       contributors may be used to endorse or promote products derived
14//       from this software without specific prior written permission.
15//
16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28#include "v8.h"
29
30#include "safepoint-table.h"
31
32#include "deoptimizer.h"
33#include "disasm.h"
34#include "macro-assembler.h"
35#include "zone-inl.h"
36
37namespace v8 {
38namespace internal {
39
40
41bool SafepointEntry::HasRegisters() const {
42  ASSERT(is_valid());
43  ASSERT(IsAligned(kNumSafepointRegisters, kBitsPerByte));
44  const int num_reg_bytes = kNumSafepointRegisters >> kBitsPerByteLog2;
45  for (int i = 0; i < num_reg_bytes; i++) {
46    if (bits_[i] != SafepointTable::kNoRegisters) return true;
47  }
48  return false;
49}
50
51
52bool SafepointEntry::HasRegisterAt(int reg_index) const {
53  ASSERT(is_valid());
54  ASSERT(reg_index >= 0 && reg_index < kNumSafepointRegisters);
55  int byte_index = reg_index >> kBitsPerByteLog2;
56  int bit_index = reg_index & (kBitsPerByte - 1);
57  return (bits_[byte_index] & (1 << bit_index)) != 0;
58}
59
60
61SafepointTable::SafepointTable(Code* code) {
62  ASSERT(code->kind() == Code::OPTIMIZED_FUNCTION);
63  code_ = code;
64  Address header = code->instruction_start() + code->safepoint_table_offset();
65  length_ = Memory::uint32_at(header + kLengthOffset);
66  entry_size_ = Memory::uint32_at(header + kEntrySizeOffset);
67  pc_and_deoptimization_indexes_ = header + kHeaderSize;
68  entries_ = pc_and_deoptimization_indexes_ +
69            (length_ * kPcAndDeoptimizationIndexSize);
70  ASSERT(entry_size_ > 0);
71  STATIC_ASSERT(SafepointEntry::DeoptimizationIndexField::kMax ==
72                Safepoint::kNoDeoptimizationIndex);
73}
74
75
76SafepointEntry SafepointTable::FindEntry(Address pc) const {
77  unsigned pc_offset = static_cast<unsigned>(pc - code_->instruction_start());
78  for (unsigned i = 0; i < length(); i++) {
79    // TODO(kasperl): Replace the linear search with binary search.
80    if (GetPcOffset(i) == pc_offset) return GetEntry(i);
81  }
82  return SafepointEntry();
83}
84
85
86void SafepointTable::PrintEntry(unsigned index) const {
87  disasm::NameConverter converter;
88  SafepointEntry entry = GetEntry(index);
89  uint8_t* bits = entry.bits();
90
91  // Print the stack slot bits.
92  if (entry_size_ > 0) {
93    ASSERT(IsAligned(kNumSafepointRegisters, kBitsPerByte));
94    const int first = kNumSafepointRegisters >> kBitsPerByteLog2;
95    int last = entry_size_ - 1;
96    for (int i = first; i < last; i++) PrintBits(bits[i], kBitsPerByte);
97    int last_bits = code_->stack_slots() - ((last - first) * kBitsPerByte);
98    PrintBits(bits[last], last_bits);
99
100    // Print the registers (if any).
101    if (!entry.HasRegisters()) return;
102    for (int j = 0; j < kNumSafepointRegisters; j++) {
103      if (entry.HasRegisterAt(j)) {
104        PrintF(" | %s", converter.NameOfCPURegister(j));
105      }
106    }
107  }
108}
109
110
111void SafepointTable::PrintBits(uint8_t byte, int digits) {
112  ASSERT(digits >= 0 && digits <= kBitsPerByte);
113  for (int i = 0; i < digits; i++) {
114    PrintF("%c", ((byte & (1 << i)) == 0) ? '0' : '1');
115  }
116}
117
118
119void Safepoint::DefinePointerRegister(Register reg) {
120  registers_->Add(reg.code());
121}
122
123
124Safepoint SafepointTableBuilder::DefineSafepoint(
125    Assembler* assembler,
126    Safepoint::Kind kind,
127    int arguments,
128    Safepoint::DeoptMode deopt_mode) {
129  ASSERT(arguments >= 0);
130  DeoptimizationInfo info;
131  info.pc = assembler->pc_offset();
132  info.arguments = arguments;
133  info.has_doubles = (kind & Safepoint::kWithDoubles);
134  deoptimization_info_.Add(info);
135  deopt_index_list_.Add(Safepoint::kNoDeoptimizationIndex);
136  if (deopt_mode == Safepoint::kNoLazyDeopt) {
137    last_lazy_safepoint_ = deopt_index_list_.length();
138  }
139  indexes_.Add(new ZoneList<int>(8));
140  registers_.Add((kind & Safepoint::kWithRegisters)
141      ? new ZoneList<int>(4)
142      : NULL);
143  return Safepoint(indexes_.last(), registers_.last());
144}
145
146
147void SafepointTableBuilder::RecordLazyDeoptimizationIndex(int index) {
148  while (last_lazy_safepoint_ < deopt_index_list_.length()) {
149    deopt_index_list_[last_lazy_safepoint_++] = index;
150  }
151}
152
153unsigned SafepointTableBuilder::GetCodeOffset() const {
154  ASSERT(emitted_);
155  return offset_;
156}
157
158
159void SafepointTableBuilder::Emit(Assembler* assembler, int bits_per_entry) {
160  // For lazy deoptimization we need space to patch a call after every call.
161  // Ensure there is always space for such patching, even if the code ends
162  // in a call.
163  int target_offset = assembler->pc_offset() + Deoptimizer::patch_size();
164  while (assembler->pc_offset() < target_offset) {
165    assembler->nop();
166  }
167
168  // Make sure the safepoint table is properly aligned. Pad with nops.
169  assembler->Align(kIntSize);
170  assembler->RecordComment(";;; Safepoint table.");
171  offset_ = assembler->pc_offset();
172
173  // Take the register bits into account.
174  bits_per_entry += kNumSafepointRegisters;
175
176  // Compute the number of bytes per safepoint entry.
177  int bytes_per_entry =
178      RoundUp(bits_per_entry, kBitsPerByte) >> kBitsPerByteLog2;
179
180  // Emit the table header.
181  int length = deoptimization_info_.length();
182  assembler->dd(length);
183  assembler->dd(bytes_per_entry);
184
185  // Emit sorted table of pc offsets together with deoptimization indexes.
186  for (int i = 0; i < length; i++) {
187    assembler->dd(deoptimization_info_[i].pc);
188    assembler->dd(EncodeExceptPC(deoptimization_info_[i],
189                                 deopt_index_list_[i]));
190  }
191
192  // Emit table of bitmaps.
193  ZoneList<uint8_t> bits(bytes_per_entry);
194  for (int i = 0; i < length; i++) {
195    ZoneList<int>* indexes = indexes_[i];
196    ZoneList<int>* registers = registers_[i];
197    bits.Clear();
198    bits.AddBlock(0, bytes_per_entry);
199
200    // Run through the registers (if any).
201    ASSERT(IsAligned(kNumSafepointRegisters, kBitsPerByte));
202    if (registers == NULL) {
203      const int num_reg_bytes = kNumSafepointRegisters >> kBitsPerByteLog2;
204      for (int j = 0; j < num_reg_bytes; j++) {
205        bits[j] = SafepointTable::kNoRegisters;
206      }
207    } else {
208      for (int j = 0; j < registers->length(); j++) {
209        int index = registers->at(j);
210        ASSERT(index >= 0 && index < kNumSafepointRegisters);
211        int byte_index = index >> kBitsPerByteLog2;
212        int bit_index = index & (kBitsPerByte - 1);
213        bits[byte_index] |= (1 << bit_index);
214      }
215    }
216
217    // Run through the indexes and build a bitmap.
218    for (int j = 0; j < indexes->length(); j++) {
219      int index = bits_per_entry - 1 - indexes->at(j);
220      int byte_index = index >> kBitsPerByteLog2;
221      int bit_index = index & (kBitsPerByte - 1);
222      bits[byte_index] |= (1U << bit_index);
223    }
224
225    // Emit the bitmap for the current entry.
226    for (int k = 0; k < bytes_per_entry; k++) {
227      assembler->db(bits[k]);
228    }
229  }
230  emitted_ = true;
231}
232
233
234uint32_t SafepointTableBuilder::EncodeExceptPC(const DeoptimizationInfo& info,
235                                               unsigned index) {
236  uint32_t encoding = SafepointEntry::DeoptimizationIndexField::encode(index);
237  encoding |= SafepointEntry::ArgumentsField::encode(info.arguments);
238  encoding |= SafepointEntry::SaveDoublesField::encode(info.has_doubles);
239  return encoding;
240}
241
242
243
244} }  // namespace v8::internal
245