Fix deoptimization address patching in Turbofan to use safepoints.

src/deoptimizer.cc

 // Copyright 2013 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/accessors.h"
 #include "src/codegen.h"
 #include "src/deoptimizer.h"
 #include "src/disasm.h"
@@ skipping 424 matching lines @@
 
       // We might be in the middle of incremental marking with compaction.
       // Tell collector to treat this code object in a special way and
       // ignore all slots that might have been recorded on it.
       isolate->heap()->mark_compact_collector()->InvalidateCode(codes[i]);
     }
   }
 }
 
 
-static int FindPatchAddressForReturnAddress(Code* code, int pc) {
-  DeoptimizationInputData* input_data =
-      DeoptimizationInputData::cast(code->deoptimization_data());
-  int patch_count = input_data->ReturnAddressPatchCount();
-  for (int i = 0; i < patch_count; i++) {
-    int return_pc = input_data->ReturnAddressPc(i)->value();
-    int patch_pc = input_data->PatchedAddressPc(i)->value();
-    // If the supplied pc matches the return pc or if the address
-    // has been already patched, return the patch pc.
-    if (pc == return_pc || pc == patch_pc) {
-      return patch_pc;
-    }
-  }
-  return -1;
-}
-
-
 // For all marked Turbofanned code on stack, change the return address to go
 // to the deoptimization block.
 void Deoptimizer::PatchStackForMarkedCode(Isolate* isolate) {
   // TODO(jarin) We should tolerate missing patch entry for the topmost frame.
   for (StackFrameIterator it(isolate, isolate->thread_local_top()); !it.done();
        it.Advance()) {
     StackFrame::Type type = it.frame()->type();
     if (type == StackFrame::OPTIMIZED) {
       Code* code = it.frame()->LookupCode();
       if (code->is_turbofanned() && code->marked_for_deoptimization()) {
         JSFunction* function =
             static_cast<OptimizedFrame*>(it.frame())->function();
         Address* pc_address = it.frame()->pc_address();
         int pc_offset =
             static_cast<int>(*pc_address - code->instruction_start());
-        int new_pc_offset = FindPatchAddressForReturnAddress(code, pc_offset);
+        SafepointEntry safepoint_entry = code->GetSafepointEntry(*pc_address);
+        unsigned new_pc_offset = safepoint_entry.deoptimization_pc();
 
         if (FLAG_trace_deopt) {
           CodeTracer::Scope scope(isolate->GetCodeTracer());
           PrintF(scope.file(), "[patching stack address for function: ");
           function->PrintName(scope.file());
           PrintF(scope.file(), " (Pc offset %i -> %i)]\n", pc_offset,
                  new_pc_offset);
         }
 
-        CHECK_LE(0, new_pc_offset);
-        *pc_address += new_pc_offset - pc_offset;
+        CHECK(new_pc_offset != Safepoint::kNoDeoptimizationPc);
+        *pc_address += static_cast<int>(new_pc_offset) - pc_offset;
       }
     }
   }
 }
 
 
 void Deoptimizer::DeoptimizeAll(Isolate* isolate) {
   if (FLAG_trace_deopt) {
     CodeTracer::Scope scope(isolate->GetCodeTracer());
     PrintF(scope.file(), "[deoptimize all code in all contexts]\n");
@@ skipping 3178 matching lines @@
 }
 
 
 void DeoptimizedFrameInfo::Iterate(ObjectVisitor* v) {
   v->VisitPointer(BitCast<Object**>(&function_));
   v->VisitPointers(parameters_, parameters_ + parameters_count_);
   v->VisitPointers(expression_stack_, expression_stack_ + expression_count_);
 }
 
 } }  // namespace v8::internal