therubyracer 0.9.0beta4 → 0.9.0beta5

data/ext/v8/upstream/v8/src/safepoint-table.cc

@@ -1,256 +0,0 @@
-// Copyright 2011 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#include "v8.h"
-
-#include "safepoint-table.h"
-
-#include "deoptimizer.h"
-#include "disasm.h"
-#include "macro-assembler.h"
-#include "zone-inl.h"
-
-namespace v8 {
-namespace internal {
-
-
-bool SafepointEntry::HasRegisters() const {
-  ASSERT(is_valid());
-  ASSERT(IsAligned(kNumSafepointRegisters, kBitsPerByte));
-  const int num_reg_bytes = kNumSafepointRegisters >> kBitsPerByteLog2;
-  for (int i = 0; i < num_reg_bytes; i++) {
-    if (bits_[i] != SafepointTable::kNoRegisters) return true;
-  }
-  return false;
-}
-
-
-bool SafepointEntry::HasRegisterAt(int reg_index) const {
-  ASSERT(is_valid());
-  ASSERT(reg_index >= 0 && reg_index < kNumSafepointRegisters);
-  int byte_index = reg_index >> kBitsPerByteLog2;
-  int bit_index = reg_index & (kBitsPerByte - 1);
-  return (bits_[byte_index] & (1 << bit_index)) != 0;
-}
-
-
-SafepointTable::SafepointTable(Code* code) {
-  ASSERT(code->kind() == Code::OPTIMIZED_FUNCTION);
-  code_ = code;
-  Address header = code->instruction_start() + code->safepoint_table_offset();
-  length_ = Memory::uint32_at(header + kLengthOffset);
-  entry_size_ = Memory::uint32_at(header + kEntrySizeOffset);
-  pc_and_deoptimization_indexes_ = header + kHeaderSize;
-  entries_ = pc_and_deoptimization_indexes_ +
-            (length_ * kPcAndDeoptimizationIndexSize);
-  ASSERT(entry_size_ > 0);
-  ASSERT_EQ(SafepointEntry::DeoptimizationIndexField::max(),
-            Safepoint::kNoDeoptimizationIndex);
-}
-
-
-SafepointEntry SafepointTable::FindEntry(Address pc) const {
-  unsigned pc_offset = static_cast<unsigned>(pc - code_->instruction_start());
-  for (unsigned i = 0; i < length(); i++) {
-    // TODO(kasperl): Replace the linear search with binary search.
-    if (GetPcOffset(i) == pc_offset) return GetEntry(i);
-  }
-  return SafepointEntry();
-}
-
-
-void SafepointTable::PrintEntry(unsigned index) const {
-  disasm::NameConverter converter;
-  SafepointEntry entry = GetEntry(index);
-  uint8_t* bits = entry.bits();
-
-  // Print the stack slot bits.
-  if (entry_size_ > 0) {
-    ASSERT(IsAligned(kNumSafepointRegisters, kBitsPerByte));
-    const int first = kNumSafepointRegisters >> kBitsPerByteLog2;
-    int last = entry_size_ - 1;
-    for (int i = first; i < last; i++) PrintBits(bits[i], kBitsPerByte);
-    int last_bits = code_->stack_slots() - ((last - first) * kBitsPerByte);
-    PrintBits(bits[last], last_bits);
-
-    // Print the registers (if any).
-    if (!entry.HasRegisters()) return;
-    for (int j = 0; j < kNumSafepointRegisters; j++) {
-      if (entry.HasRegisterAt(j)) {
-        PrintF(" | %s", converter.NameOfCPURegister(j));
-      }
-    }
-  }
-}
-
-
-void SafepointTable::PrintBits(uint8_t byte, int digits) {
-  ASSERT(digits >= 0 && digits <= kBitsPerByte);
-  for (int i = 0; i < digits; i++) {
-    PrintF("%c", ((byte & (1 << i)) == 0) ? '0' : '1');
-  }
-}
-
-
-void Safepoint::DefinePointerRegister(Register reg) {
-  registers_->Add(reg.code());
-}
-
-
-Safepoint SafepointTableBuilder::DefineSafepoint(
-    Assembler* assembler, Safepoint::Kind kind, int arguments,
-    int deoptimization_index) {
-  ASSERT(deoptimization_index != -1);
-  ASSERT(arguments >= 0);
-  DeoptimizationInfo pc_and_deoptimization_index;
-  pc_and_deoptimization_index.pc = assembler->pc_offset();
-  pc_and_deoptimization_index.deoptimization_index = deoptimization_index;
-  pc_and_deoptimization_index.pc_after_gap = assembler->pc_offset();
-  pc_and_deoptimization_index.arguments = arguments;
-  pc_and_deoptimization_index.has_doubles = (kind & Safepoint::kWithDoubles);
-  deoptimization_info_.Add(pc_and_deoptimization_index);
-  indexes_.Add(new ZoneList<int>(8));
-  registers_.Add((kind & Safepoint::kWithRegisters)
-      ? new ZoneList<int>(4)
-      : NULL);
-  return Safepoint(indexes_.last(), registers_.last());
-}
-
-
-unsigned SafepointTableBuilder::GetCodeOffset() const {
-  ASSERT(emitted_);
-  return offset_;
-}
-
-
-void SafepointTableBuilder::Emit(Assembler* assembler, int bits_per_entry) {
-  // For lazy deoptimization we need space to patch a call after every call.
-  // Ensure there is always space for such patching, even if the code ends
-  // in a call.
-  int target_offset = assembler->pc_offset() + Deoptimizer::patch_size();
-  while (assembler->pc_offset() < target_offset) {
-    assembler->nop();
-  }
-
-  // Make sure the safepoint table is properly aligned. Pad with nops.
-  assembler->Align(kIntSize);
-  assembler->RecordComment(";;; Safepoint table.");
-  offset_ = assembler->pc_offset();
-
-  // Take the register bits into account.
-  bits_per_entry += kNumSafepointRegisters;
-
-  // Compute the number of bytes per safepoint entry.
-  int bytes_per_entry =
-      RoundUp(bits_per_entry, kBitsPerByte) >> kBitsPerByteLog2;
-
-  // Emit the table header.
-  int length = deoptimization_info_.length();
-  assembler->dd(length);
-  assembler->dd(bytes_per_entry);
-
-  // Emit sorted table of pc offsets together with deoptimization indexes and
-  // pc after gap information.
-  for (int i = 0; i < length; i++) {
-    assembler->dd(deoptimization_info_[i].pc);
-    assembler->dd(EncodeExceptPC(deoptimization_info_[i]));
-  }
-
-  // Emit table of bitmaps.
-  ZoneList<uint8_t> bits(bytes_per_entry);
-  for (int i = 0; i < length; i++) {
-    ZoneList<int>* indexes = indexes_[i];
-    ZoneList<int>* registers = registers_[i];
-    bits.Clear();
-    bits.AddBlock(0, bytes_per_entry);
-
-    // Run through the registers (if any).
-    ASSERT(IsAligned(kNumSafepointRegisters, kBitsPerByte));
-    if (registers == NULL) {
-      const int num_reg_bytes = kNumSafepointRegisters >> kBitsPerByteLog2;
-      for (int j = 0; j < num_reg_bytes; j++) {
-        bits[j] = SafepointTable::kNoRegisters;
-      }
-    } else {
-      for (int j = 0; j < registers->length(); j++) {
-        int index = registers->at(j);
-        ASSERT(index >= 0 && index < kNumSafepointRegisters);
-        int byte_index = index >> kBitsPerByteLog2;
-        int bit_index = index & (kBitsPerByte - 1);
-        bits[byte_index] |= (1 << bit_index);
-      }
-    }
-
-    // Run through the indexes and build a bitmap.
-    for (int j = 0; j < indexes->length(); j++) {
-      int index = bits_per_entry - 1 - indexes->at(j);
-      int byte_index = index >> kBitsPerByteLog2;
-      int bit_index = index & (kBitsPerByte - 1);
-      bits[byte_index] |= (1U << bit_index);
-    }
-
-    // Emit the bitmap for the current entry.
-    for (int k = 0; k < bytes_per_entry; k++) {
-      assembler->db(bits[k]);
-    }
-  }
-  emitted_ = true;
-}
-
-
-uint32_t SafepointTableBuilder::EncodeExceptPC(const DeoptimizationInfo& info) {
-  unsigned index = info.deoptimization_index;
-  unsigned gap_size = info.pc_after_gap - info.pc;
-  uint32_t encoding = SafepointEntry::DeoptimizationIndexField::encode(index);
-  encoding |= SafepointEntry::GapCodeSizeField::encode(gap_size);
-  encoding |= SafepointEntry::ArgumentsField::encode(info.arguments);
-  encoding |= SafepointEntry::SaveDoublesField::encode(info.has_doubles);
-  return encoding;
-}
-
-
-int SafepointTableBuilder::CountShortDeoptimizationIntervals(unsigned limit) {
-  int result = 0;
-  if (!deoptimization_info_.is_empty()) {
-    unsigned previous_gap_end = deoptimization_info_[0].pc_after_gap;
-    for (int i = 1, n = deoptimization_info_.length(); i < n; i++) {
-      DeoptimizationInfo info = deoptimization_info_[i];
-      if (static_cast<int>(info.deoptimization_index) !=
-          Safepoint::kNoDeoptimizationIndex) {
-        if (previous_gap_end + limit > info.pc) {
-          result++;
-        }
-        previous_gap_end = info.pc_after_gap;
-      }
-    }
-  }
-  return result;
-}
-
-
-
-} }  // namespace v8::internal

