Home | History | Annotate | Download | only in src 
      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 
     37 namespace v8 {
     38 namespace internal {
     39 
     40 
     41 bool 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 
     52 bool 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 
     61 SafepointTable::SafepointTable(Code* code) {
     62   ASSERT(code->is_crankshafted());
     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 
     76 SafepointEntry 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 
     86 void SafepointTable::PrintEntry(unsigned index, FILE* out) 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(out, bits[i], kBitsPerByte);
     97     int last_bits = code_->stack_slots() - ((last - first) * kBitsPerByte);
     98     PrintBits(out, 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(out, " | %s", converter.NameOfCPURegister(j));
    105       }
    106     }
    107   }
    108 }
    109 
    110 
    111 void SafepointTable::PrintBits(FILE* out, uint8_t byte, int digits) {
    112   ASSERT(digits >= 0 && digits <= kBitsPerByte);
    113   for (int i = 0; i < digits; i++) {
    114     PrintF(out, "%c", ((byte & (1 << i)) == 0) ? '0' : '1');
    115   }
    116 }
    117 
    118 
    119 void Safepoint::DefinePointerRegister(Register reg, Zone* zone) {
    120   registers_->Add(reg.code(), zone);
    121 }
    122 
    123 
    124 Safepoint 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, zone_);
    135   deopt_index_list_.Add(Safepoint::kNoDeoptimizationIndex, zone_);
    136   if (deopt_mode == Safepoint::kNoLazyDeopt) {
    137     last_lazy_safepoint_ = deopt_index_list_.length();
    138   }
    139   indexes_.Add(new(zone_) ZoneList<int>(8, zone_), zone_);
    140   registers_.Add((kind & Safepoint::kWithRegisters)
    141       ? new(zone_) ZoneList<int>(4, zone_)
    142       : NULL,
    143       zone_);
    144   return Safepoint(indexes_.last(), registers_.last());
    145 }
    146 
    147 
    148 void SafepointTableBuilder::RecordLazyDeoptimizationIndex(int index) {
    149   while (last_lazy_safepoint_ < deopt_index_list_.length()) {
    150     deopt_index_list_[last_lazy_safepoint_++] = index;
    151   }
    152 }
    153 
    154 unsigned SafepointTableBuilder::GetCodeOffset() const {
    155   ASSERT(emitted_);
    156   return offset_;
    157 }
    158 
    159 
    160 void SafepointTableBuilder::Emit(Assembler* assembler, int bits_per_entry) {
    161   // Make sure the safepoint table is properly aligned. Pad with nops.
    162   assembler->Align(kIntSize);
    163   assembler->RecordComment(";;; Safepoint table.");
    164   offset_ = assembler->pc_offset();
    165 
    166   // Take the register bits into account.
    167   bits_per_entry += kNumSafepointRegisters;
    168 
    169   // Compute the number of bytes per safepoint entry.
    170   int bytes_per_entry =
    171       RoundUp(bits_per_entry, kBitsPerByte) >> kBitsPerByteLog2;
    172 
    173   // Emit the table header.
    174   int length = deoptimization_info_.length();
    175   assembler->dd(length);
    176   assembler->dd(bytes_per_entry);
    177 
    178   // Emit sorted table of pc offsets together with deoptimization indexes.
    179   for (int i = 0; i < length; i++) {
    180     assembler->dd(deoptimization_info_[i].pc);
    181     assembler->dd(EncodeExceptPC(deoptimization_info_[i],
    182                                  deopt_index_list_[i]));
    183   }
    184 
    185   // Emit table of bitmaps.
    186   ZoneList<uint8_t> bits(bytes_per_entry, zone_);
    187   for (int i = 0; i < length; i++) {
    188     ZoneList<int>* indexes = indexes_[i];
    189     ZoneList<int>* registers = registers_[i];
    190     bits.Clear();
    191     bits.AddBlock(0, bytes_per_entry, zone_);
    192 
    193     // Run through the registers (if any).
    194     ASSERT(IsAligned(kNumSafepointRegisters, kBitsPerByte));
    195     if (registers == NULL) {
    196       const int num_reg_bytes = kNumSafepointRegisters >> kBitsPerByteLog2;
    197       for (int j = 0; j < num_reg_bytes; j++) {
    198         bits[j] = SafepointTable::kNoRegisters;
    199       }
    200     } else {
    201       for (int j = 0; j < registers->length(); j++) {
    202         int index = registers->at(j);
    203         ASSERT(index >= 0 && index < kNumSafepointRegisters);
    204         int byte_index = index >> kBitsPerByteLog2;
    205         int bit_index = index & (kBitsPerByte - 1);
    206         bits[byte_index] |= (1 << bit_index);
    207       }
    208     }
    209 
    210     // Run through the indexes and build a bitmap.
    211     for (int j = 0; j < indexes->length(); j++) {
    212       int index = bits_per_entry - 1 - indexes->at(j);
    213       int byte_index = index >> kBitsPerByteLog2;
    214       int bit_index = index & (kBitsPerByte - 1);
    215       bits[byte_index] |= (1U << bit_index);
    216     }
    217 
    218     // Emit the bitmap for the current entry.
    219     for (int k = 0; k < bytes_per_entry; k++) {
    220       assembler->db(bits[k]);
    221     }
    222   }
    223   emitted_ = true;
    224 }
    225 
    226 
    227 uint32_t SafepointTableBuilder::EncodeExceptPC(const DeoptimizationInfo& info,
    228                                                unsigned index) {
    229   uint32_t encoding = SafepointEntry::DeoptimizationIndexField::encode(index);
    230   encoding |= SafepointEntry::ArgumentsField::encode(info.arguments);
    231   encoding |= SafepointEntry::SaveDoublesField::encode(info.has_doubles);
    232   return encoding;
    233 }
    234 
    235 
    236 
    237 } }  // namespace v8::internal
    238