Update V8 to r6101 as required by WebKit r74534
Change-Id: I7f84af8dd732f11898fd644b2c2b1538914cb78d
diff --git a/src/safepoint-table.cc b/src/safepoint-table.cc
new file mode 100644
index 0000000..b9468a5
--- /dev/null
+++ b/src/safepoint-table.cc
@@ -0,0 +1,210 @@
+// Copyright 2010 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 "safepoint-table.h"
+#include "disasm.h"
+
+namespace v8 {
+namespace internal {
+
+SafepointTable::SafepointTable(Code* code) {
+ ASSERT(code->kind() == Code::OPTIMIZED_FUNCTION);
+ code_ = code;
+ Address header = code->instruction_start() + code->safepoint_table_start();
+ 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(DeoptimizationIndexField::max(), Safepoint::kNoDeoptimizationIndex);
+}
+
+
+bool SafepointTable::HasRegisters(uint8_t* entry) {
+ ASSERT(IsAligned(kNumSafepointRegisters, kBitsPerByte));
+ const int num_reg_bytes = kNumSafepointRegisters >> kBitsPerByteLog2;
+ for (int i = 0; i < num_reg_bytes; i++) {
+ if (entry[i] != kNoRegisters) return true;
+ }
+ return false;
+}
+
+
+bool SafepointTable::HasRegisterAt(uint8_t* entry, int reg_index) {
+ ASSERT(reg_index >= 0 && reg_index < kNumSafepointRegisters);
+ int byte_index = reg_index >> kBitsPerByteLog2;
+ int bit_index = reg_index & (kBitsPerByte - 1);
+ return (entry[byte_index] & (1 << bit_index)) != 0;
+}
+
+
+void SafepointTable::PrintEntry(unsigned index) const {
+ disasm::NameConverter converter;
+ uint8_t* entry = GetEntry(index);
+
+ // 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(entry[i], kBitsPerByte);
+ int last_bits = code_->stack_slots() - ((last - first) * kBitsPerByte);
+ PrintBits(entry[last], last_bits);
+
+ // Print the registers (if any).
+ if (!HasRegisters(entry)) return;
+ for (int j = 0; j < kNumSafepointRegisters; j++) {
+ if (HasRegisterAt(entry, 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');
+ }
+}
+
+
+Safepoint SafepointTableBuilder::DefineSafepoint(Assembler* assembler,
+ int deoptimization_index) {
+ ASSERT(deoptimization_index != -1);
+ 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();
+ deoptimization_info_.Add(pc_and_deoptimization_index);
+ indexes_.Add(new ZoneList<int>(8));
+ registers_.Add(NULL);
+ return Safepoint(indexes_.last(), registers_.last());
+}
+
+
+Safepoint SafepointTableBuilder::DefineSafepointWithRegisters(
+ Assembler* assembler, int arguments, int deoptimization_index) {
+ ASSERT(deoptimization_index != -1);
+ ASSERT(arguments == 0); // Only case that works for now.
+ 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();
+ deoptimization_info_.Add(pc_and_deoptimization_index);
+ indexes_.Add(new ZoneList<int>(8));
+ registers_.Add(new ZoneList<int>(4));
+ return Safepoint(indexes_.last(), registers_.last());
+}
+
+
+unsigned SafepointTableBuilder::GetCodeOffset() const {
+ ASSERT(emitted_);
+ return offset_;
+}
+
+
+void SafepointTableBuilder::Emit(Assembler* assembler, int bits_per_entry) {
+ // 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(EncodeDeoptimizationIndexAndGap(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::EncodeDeoptimizationIndexAndGap(
+ DeoptimizationInfo info) {
+ unsigned index = info.deoptimization_index;
+ unsigned gap_size = info.pc_after_gap - info.pc;
+ uint32_t encoding = SafepointTable::DeoptimizationIndexField::encode(index);
+ encoding |= SafepointTable::GapCodeSizeField::encode(gap_size);
+ return encoding;
+}
+
+
+} } // namespace v8::internal