src/v8/src/safepoint-table.cc

   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
  15 namespace v8 {
  16 namespace internal {
  17
  18
  19 bool 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
  30 bool 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
  39 SafepointTable::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
  54 SafepointEntry 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
  64 void SafepointTable::PrintEntry(unsigned index,
  65                                 std::ostream& os) const {  // NOLINT
  66   disasm::NameConverter converter;
  67   SafepointEntry entry = GetEntry(index);
  68   uint8_t* bits = entry.bits();
  69
  70   // Print the stack slot bits.
  71   if (entry_size_ > 0) {
  72     DCHECK(IsAligned(kNumSafepointRegisters, kBitsPerByte));
  73     const int first = kNumSafepointRegisters >> kBitsPerByteLog2;
  74     int last = entry_size_ - 1;
  75     for (int i = first; i < last; i++) PrintBits(os, bits[i], kBitsPerByte);
  76     int last_bits = code_->stack_slots() - ((last - first) * kBitsPerByte);
  77     PrintBits(os, bits[last], last_bits);
  78
  79     // Print the registers (if any).
  80     if (!entry.HasRegisters()) return;
  81     for (int j = 0; j < kNumSafepointRegisters; j++) {
  82       if (entry.HasRegisterAt(j)) {
  83         os << " | " << converter.NameOfCPURegister(j);
  84       }
  85     }
  86   }
  87 }
  88
  89
  90 void SafepointTable::PrintBits(std::ostream& os,  // NOLINT
  91                                uint8_t byte, int digits) {
  92   DCHECK(digits >= 0 && digits <= kBitsPerByte);
  93   for (int i = 0; i < digits; i++) {
  94     os << (((byte & (1 << i)) == 0) ? "0" : "1");
  95   }
  96 }
  97
  98
  99 void Safepoint::DefinePointerRegister(Register reg, Zone* zone) {
 100   registers_->Add(reg.code(), zone);
 101 }
 102
 103
 104 Safepoint SafepointTableBuilder::DefineSafepoint(
 105     Assembler* assembler,
 106     Safepoint::Kind kind,
 107     int arguments,
 108     Safepoint::DeoptMode deopt_mode) {
 109   DCHECK(arguments >= 0);
 110   DeoptimizationInfo info;
 111   info.pc = assembler->pc_offset();
 112   info.arguments = arguments;
 113   info.has_doubles = (kind & Safepoint::kWithDoubles);
 114   deoptimization_info_.Add(info, zone_);
 115   deopt_index_list_.Add(Safepoint::kNoDeoptimizationIndex, zone_);
 116   if (deopt_mode == Safepoint::kNoLazyDeopt) {
 117     last_lazy_safepoint_ = deopt_index_list_.length();
 118   }
 119   indexes_.Add(new(zone_) ZoneList<int>(8, zone_), zone_);
 120   registers_.Add((kind & Safepoint::kWithRegisters)
 121       ? new(zone_) ZoneList<int>(4, zone_)
 122       : NULL,
 123       zone_);
 124   return Safepoint(indexes_.last(), registers_.last());
 125 }
 126
 127
 128 void SafepointTableBuilder::RecordLazyDeoptimizationIndex(int index) {
 129   while (last_lazy_safepoint_ < deopt_index_list_.length()) {
 130     deopt_index_list_[last_lazy_safepoint_++] = index;
 131   }
 132 }
 133
 134 unsigned SafepointTableBuilder::GetCodeOffset() const {
 135   DCHECK(emitted_);
 136   return offset_;
 137 }
 138
 139
 140 void SafepointTableBuilder::Emit(Assembler* assembler, int bits_per_entry) {
 141   // Make sure the safepoint table is properly aligned. Pad with nops.
 142   assembler->Align(kIntSize);
 143   assembler->RecordComment(";;; Safepoint table.");
 144   offset_ = assembler->pc_offset();
 145
 146   // Take the register bits into account.
 147   bits_per_entry += kNumSafepointRegisters;
 148
 149   // Compute the number of bytes per safepoint entry.
 150   int bytes_per_entry =
 151       RoundUp(bits_per_entry, kBitsPerByte) >> kBitsPerByteLog2;
 152
 153   // Emit the table header.
 154   int length = deoptimization_info_.length();
 155   assembler->dd(length);
 156   assembler->dd(bytes_per_entry);
 157
 158   // Emit sorted table of pc offsets together with deoptimization indexes.
 159   for (int i = 0; i < length; i++) {
 160     assembler->dd(deoptimization_info_[i].pc);
 161     assembler->dd(EncodeExceptPC(deoptimization_info_[i],
 162                                  deopt_index_list_[i]));
 163   }
 164
 165   // Emit table of bitmaps.
 166   ZoneList<uint8_t> bits(bytes_per_entry, zone_);
 167   for (int i = 0; i < length; i++) {
 168     ZoneList<int>* indexes = indexes_[i];
 169     ZoneList<int>* registers = registers_[i];
 170     bits.Clear();
 171     bits.AddBlock(0, bytes_per_entry, zone_);
 172
 173     // Run through the registers (if any).
 174     DCHECK(IsAligned(kNumSafepointRegisters, kBitsPerByte));
 175     if (registers == NULL) {
 176       const int num_reg_bytes = kNumSafepointRegisters >> kBitsPerByteLog2;
 177       for (int j = 0; j < num_reg_bytes; j++) {
 178         bits[j] = SafepointTable::kNoRegisters;
 179       }
 180     } else {
 181       for (int j = 0; j < registers->length(); j++) {
 182         int index = registers->at(j);
 183         DCHECK(index >= 0 && index < kNumSafepointRegisters);
 184         int byte_index = index >> kBitsPerByteLog2;
 185         int bit_index = index & (kBitsPerByte - 1);
 186         bits[byte_index] |= (1 << bit_index);
 187       }
 188     }
 189
 190     // Run through the indexes and build a bitmap.
 191     for (int j = 0; j < indexes->length(); j++) {
 192       int index = bits_per_entry - 1 - indexes->at(j);
 193       int byte_index = index >> kBitsPerByteLog2;
 194       int bit_index = index & (kBitsPerByte - 1);
 195       bits[byte_index] |= (1U << bit_index);
 196     }
 197
 198     // Emit the bitmap for the current entry.
 199     for (int k = 0; k < bytes_per_entry; k++) {
 200       assembler->db(bits[k]);
 201     }
 202   }
 203   emitted_ = true;
 204 }
 205
 206
 207 uint32_t SafepointTableBuilder::EncodeExceptPC(const DeoptimizationInfo& info,
 208                                                unsigned index) {
 209   uint32_t encoding = SafepointEntry::DeoptimizationIndexField::encode(index);
 210   encoding |= SafepointEntry::ArgumentsField::encode(info.arguments);
 211   encoding |= SafepointEntry::SaveDoublesField::encode(info.has_doubles);
 212   return encoding;
 213 }
 214
 215
 216
 217 } }  // namespace v8::internal