Remove deoptimization by patching the call stack.

src/safepoint-table.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/safepoint-table.h"
 
 #include "src/deoptimizer.h"
 #include "src/disasm.h"
@@ skipping 25 matching lines @@
 }
 
 
 SafepointTable::SafepointTable(Code* code) {
   DCHECK(code->is_crankshafted());
   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_ * kPcAndDeoptimizationInfoSize);
+  entries_ = pc_and_deoptimization_indexes_ +
+             (length_ * kPcAndDeoptimizationIndexSize);
   DCHECK(entry_size_ > 0);
   STATIC_ASSERT(SafepointEntry::DeoptimizationIndexField::kMax ==
                 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);
-    if (GetDeoptimizationPcOffset(i) == pc_offset) return GetEntry(i);
   }
   return SafepointEntry();
 }
 
 
 void SafepointTable::PrintEntry(unsigned index, OStream& os) const {  // NOLINT
   disasm::NameConverter converter;
   SafepointEntry entry = GetEntry(index);
   uint8_t* bits = entry.bits();
 
@@ skipping 34 matching lines @@
 Safepoint SafepointTableBuilder::DefineSafepoint(
     Assembler* assembler,
     Safepoint::Kind kind,
     int arguments,
     Safepoint::DeoptMode deopt_mode) {
   DCHECK(arguments >= 0);
   DeoptimizationInfo info;
   info.pc = assembler->pc_offset();
   info.arguments = arguments;
   info.has_doubles = (kind & Safepoint::kWithDoubles);
-  info.deoptimization_pc = Safepoint::kNoDeoptimizationPc;
-  int safepoint_id = deoptimization_info_.length();
   deoptimization_info_.Add(info, zone_);
   deopt_index_list_.Add(Safepoint::kNoDeoptimizationIndex, zone_);
   if (deopt_mode == Safepoint::kNoLazyDeopt) {
     last_lazy_safepoint_ = deopt_index_list_.length();
   }
   indexes_.Add(new(zone_) ZoneList<int>(8, zone_), zone_);
   registers_.Add((kind & Safepoint::kWithRegisters)
       ? new(zone_) ZoneList<int>(4, zone_)
       : NULL,
       zone_);
-  return Safepoint(safepoint_id, indexes_.last(), registers_.last());
+  return Safepoint(indexes_.last(), registers_.last());
 }
 
 
 void SafepointTableBuilder::RecordLazyDeoptimizationIndex(int index) {
   while (last_lazy_safepoint_ < deopt_index_list_.length()) {
     deopt_index_list_[last_lazy_safepoint_++] = index;
   }
 }
 
 unsigned SafepointTableBuilder::GetCodeOffset() const {
@@ skipping 18 matching lines @@
   // 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.
   for (int i = 0; i < length; i++) {
     assembler->dd(deoptimization_info_[i].pc);
     assembler->dd(EncodeExceptPC(deoptimization_info_[i],
                                  deopt_index_list_[i]));
-    assembler->dd(deoptimization_info_[i].deoptimization_pc);
   }
 
   // Emit table of bitmaps.
   ZoneList<uint8_t> bits(bytes_per_entry, zone_);
   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, zone_);
 
@@ skipping 35 matching lines @@
                                                unsigned index) {
   uint32_t encoding = SafepointEntry::DeoptimizationIndexField::encode(index);
   encoding |= SafepointEntry::ArgumentsField::encode(info.arguments);
   encoding |= SafepointEntry::SaveDoublesField::encode(info.has_doubles);
   return encoding;
 }
 
 
 
 } }  // namespace v8::internal