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->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 
     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) 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 
    111 void 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 
    119 void Safepoint::DefinePointerRegister(Register reg) {
    120   registers_->Add(reg.code());
    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);
    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 
    147 void SafepointTableBuilder::RecordLazyDeoptimizationIndex(int index) {
    148   while (last_lazy_safepoint_ < deopt_index_list_.length()) {
    149     deopt_index_list_[last_lazy_safepoint_++] = index;
    150   }
    151 }
    152 
    153 unsigned SafepointTableBuilder::GetCodeOffset() const {
    154   ASSERT(emitted_);
    155   return offset_;
    156 }
    157 
    158 
    159 void 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 
    234 uint32_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