data/ext/v8/upstream/v8/src/safepoint-table.h

@@ -1,269 +0,0 @@
-// Copyright 2011 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#ifndef V8_SAFEPOINT_TABLE_H_
-#define V8_SAFEPOINT_TABLE_H_
-
-#include "heap.h"
-#include "v8memory.h"
-#include "zone.h"
-
-namespace v8 {
-namespace internal {
-
-struct Register;
-
-class SafepointEntry BASE_EMBEDDED {
- public:
-  SafepointEntry() : info_(0), bits_(NULL) {}
-
-  SafepointEntry(unsigned info, uint8_t* bits) : info_(info), bits_(bits) {
-    ASSERT(is_valid());
-  }
-
-  bool is_valid() const { return bits_ != NULL; }
-
-  bool Equals(const SafepointEntry& other) const {
-    return info_ == other.info_ && bits_ == other.bits_;
-  }
-
-  void Reset() {
-    info_ = 0;
-    bits_ = NULL;
-  }
-
-  int deoptimization_index() const {
-    ASSERT(is_valid());
-    return DeoptimizationIndexField::decode(info_);
-  }
-
-  int gap_code_size() const {
-    ASSERT(is_valid());
-    return GapCodeSizeField::decode(info_);
-  }
-
-  int argument_count() const {
-    ASSERT(is_valid());
-    return ArgumentsField::decode(info_);
-  }
-
-  bool has_doubles() const {
-    ASSERT(is_valid());
-    return SaveDoublesField::decode(info_);
-  }
-
-  uint8_t* bits() {
-    ASSERT(is_valid());
-    return bits_;
-  }
-
-  bool HasRegisters() const;
-  bool HasRegisterAt(int reg_index) const;
-
-  // Reserve 13 bits for the gap code size. On ARM a constant pool can be
-  // emitted when generating the gap code. The size of the const pool is less
-  // than what can be represented in 12 bits, so 13 bits gives room for having
-  // instructions before potentially emitting a constant pool.
-  static const int kGapCodeSizeBits = 13;
-  static const int kArgumentsFieldBits = 3;
-  static const int kSaveDoublesFieldBits = 1;
-  static const int kDeoptIndexBits =
-      32 - kGapCodeSizeBits - kArgumentsFieldBits - kSaveDoublesFieldBits;
-  class GapCodeSizeField: public BitField<unsigned, 0, kGapCodeSizeBits> {};
-  class DeoptimizationIndexField: public BitField<int,
-                                                  kGapCodeSizeBits,
-                                                  kDeoptIndexBits> {};  // NOLINT
-  class ArgumentsField: public BitField<unsigned,
-                                        kGapCodeSizeBits + kDeoptIndexBits,
-                                        kArgumentsFieldBits> {};  // NOLINT
-  class SaveDoublesField: public BitField<bool,
-                                          kGapCodeSizeBits + kDeoptIndexBits +
-                                          kArgumentsFieldBits,
-                                          kSaveDoublesFieldBits> { }; // NOLINT
-
- private:
-  unsigned info_;
-  uint8_t* bits_;
-};
-
-
-class SafepointTable BASE_EMBEDDED {
- public:
-  explicit SafepointTable(Code* code);
-
-  int size() const {
-    return kHeaderSize +
-           (length_ * (kPcAndDeoptimizationIndexSize + entry_size_)); }
-  unsigned length() const { return length_; }
-  unsigned entry_size() const { return entry_size_; }
-
-  unsigned GetPcOffset(unsigned index) const {
-    ASSERT(index < length_);
-    return Memory::uint32_at(GetPcOffsetLocation(index));
-  }
-
-  SafepointEntry GetEntry(unsigned index) const {
-    ASSERT(index < length_);
-    unsigned info = Memory::uint32_at(GetInfoLocation(index));
-    uint8_t* bits = &Memory::uint8_at(entries_ + (index * entry_size_));
-    return SafepointEntry(info, bits);
-  }
-
-  // Returns the entry for the given pc.
-  SafepointEntry FindEntry(Address pc) const;
-
-  void PrintEntry(unsigned index) const;
-
- private:
-  static const uint8_t kNoRegisters = 0xFF;
-
-  static const int kLengthOffset = 0;
-  static const int kEntrySizeOffset = kLengthOffset + kIntSize;
-  static const int kHeaderSize = kEntrySizeOffset + kIntSize;
-
-  static const int kPcSize = kIntSize;
-  static const int kDeoptimizationIndexSize = kIntSize;
-  static const int kPcAndDeoptimizationIndexSize =
-      kPcSize + kDeoptimizationIndexSize;
-
-  Address GetPcOffsetLocation(unsigned index) const {
-    return pc_and_deoptimization_indexes_ +
-           (index * kPcAndDeoptimizationIndexSize);
-  }
-
-  Address GetInfoLocation(unsigned index) const {
-    return GetPcOffsetLocation(index) + kPcSize;
-  }
-
-  static void PrintBits(uint8_t byte, int digits);
-
-  AssertNoAllocation no_allocation_;
-  Code* code_;
-  unsigned length_;
-  unsigned entry_size_;
-
-  Address pc_and_deoptimization_indexes_;
-  Address entries_;
-
-  friend class SafepointTableBuilder;
-  friend class SafepointEntry;
-
-  DISALLOW_COPY_AND_ASSIGN(SafepointTable);
-};
-
-
-class Safepoint BASE_EMBEDDED {
- public:
-  typedef enum {
-    kSimple = 0,
-    kWithRegisters = 1 << 0,
-    kWithDoubles = 1 << 1,
-    kWithRegistersAndDoubles = kWithRegisters | kWithDoubles
-  } Kind;
-
-  static const int kNoDeoptimizationIndex =
-      (1 << (SafepointEntry::kDeoptIndexBits)) - 1;
-
-  void DefinePointerSlot(int index) { indexes_->Add(index); }
-  void DefinePointerRegister(Register reg);
-
- private:
-  Safepoint(ZoneList<int>* indexes, ZoneList<int>* registers) :
-      indexes_(indexes), registers_(registers) { }
-  ZoneList<int>* indexes_;
-  ZoneList<int>* registers_;
-
-  friend class SafepointTableBuilder;
-};
-
-
-class SafepointTableBuilder BASE_EMBEDDED {
- public:
-  SafepointTableBuilder()
-      : deoptimization_info_(32),
-        indexes_(32),
-        registers_(32),
-        emitted_(false) { }
-
-  // Get the offset of the emitted safepoint table in the code.
-  unsigned GetCodeOffset() const;
-
-  // Define a new safepoint for the current position in the body.
-  Safepoint DefineSafepoint(Assembler* assembler,
-                            Safepoint::Kind kind,
-                            int arguments,
-                            int deoptimization_index);
-
-  // Update the last safepoint with the size of the code generated until the
-  // end of the gap following it.
-  void SetPcAfterGap(int pc) {
-    ASSERT(!deoptimization_info_.is_empty());
-    int index = deoptimization_info_.length() - 1;
-    deoptimization_info_[index].pc_after_gap = pc;
-  }
-
-  // Get the end pc offset of the last safepoint, including the code generated
-  // until the end of the gap following it.
-  unsigned GetPcAfterGap() {
-    int index = deoptimization_info_.length();
-    if (index == 0) return 0;
-    return deoptimization_info_[index - 1].pc_after_gap;
-  }
-
-  // Emit the safepoint table after the body. The number of bits per
-  // entry must be enough to hold all the pointer indexes.
-  void Emit(Assembler* assembler, int bits_per_entry);
-
-  // Count the number of deoptimization points where the next
-  // following deoptimization point comes less than limit bytes
-  // after the end of this point's gap.
-  int CountShortDeoptimizationIntervals(unsigned limit);
-
- private:
-  struct DeoptimizationInfo {
-    unsigned pc;
-    unsigned deoptimization_index;
-    unsigned pc_after_gap;
-    unsigned arguments;
-    bool has_doubles;
-  };
-
-  uint32_t EncodeExceptPC(const DeoptimizationInfo& info);
-
-  ZoneList<DeoptimizationInfo> deoptimization_info_;
-  ZoneList<ZoneList<int>*> indexes_;
-  ZoneList<ZoneList<int>*> registers_;
-
-  unsigned offset_;
-  bool emitted_;
-
-  DISALLOW_COPY_AND_ASSIGN(SafepointTableBuilder);
-};
-
-} }  // namespace v8::internal
-
-#endif  // V8_SAFEPOINT_TABLE_H_